Subversion Repositories SmartDukaan

Rev

Rev 7382 | Rev 7460 | 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 
 
749 
 
5944 mandeep.dh 750 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
751 
  def __init__(self, iprot, oprot=None):
752 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
753 
 
754 
  def addItem(self, item):
755 
    """
756 
    Availability and inventory attributes
757 
 
758 
    Parameters:
759 
     - item
760 
    """
761 
    self.send_addItem(item)
762 
    return self.recv_addItem()
763 
 
764 
  def send_addItem(self, item):
765 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
766 
    args = addItem_args()
767 
    args.item = item
768 
    args.write(self._oprot)
769 
    self._oprot.writeMessageEnd()
770 
    self._oprot.trans.flush()
771 
 
772 
  def recv_addItem(self, ):
773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
774 
    if mtype == TMessageType.EXCEPTION:
775 
      x = TApplicationException()
776 
      x.read(self._iprot)
777 
      self._iprot.readMessageEnd()
778 
      raise x
779 
    result = addItem_result()
780 
    result.read(self._iprot)
781 
    self._iprot.readMessageEnd()
782 
    if result.success is not None:
783 
      return result.success
784 
    if result.cex is not None:
785 
      raise result.cex
786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
787 
 
788 
  def updateItem(self, item):
789 
    """
790 
    Parameters:
791 
     - item
792 
    """
793 
    self.send_updateItem(item)
794 
    return self.recv_updateItem()
795 
 
796 
  def send_updateItem(self, item):
797 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
798 
    args = updateItem_args()
799 
    args.item = item
800 
    args.write(self._oprot)
801 
    self._oprot.writeMessageEnd()
802 
    self._oprot.trans.flush()
803 
 
804 
  def recv_updateItem(self, ):
805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
806 
    if mtype == TMessageType.EXCEPTION:
807 
      x = TApplicationException()
808 
      x.read(self._iprot)
809 
      self._iprot.readMessageEnd()
810 
      raise x
811 
    result = updateItem_result()
812 
    result.read(self._iprot)
813 
    self._iprot.readMessageEnd()
814 
    if result.success is not None:
815 
      return result.success
816 
    if result.cex is not None:
817 
      raise result.cex
818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
819 
 
820 
  def isActive(self, itemId):
821 
    """
822 
    Checks if the item given to the corresponding itemId is active. If it's active,
823 
    whether it's risky and if it's risky, its inventory position.
824 
 
825 
    Parameters:
826 
     - itemId
827 
    """
828 
    self.send_isActive(itemId)
829 
    return self.recv_isActive()
830 
 
831 
  def send_isActive(self, itemId):
832 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
833 
    args = isActive_args()
834 
    args.itemId = itemId
835 
    args.write(self._oprot)
836 
    self._oprot.writeMessageEnd()
837 
    self._oprot.trans.flush()
838 
 
839 
  def recv_isActive(self, ):
840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
841 
    if mtype == TMessageType.EXCEPTION:
842 
      x = TApplicationException()
843 
      x.read(self._iprot)
844 
      self._iprot.readMessageEnd()
845 
      raise x
846 
    result = isActive_result()
847 
    result.read(self._iprot)
848 
    self._iprot.readMessageEnd()
849 
    if result.success is not None:
850 
      return result.success
851 
    if result.isex is not None:
852 
      raise result.isex
853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
854 
 
7438 amit.gupta 855 
  def getItemsStatus(self, itemIds):
856 
    """
857 
    Parameters:
858 
     - itemIds
859 
    """
860 
    self.send_getItemsStatus(itemIds)
861 
    return self.recv_getItemsStatus()
862 
 
863 
  def send_getItemsStatus(self, itemIds):
864 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
865 
    args = getItemsStatus_args()
866 
    args.itemIds = itemIds
867 
    args.write(self._oprot)
868 
    self._oprot.writeMessageEnd()
869 
    self._oprot.trans.flush()
870 
 
871 
  def recv_getItemsStatus(self, ):
872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
873 
    if mtype == TMessageType.EXCEPTION:
874 
      x = TApplicationException()
875 
      x.read(self._iprot)
876 
      self._iprot.readMessageEnd()
877 
      raise x
878 
    result = getItemsStatus_result()
879 
    result.read(self._iprot)
880 
    self._iprot.readMessageEnd()
881 
    if result.success is not None:
882 
      return result.success
883 
    if result.isex is not None:
884 
      raise result.isex
885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
886 
 
5944 mandeep.dh 887 
  def getItemStatusDescription(self, itemId):
888 
    """
889 
    Parameters:
890 
     - itemId
891 
    """
892 
    self.send_getItemStatusDescription(itemId)
893 
    return self.recv_getItemStatusDescription()
894 
 
895 
  def send_getItemStatusDescription(self, itemId):
896 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
897 
    args = getItemStatusDescription_args()
898 
    args.itemId = itemId
899 
    args.write(self._oprot)
900 
    self._oprot.writeMessageEnd()
901 
    self._oprot.trans.flush()
902 
 
903 
  def recv_getItemStatusDescription(self, ):
904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
905 
    if mtype == TMessageType.EXCEPTION:
906 
      x = TApplicationException()
907 
      x.read(self._iprot)
908 
      self._iprot.readMessageEnd()
909 
      raise x
910 
    result = getItemStatusDescription_result()
911 
    result.read(self._iprot)
912 
    self._iprot.readMessageEnd()
913 
    if result.success is not None:
914 
      return result.success
915 
    if result.isex is not None:
916 
      raise result.isex
917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
918 
 
919 
  def startItemOn(self, item_id, timestamp):
920 
    """
921 
    Parameters:
922 
     - item_id
923 
     - timestamp
924 
    """
925 
    self.send_startItemOn(item_id, timestamp)
926 
    self.recv_startItemOn()
927 
 
928 
  def send_startItemOn(self, item_id, timestamp):
929 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
930 
    args = startItemOn_args()
931 
    args.item_id = item_id
932 
    args.timestamp = timestamp
933 
    args.write(self._oprot)
934 
    self._oprot.writeMessageEnd()
935 
    self._oprot.trans.flush()
936 
 
937 
  def recv_startItemOn(self, ):
938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
939 
    if mtype == TMessageType.EXCEPTION:
940 
      x = TApplicationException()
941 
      x.read(self._iprot)
942 
      self._iprot.readMessageEnd()
943 
      raise x
944 
    result = startItemOn_result()
945 
    result.read(self._iprot)
946 
    self._iprot.readMessageEnd()
947 
    if result.cex is not None:
948 
      raise result.cex
949 
    return
950 
 
951 
  def retireItemOn(self, item_id, timestamp):
952 
    """
953 
    Parameters:
954 
     - item_id
955 
     - timestamp
956 
    """
957 
    self.send_retireItemOn(item_id, timestamp)
958 
    self.recv_retireItemOn()
959 
 
960 
  def send_retireItemOn(self, item_id, timestamp):
961 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
962 
    args = retireItemOn_args()
963 
    args.item_id = item_id
964 
    args.timestamp = timestamp
965 
    args.write(self._oprot)
966 
    self._oprot.writeMessageEnd()
967 
    self._oprot.trans.flush()
968 
 
969 
  def recv_retireItemOn(self, ):
970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
971 
    if mtype == TMessageType.EXCEPTION:
972 
      x = TApplicationException()
973 
      x.read(self._iprot)
974 
      self._iprot.readMessageEnd()
975 
      raise x
976 
    result = retireItemOn_result()
977 
    result.read(self._iprot)
978 
    self._iprot.readMessageEnd()
979 
    if result.cex is not None:
980 
      raise result.cex
981 
    return
982 
 
983 
  def changeItemStatus(self, item_id, timestamp, newstatus):
984 
    """
985 
    Parameters:
986 
     - item_id
987 
     - timestamp
988 
     - newstatus
989 
    """
990 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
991 
    self.recv_changeItemStatus()
992 
 
993 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
994 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
995 
    args = changeItemStatus_args()
996 
    args.item_id = item_id
997 
    args.timestamp = timestamp
998 
    args.newstatus = newstatus
999 
    args.write(self._oprot)
1000 
    self._oprot.writeMessageEnd()
1001 
    self._oprot.trans.flush()
1002 
 
1003 
  def recv_changeItemStatus(self, ):
1004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1005 
    if mtype == TMessageType.EXCEPTION:
1006 
      x = TApplicationException()
1007 
      x.read(self._iprot)
1008 
      self._iprot.readMessageEnd()
1009 
      raise x
1010 
    result = changeItemStatus_result()
1011 
    result.read(self._iprot)
1012 
    self._iprot.readMessageEnd()
1013 
    if result.cex is not None:
1014 
      raise result.cex
1015 
    return
1016 
 
1017 
  def getItem(self, item_id):
1018 
    """
1019 
    Parameters:
1020 
     - item_id
1021 
    """
1022 
    self.send_getItem(item_id)
1023 
    return self.recv_getItem()
1024 
 
1025 
  def send_getItem(self, item_id):
1026 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1027 
    args = getItem_args()
1028 
    args.item_id = item_id
1029 
    args.write(self._oprot)
1030 
    self._oprot.writeMessageEnd()
1031 
    self._oprot.trans.flush()
1032 
 
1033 
  def recv_getItem(self, ):
1034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1035 
    if mtype == TMessageType.EXCEPTION:
1036 
      x = TApplicationException()
1037 
      x.read(self._iprot)
1038 
      self._iprot.readMessageEnd()
1039 
      raise x
1040 
    result = getItem_result()
1041 
    result.read(self._iprot)
1042 
    self._iprot.readMessageEnd()
1043 
    if result.success is not None:
1044 
      return result.success
1045 
    if result.cex is not None:
1046 
      raise result.cex
1047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1048 
 
1049 
  def getItemsByCatalogId(self, catalog_item_id):
1050 
    """
1051 
    Parameters:
1052 
     - catalog_item_id
1053 
    """
1054 
    self.send_getItemsByCatalogId(catalog_item_id)
1055 
    return self.recv_getItemsByCatalogId()
1056 
 
1057 
  def send_getItemsByCatalogId(self, catalog_item_id):
1058 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1059 
    args = getItemsByCatalogId_args()
1060 
    args.catalog_item_id = catalog_item_id
1061 
    args.write(self._oprot)
1062 
    self._oprot.writeMessageEnd()
1063 
    self._oprot.trans.flush()
1064 
 
1065 
  def recv_getItemsByCatalogId(self, ):
1066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1067 
    if mtype == TMessageType.EXCEPTION:
1068 
      x = TApplicationException()
1069 
      x.read(self._iprot)
1070 
      self._iprot.readMessageEnd()
1071 
      raise x
1072 
    result = getItemsByCatalogId_result()
1073 
    result.read(self._iprot)
1074 
    self._iprot.readMessageEnd()
1075 
    if result.success is not None:
1076 
      return result.success
1077 
    if result.cex is not None:
1078 
      raise result.cex
1079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1080 
 
1081 
  def getValidItemsByCatalogId(self, catalog_item_id):
1082 
    """
1083 
    Parameters:
1084 
     - catalog_item_id
1085 
    """
1086 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1087 
    return self.recv_getValidItemsByCatalogId()
1088 
 
1089 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1090 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1091 
    args = getValidItemsByCatalogId_args()
1092 
    args.catalog_item_id = catalog_item_id
1093 
    args.write(self._oprot)
1094 
    self._oprot.writeMessageEnd()
1095 
    self._oprot.trans.flush()
1096 
 
1097 
  def recv_getValidItemsByCatalogId(self, ):
1098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1099 
    if mtype == TMessageType.EXCEPTION:
1100 
      x = TApplicationException()
1101 
      x.read(self._iprot)
1102 
      self._iprot.readMessageEnd()
1103 
      raise x
1104 
    result = getValidItemsByCatalogId_result()
1105 
    result.read(self._iprot)
1106 
    self._iprot.readMessageEnd()
1107 
    if result.success is not None:
1108 
      return result.success
1109 
    if result.cex is not None:
1110 
      raise result.cex
1111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1112 
 
1113 
  def getAllItems(self, isActive):
1114 
    """
1115 
    Parameters:
1116 
     - isActive
1117 
    """
1118 
    self.send_getAllItems(isActive)
1119 
    return self.recv_getAllItems()
1120 
 
1121 
  def send_getAllItems(self, isActive):
1122 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1123 
    args = getAllItems_args()
1124 
    args.isActive = isActive
1125 
    args.write(self._oprot)
1126 
    self._oprot.writeMessageEnd()
1127 
    self._oprot.trans.flush()
1128 
 
1129 
  def recv_getAllItems(self, ):
1130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1131 
    if mtype == TMessageType.EXCEPTION:
1132 
      x = TApplicationException()
1133 
      x.read(self._iprot)
1134 
      self._iprot.readMessageEnd()
1135 
      raise x
1136 
    result = getAllItems_result()
1137 
    result.read(self._iprot)
1138 
    self._iprot.readMessageEnd()
1139 
    if result.success is not None:
1140 
      return result.success
1141 
    if result.cex is not None:
1142 
      raise result.cex
1143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1144 
 
1145 
  def getAllItemsByStatus(self, itemStatus):
1146 
    """
1147 
    Parameters:
1148 
     - itemStatus
1149 
    """
1150 
    self.send_getAllItemsByStatus(itemStatus)
1151 
    return self.recv_getAllItemsByStatus()
1152 
 
1153 
  def send_getAllItemsByStatus(self, itemStatus):
1154 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1155 
    args = getAllItemsByStatus_args()
1156 
    args.itemStatus = itemStatus
1157 
    args.write(self._oprot)
1158 
    self._oprot.writeMessageEnd()
1159 
    self._oprot.trans.flush()
1160 
 
1161 
  def recv_getAllItemsByStatus(self, ):
1162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1163 
    if mtype == TMessageType.EXCEPTION:
1164 
      x = TApplicationException()
1165 
      x.read(self._iprot)
1166 
      self._iprot.readMessageEnd()
1167 
      raise x
1168 
    result = getAllItemsByStatus_result()
1169 
    result.read(self._iprot)
1170 
    self._iprot.readMessageEnd()
1171 
    if result.success is not None:
1172 
      return result.success
1173 
    if result.cex is not None:
1174 
      raise result.cex
1175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1176 
 
1177 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1178 
    """
1179 
    Parameters:
1180 
     - entityId
1181 
     - category
1182 
     - brand
1183 
     - modelName
1184 
     - modelNumber
1185 
    """
1186 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1187 
    return self.recv_markItemAsContentComplete()
1188 
 
1189 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1190 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1191 
    args = markItemAsContentComplete_args()
1192 
    args.entityId = entityId
1193 
    args.category = category
1194 
    args.brand = brand
1195 
    args.modelName = modelName
1196 
    args.modelNumber = modelNumber
1197 
    args.write(self._oprot)
1198 
    self._oprot.writeMessageEnd()
1199 
    self._oprot.trans.flush()
1200 
 
1201 
  def recv_markItemAsContentComplete(self, ):
1202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1203 
    if mtype == TMessageType.EXCEPTION:
1204 
      x = TApplicationException()
1205 
      x.read(self._iprot)
1206 
      self._iprot.readMessageEnd()
1207 
      raise x
1208 
    result = markItemAsContentComplete_result()
1209 
    result.read(self._iprot)
1210 
    self._iprot.readMessageEnd()
1211 
    if result.success is not None:
1212 
      return result.success
1213 
    if result.cex is not None:
1214 
      raise result.cex
1215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1216 
 
1217 
  def getAllItemsInRange(self, offset, limit):
1218 
    """
1219 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1220 
 
1221 
    Parameters:
1222 
     - offset
1223 
     - limit
1224 
    """
1225 
    self.send_getAllItemsInRange(offset, limit)
1226 
    return self.recv_getAllItemsInRange()
1227 
 
1228 
  def send_getAllItemsInRange(self, offset, limit):
1229 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1230 
    args = getAllItemsInRange_args()
1231 
    args.offset = offset
1232 
    args.limit = limit
1233 
    args.write(self._oprot)
1234 
    self._oprot.writeMessageEnd()
1235 
    self._oprot.trans.flush()
1236 
 
1237 
  def recv_getAllItemsInRange(self, ):
1238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1239 
    if mtype == TMessageType.EXCEPTION:
1240 
      x = TApplicationException()
1241 
      x.read(self._iprot)
1242 
      self._iprot.readMessageEnd()
1243 
      raise x
1244 
    result = getAllItemsInRange_result()
1245 
    result.read(self._iprot)
1246 
    self._iprot.readMessageEnd()
1247 
    if result.success is not None:
1248 
      return result.success
1249 
    if result.cex is not None:
1250 
      raise result.cex
1251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1252 
 
1253 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1254 
    """
1255 
    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.
1256 
 
1257 
    Parameters:
1258 
     - itemStatus
1259 
     - offset
1260 
     - limit
1261 
    """
1262 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1263 
    return self.recv_getAllItemsByStatusInRange()
1264 
 
1265 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1266 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1267 
    args = getAllItemsByStatusInRange_args()
1268 
    args.itemStatus = itemStatus
1269 
    args.offset = offset
1270 
    args.limit = limit
1271 
    args.write(self._oprot)
1272 
    self._oprot.writeMessageEnd()
1273 
    self._oprot.trans.flush()
1274 
 
1275 
  def recv_getAllItemsByStatusInRange(self, ):
1276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1277 
    if mtype == TMessageType.EXCEPTION:
1278 
      x = TApplicationException()
1279 
      x.read(self._iprot)
1280 
      self._iprot.readMessageEnd()
1281 
      raise x
1282 
    result = getAllItemsByStatusInRange_result()
1283 
    result.read(self._iprot)
1284 
    self._iprot.readMessageEnd()
1285 
    if result.success is not None:
1286 
      return result.success
1287 
    if result.cex is not None:
1288 
      raise result.cex
1289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1290 
 
1291 
  def getItemCountByStatus(self, useStatus, itemStatus):
1292 
    """
1293 
    Gets a count of all items by status
1294 
 
1295 
    Parameters:
1296 
     - useStatus
1297 
     - itemStatus
1298 
    """
1299 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1300 
    return self.recv_getItemCountByStatus()
1301 
 
1302 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1303 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1304 
    args = getItemCountByStatus_args()
1305 
    args.useStatus = useStatus
1306 
    args.itemStatus = itemStatus
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_getItemCountByStatus(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = getItemCountByStatus_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
1321 
    if result.success is not None:
1322 
      return result.success
1323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1324 
 
1325 
  def getBestSellers(self, ):
1326 
    self.send_getBestSellers()
1327 
    return self.recv_getBestSellers()
1328 
 
1329 
  def send_getBestSellers(self, ):
1330 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1331 
    args = getBestSellers_args()
1332 
    args.write(self._oprot)
1333 
    self._oprot.writeMessageEnd()
1334 
    self._oprot.trans.flush()
1335 
 
1336 
  def recv_getBestSellers(self, ):
1337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1338 
    if mtype == TMessageType.EXCEPTION:
1339 
      x = TApplicationException()
1340 
      x.read(self._iprot)
1341 
      self._iprot.readMessageEnd()
1342 
      raise x
1343 
    result = getBestSellers_result()
1344 
    result.read(self._iprot)
1345 
    self._iprot.readMessageEnd()
1346 
    if result.success is not None:
1347 
      return result.success
1348 
    if result.isex is not None:
1349 
      raise result.isex
1350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1351 
 
1352 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1353 
    """
1354 
    Parameters:
1355 
     - beginIndex
1356 
     - totalItems
1357 
     - brand
1358 
     - category
1359 
    """
1360 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1361 
    return self.recv_getBestSellersCatalogIds()
1362 
 
1363 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1364 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1365 
    args = getBestSellersCatalogIds_args()
1366 
    args.beginIndex = beginIndex
1367 
    args.totalItems = totalItems
1368 
    args.brand = brand
1369 
    args.category = category
1370 
    args.write(self._oprot)
1371 
    self._oprot.writeMessageEnd()
1372 
    self._oprot.trans.flush()
1373 
 
1374 
  def recv_getBestSellersCatalogIds(self, ):
1375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1376 
    if mtype == TMessageType.EXCEPTION:
1377 
      x = TApplicationException()
1378 
      x.read(self._iprot)
1379 
      self._iprot.readMessageEnd()
1380 
      raise x
1381 
    result = getBestSellersCatalogIds_result()
1382 
    result.read(self._iprot)
1383 
    self._iprot.readMessageEnd()
1384 
    if result.success is not None:
1385 
      return result.success
1386 
    if result.cex is not None:
1387 
      raise result.cex
1388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1389 
 
1390 
  def getBestSellersCount(self, ):
1391 
    self.send_getBestSellersCount()
1392 
    return self.recv_getBestSellersCount()
1393 
 
1394 
  def send_getBestSellersCount(self, ):
1395 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1396 
    args = getBestSellersCount_args()
1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getBestSellersCount(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getBestSellersCount_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success is not None:
1412 
      return result.success
1413 
    if result.cex is not None:
1414 
      raise result.cex
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1416 
 
1417 
  def getBestDeals(self, ):
1418 
    self.send_getBestDeals()
1419 
    return self.recv_getBestDeals()
1420 
 
1421 
  def send_getBestDeals(self, ):
1422 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1423 
    args = getBestDeals_args()
1424 
    args.write(self._oprot)
1425 
    self._oprot.writeMessageEnd()
1426 
    self._oprot.trans.flush()
1427 
 
1428 
  def recv_getBestDeals(self, ):
1429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1430 
    if mtype == TMessageType.EXCEPTION:
1431 
      x = TApplicationException()
1432 
      x.read(self._iprot)
1433 
      self._iprot.readMessageEnd()
1434 
      raise x
1435 
    result = getBestDeals_result()
1436 
    result.read(self._iprot)
1437 
    self._iprot.readMessageEnd()
1438 
    if result.success is not None:
1439 
      return result.success
1440 
    if result.isex is not None:
1441 
      raise result.isex
1442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1443 
 
1444 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1445 
    """
1446 
    Parameters:
1447 
     - beginIndex
1448 
     - totalItems
1449 
     - brand
1450 
     - category
1451 
    """
1452 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1453 
    return self.recv_getBestDealsCatalogIds()
1454 
 
1455 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1456 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1457 
    args = getBestDealsCatalogIds_args()
1458 
    args.beginIndex = beginIndex
1459 
    args.totalItems = totalItems
1460 
    args.brand = brand
1461 
    args.category = category
1462 
    args.write(self._oprot)
1463 
    self._oprot.writeMessageEnd()
1464 
    self._oprot.trans.flush()
1465 
 
1466 
  def recv_getBestDealsCatalogIds(self, ):
1467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1468 
    if mtype == TMessageType.EXCEPTION:
1469 
      x = TApplicationException()
1470 
      x.read(self._iprot)
1471 
      self._iprot.readMessageEnd()
1472 
      raise x
1473 
    result = getBestDealsCatalogIds_result()
1474 
    result.read(self._iprot)
1475 
    self._iprot.readMessageEnd()
1476 
    if result.success is not None:
1477 
      return result.success
1478 
    if result.cex is not None:
1479 
      raise result.cex
1480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1481 
 
1482 
  def getBestDealsCount(self, ):
1483 
    self.send_getBestDealsCount()
1484 
    return self.recv_getBestDealsCount()
1485 
 
1486 
  def send_getBestDealsCount(self, ):
1487 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1488 
    args = getBestDealsCount_args()
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_getBestDealsCount(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = getBestDealsCount_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
1503 
    if result.success is not None:
1504 
      return result.success
1505 
    if result.cex is not None:
1506 
      raise result.cex
1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1508 
 
1509 
  def getComingSoon(self, ):
1510 
    self.send_getComingSoon()
1511 
    return self.recv_getComingSoon()
1512 
 
1513 
  def send_getComingSoon(self, ):
1514 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1515 
    args = getComingSoon_args()
1516 
    args.write(self._oprot)
1517 
    self._oprot.writeMessageEnd()
1518 
    self._oprot.trans.flush()
1519 
 
1520 
  def recv_getComingSoon(self, ):
1521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1522 
    if mtype == TMessageType.EXCEPTION:
1523 
      x = TApplicationException()
1524 
      x.read(self._iprot)
1525 
      self._iprot.readMessageEnd()
1526 
      raise x
1527 
    result = getComingSoon_result()
1528 
    result.read(self._iprot)
1529 
    self._iprot.readMessageEnd()
1530 
    if result.success is not None:
1531 
      return result.success
1532 
    if result.isex is not None:
1533 
      raise result.isex
1534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1535 
 
1536 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1537 
    """
1538 
    Parameters:
1539 
     - beginIndex
1540 
     - totalItems
1541 
     - brand
1542 
     - category
1543 
    """
1544 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1545 
    return self.recv_getComingSoonCatalogIds()
1546 
 
1547 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1548 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1549 
    args = getComingSoonCatalogIds_args()
1550 
    args.beginIndex = beginIndex
1551 
    args.totalItems = totalItems
1552 
    args.brand = brand
1553 
    args.category = category
1554 
    args.write(self._oprot)
1555 
    self._oprot.writeMessageEnd()
1556 
    self._oprot.trans.flush()
1557 
 
1558 
  def recv_getComingSoonCatalogIds(self, ):
1559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1560 
    if mtype == TMessageType.EXCEPTION:
1561 
      x = TApplicationException()
1562 
      x.read(self._iprot)
1563 
      self._iprot.readMessageEnd()
1564 
      raise x
1565 
    result = getComingSoonCatalogIds_result()
1566 
    result.read(self._iprot)
1567 
    self._iprot.readMessageEnd()
1568 
    if result.success is not None:
1569 
      return result.success
1570 
    if result.cex is not None:
1571 
      raise result.cex
1572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1573 
 
1574 
  def getComingSoonCount(self, ):
1575 
    self.send_getComingSoonCount()
1576 
    return self.recv_getComingSoonCount()
1577 
 
1578 
  def send_getComingSoonCount(self, ):
1579 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1580 
    args = getComingSoonCount_args()
1581 
    args.write(self._oprot)
1582 
    self._oprot.writeMessageEnd()
1583 
    self._oprot.trans.flush()
1584 
 
1585 
  def recv_getComingSoonCount(self, ):
1586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1587 
    if mtype == TMessageType.EXCEPTION:
1588 
      x = TApplicationException()
1589 
      x.read(self._iprot)
1590 
      self._iprot.readMessageEnd()
1591 
      raise x
1592 
    result = getComingSoonCount_result()
1593 
    result.read(self._iprot)
1594 
    self._iprot.readMessageEnd()
1595 
    if result.success is not None:
1596 
      return result.success
1597 
    if result.cex is not None:
1598 
      raise result.cex
1599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1600 
 
1601 
  def getLatestArrivals(self, ):
1602 
    """
1603 
    Returns a list of items sorted in the descending order by start date.
1604 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1605 
    """
1606 
    self.send_getLatestArrivals()
1607 
    return self.recv_getLatestArrivals()
1608 
 
1609 
  def send_getLatestArrivals(self, ):
1610 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1611 
    args = getLatestArrivals_args()
1612 
    args.write(self._oprot)
1613 
    self._oprot.writeMessageEnd()
1614 
    self._oprot.trans.flush()
1615 
 
1616 
  def recv_getLatestArrivals(self, ):
1617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1618 
    if mtype == TMessageType.EXCEPTION:
1619 
      x = TApplicationException()
1620 
      x.read(self._iprot)
1621 
      self._iprot.readMessageEnd()
1622 
      raise x
1623 
    result = getLatestArrivals_result()
1624 
    result.read(self._iprot)
1625 
    self._iprot.readMessageEnd()
1626 
    if result.success is not None:
1627 
      return result.success
1628 
    if result.isex is not None:
1629 
      raise result.isex
1630 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1631 
 
1632 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1633 
    """
1634 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1635 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1636 
 
1637 
    Parameters:
1638 
     - beginIndex
1639 
     - totalItems
1640 
     - brand
1641 
     - categories
1642 
    """
1643 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1644 
    return self.recv_getLatestArrivalsCatalogIds()
1645 
 
1646 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1647 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1648 
    args = getLatestArrivalsCatalogIds_args()
1649 
    args.beginIndex = beginIndex
1650 
    args.totalItems = totalItems
1651 
    args.brand = brand
1652 
    args.categories = categories
1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getLatestArrivalsCatalogIds(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getLatestArrivalsCatalogIds_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    if result.success is not None:
1668 
      return result.success
1669 
    if result.cex is not None:
1670 
      raise result.cex
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1672 
 
1673 
  def getLatestArrivalsCount(self, ):
1674 
    """
1675 
    Get the total number of latest arrivals we are willing to show.
1676 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1677 
    """
1678 
    self.send_getLatestArrivalsCount()
1679 
    return self.recv_getLatestArrivalsCount()
1680 
 
1681 
  def send_getLatestArrivalsCount(self, ):
1682 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1683 
    args = getLatestArrivalsCount_args()
1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
1688 
  def recv_getLatestArrivalsCount(self, ):
1689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1690 
    if mtype == TMessageType.EXCEPTION:
1691 
      x = TApplicationException()
1692 
      x.read(self._iprot)
1693 
      self._iprot.readMessageEnd()
1694 
      raise x
1695 
    result = getLatestArrivalsCount_result()
1696 
    result.read(self._iprot)
1697 
    self._iprot.readMessageEnd()
1698 
    if result.success is not None:
1699 
      return result.success
1700 
    if result.cex is not None:
1701 
      raise result.cex
1702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1703 
 
1704 
  def generateNewEntityID(self, ):
1705 
    self.send_generateNewEntityID()
1706 
    return self.recv_generateNewEntityID()
1707 
 
1708 
  def send_generateNewEntityID(self, ):
1709 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1710 
    args = generateNewEntityID_args()
1711 
    args.write(self._oprot)
1712 
    self._oprot.writeMessageEnd()
1713 
    self._oprot.trans.flush()
1714 
 
1715 
  def recv_generateNewEntityID(self, ):
1716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1717 
    if mtype == TMessageType.EXCEPTION:
1718 
      x = TApplicationException()
1719 
      x.read(self._iprot)
1720 
      self._iprot.readMessageEnd()
1721 
      raise x
1722 
    result = generateNewEntityID_result()
1723 
    result.read(self._iprot)
1724 
    self._iprot.readMessageEnd()
1725 
    if result.success is not None:
1726 
      return result.success
1727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1728 
 
1729 
  def addCategory(self, category):
1730 
    """
1731 
    All category related functions
1732 
 
1733 
    Parameters:
1734 
     - category
1735 
    """
1736 
    self.send_addCategory(category)
1737 
    return self.recv_addCategory()
1738 
 
1739 
  def send_addCategory(self, category):
1740 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1741 
    args = addCategory_args()
1742 
    args.category = category
1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_addCategory(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = addCategory_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
1757 
    if result.success is not None:
1758 
      return result.success
1759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1760 
 
1761 
  def getCategory(self, id):
1762 
    """
1763 
    Parameters:
1764 
     - id
1765 
    """
1766 
    self.send_getCategory(id)
1767 
    return self.recv_getCategory()
1768 
 
1769 
  def send_getCategory(self, id):
1770 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1771 
    args = getCategory_args()
1772 
    args.id = id
1773 
    args.write(self._oprot)
1774 
    self._oprot.writeMessageEnd()
1775 
    self._oprot.trans.flush()
1776 
 
1777 
  def recv_getCategory(self, ):
1778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1779 
    if mtype == TMessageType.EXCEPTION:
1780 
      x = TApplicationException()
1781 
      x.read(self._iprot)
1782 
      self._iprot.readMessageEnd()
1783 
      raise x
1784 
    result = getCategory_result()
1785 
    result.read(self._iprot)
1786 
    self._iprot.readMessageEnd()
1787 
    if result.success is not None:
1788 
      return result.success
1789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1790 
 
1791 
  def getAllCategories(self, ):
1792 
    self.send_getAllCategories()
1793 
    return self.recv_getAllCategories()
1794 
 
1795 
  def send_getAllCategories(self, ):
1796 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1797 
    args = getAllCategories_args()
1798 
    args.write(self._oprot)
1799 
    self._oprot.writeMessageEnd()
1800 
    self._oprot.trans.flush()
1801 
 
1802 
  def recv_getAllCategories(self, ):
1803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1804 
    if mtype == TMessageType.EXCEPTION:
1805 
      x = TApplicationException()
1806 
      x.read(self._iprot)
1807 
      self._iprot.readMessageEnd()
1808 
      raise x
1809 
    result = getAllCategories_result()
1810 
    result.read(self._iprot)
1811 
    self._iprot.readMessageEnd()
1812 
    if result.success is not None:
1813 
      return result.success
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1815 
 
1816 
  def getAllSimilarItems(self, itemId):
1817 
    """
1818 
    Returns the list of similar items.
1819 
 
1820 
    Parameters:
1821 
     - itemId
1822 
    """
1823 
    self.send_getAllSimilarItems(itemId)
1824 
    return self.recv_getAllSimilarItems()
1825 
 
1826 
  def send_getAllSimilarItems(self, itemId):
1827 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1828 
    args = getAllSimilarItems_args()
1829 
    args.itemId = itemId
1830 
    args.write(self._oprot)
1831 
    self._oprot.writeMessageEnd()
1832 
    self._oprot.trans.flush()
1833 
 
1834 
  def recv_getAllSimilarItems(self, ):
1835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1836 
    if mtype == TMessageType.EXCEPTION:
1837 
      x = TApplicationException()
1838 
      x.read(self._iprot)
1839 
      self._iprot.readMessageEnd()
1840 
      raise x
1841 
    result = getAllSimilarItems_result()
1842 
    result.read(self._iprot)
1843 
    self._iprot.readMessageEnd()
1844 
    if result.success is not None:
1845 
      return result.success
1846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1847 
 
1848 
  def addSimilarItem(self, itemId, catalogItemId):
1849 
    """
1850 
    Adds similar item.
1851 
 
1852 
    Parameters:
1853 
     - itemId
1854 
     - catalogItemId
1855 
    """
1856 
    self.send_addSimilarItem(itemId, catalogItemId)
1857 
    return self.recv_addSimilarItem()
1858 
 
1859 
  def send_addSimilarItem(self, itemId, catalogItemId):
1860 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1861 
    args = addSimilarItem_args()
1862 
    args.itemId = itemId
1863 
    args.catalogItemId = catalogItemId
1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
1868 
  def recv_addSimilarItem(self, ):
1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
1875 
    result = addSimilarItem_result()
1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success is not None:
1879 
      return result.success
1880 
    if result.cex is not None:
1881 
      raise result.cex
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1883 
 
6512 kshitij.so 1884 
  def addTag(self, displayName, itemId):
1885 
    """
1886 
    Tag Related
1887 
 
1888 
    Parameters:
1889 
     - displayName
1890 
     - itemId
1891 
    """
1892 
    self.send_addTag(displayName, itemId)
1893 
    return self.recv_addTag()
1894 
 
1895 
  def send_addTag(self, displayName, itemId):
1896 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1897 
    args = addTag_args()
1898 
    args.displayName = displayName
1899 
    args.itemId = itemId
1900 
    args.write(self._oprot)
1901 
    self._oprot.writeMessageEnd()
1902 
    self._oprot.trans.flush()
1903 
 
1904 
  def recv_addTag(self, ):
1905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1906 
    if mtype == TMessageType.EXCEPTION:
1907 
      x = TApplicationException()
1908 
      x.read(self._iprot)
1909 
      self._iprot.readMessageEnd()
1910 
      raise x
1911 
    result = addTag_result()
1912 
    result.read(self._iprot)
1913 
    self._iprot.readMessageEnd()
1914 
    if result.success is not None:
1915 
      return result.success
1916 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1917 
 
1918 
  def deleteEntityTag(self, displayName, itemId):
1919 
    """
1920 
    Parameters:
1921 
     - displayName
1922 
     - itemId
1923 
    """
1924 
    self.send_deleteEntityTag(displayName, itemId)
1925 
    return self.recv_deleteEntityTag()
1926 
 
1927 
  def send_deleteEntityTag(self, displayName, itemId):
1928 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1929 
    args = deleteEntityTag_args()
1930 
    args.displayName = displayName
1931 
    args.itemId = itemId
1932 
    args.write(self._oprot)
1933 
    self._oprot.writeMessageEnd()
1934 
    self._oprot.trans.flush()
1935 
 
1936 
  def recv_deleteEntityTag(self, ):
1937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1938 
    if mtype == TMessageType.EXCEPTION:
1939 
      x = TApplicationException()
1940 
      x.read(self._iprot)
1941 
      self._iprot.readMessageEnd()
1942 
      raise x
1943 
    result = deleteEntityTag_result()
1944 
    result.read(self._iprot)
1945 
    self._iprot.readMessageEnd()
1946 
    if result.success is not None:
1947 
      return result.success
1948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1949 
 
1950 
  def deleteTag(self, displayName):
1951 
    """
1952 
    Parameters:
1953 
     - displayName
1954 
    """
1955 
    self.send_deleteTag(displayName)
1956 
    return self.recv_deleteTag()
1957 
 
1958 
  def send_deleteTag(self, displayName):
1959 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1960 
    args = deleteTag_args()
1961 
    args.displayName = displayName
1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
1966 
  def recv_deleteTag(self, ):
1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
1973 
    result = deleteTag_result()
1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success is not None:
1977 
      return result.success
1978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1979 
 
1980 
  def getAllTags(self, ):
1981 
    self.send_getAllTags()
1982 
    return self.recv_getAllTags()
1983 
 
1984 
  def send_getAllTags(self, ):
1985 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1986 
    args = getAllTags_args()
1987 
    args.write(self._oprot)
1988 
    self._oprot.writeMessageEnd()
1989 
    self._oprot.trans.flush()
1990 
 
1991 
  def recv_getAllTags(self, ):
1992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1993 
    if mtype == TMessageType.EXCEPTION:
1994 
      x = TApplicationException()
1995 
      x.read(self._iprot)
1996 
      self._iprot.readMessageEnd()
1997 
      raise x
1998 
    result = getAllTags_result()
1999 
    result.read(self._iprot)
2000 
    self._iprot.readMessageEnd()
2001 
    if result.success is not None:
2002 
      return result.success
2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2004 
 
2005 
  def getAllEntitiesByTagName(self, displayName):
2006 
    """
2007 
    Parameters:
2008 
     - displayName
2009 
    """
2010 
    self.send_getAllEntitiesByTagName(displayName)
2011 
    return self.recv_getAllEntitiesByTagName()
2012 
 
2013 
  def send_getAllEntitiesByTagName(self, displayName):
2014 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2015 
    args = getAllEntitiesByTagName_args()
2016 
    args.displayName = displayName
2017 
    args.write(self._oprot)
2018 
    self._oprot.writeMessageEnd()
2019 
    self._oprot.trans.flush()
2020 
 
2021 
  def recv_getAllEntitiesByTagName(self, ):
2022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2023 
    if mtype == TMessageType.EXCEPTION:
2024 
      x = TApplicationException()
2025 
      x.read(self._iprot)
2026 
      self._iprot.readMessageEnd()
2027 
      raise x
2028 
    result = getAllEntitiesByTagName_result()
2029 
    result.read(self._iprot)
2030 
    self._iprot.readMessageEnd()
2031 
    if result.success is not None:
2032 
      return result.success
2033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2034 
 
6845 amit.gupta 2035 
  def getAllEntityTags(self, ):
2036 
    self.send_getAllEntityTags()
2037 
    return self.recv_getAllEntityTags()
2038 
 
2039 
  def send_getAllEntityTags(self, ):
2040 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2041 
    args = getAllEntityTags_args()
2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
2046 
  def recv_getAllEntityTags(self, ):
2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
2053 
    result = getAllEntityTags_result()
2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
2056 
    if result.success is not None:
2057 
      return result.success
2058 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2059 
 
6850 kshitij.so 2060 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2061 
    """
2062 
    Parameters:
2063 
     - bannerName
2064 
     - imageName
2065 
     - link
2066 
     - priority
2067 
     - isActive
2068 
     - hasMap
2069 
    """
2070 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2071 
    return self.recv_addBanner()
2072 
 
2073 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2074 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2075 
    args = addBanner_args()
2076 
    args.bannerName = bannerName
2077 
    args.imageName = imageName
2078 
    args.link = link
2079 
    args.priority = priority
2080 
    args.isActive = isActive
2081 
    args.hasMap = hasMap
2082 
    args.write(self._oprot)
2083 
    self._oprot.writeMessageEnd()
2084 
    self._oprot.trans.flush()
2085 
 
2086 
  def recv_addBanner(self, ):
2087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2088 
    if mtype == TMessageType.EXCEPTION:
2089 
      x = TApplicationException()
2090 
      x.read(self._iprot)
2091 
      self._iprot.readMessageEnd()
2092 
      raise x
2093 
    result = addBanner_result()
2094 
    result.read(self._iprot)
2095 
    self._iprot.readMessageEnd()
2096 
    if result.success is not None:
2097 
      return result.success
2098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2099 
 
2100 
  def getAllBanners(self, ):
2101 
    self.send_getAllBanners()
2102 
    return self.recv_getAllBanners()
2103 
 
2104 
  def send_getAllBanners(self, ):
2105 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2106 
    args = getAllBanners_args()
2107 
    args.write(self._oprot)
2108 
    self._oprot.writeMessageEnd()
2109 
    self._oprot.trans.flush()
2110 
 
2111 
  def recv_getAllBanners(self, ):
2112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2113 
    if mtype == TMessageType.EXCEPTION:
2114 
      x = TApplicationException()
2115 
      x.read(self._iprot)
2116 
      self._iprot.readMessageEnd()
2117 
      raise x
2118 
    result = getAllBanners_result()
2119 
    result.read(self._iprot)
2120 
    self._iprot.readMessageEnd()
2121 
    if result.success is not None:
2122 
      return result.success
2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2124 
 
2125 
  def deleteBanner(self, bannerName):
2126 
    """
2127 
    Parameters:
2128 
     - bannerName
2129 
    """
2130 
    self.send_deleteBanner(bannerName)
2131 
    return self.recv_deleteBanner()
2132 
 
2133 
  def send_deleteBanner(self, bannerName):
2134 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2135 
    args = deleteBanner_args()
2136 
    args.bannerName = bannerName
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
2141 
  def recv_deleteBanner(self, ):
2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
2148 
    result = deleteBanner_result()
2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
2151 
    if result.success is not None:
2152 
      return result.success
2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2154 
 
2155 
  def getBannerDetails(self, bannerName):
2156 
    """
2157 
    Parameters:
2158 
     - bannerName
2159 
    """
2160 
    self.send_getBannerDetails(bannerName)
2161 
    return self.recv_getBannerDetails()
2162 
 
2163 
  def send_getBannerDetails(self, bannerName):
2164 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2165 
    args = getBannerDetails_args()
2166 
    args.bannerName = bannerName
2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
2171 
  def recv_getBannerDetails(self, ):
2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
2178 
    result = getBannerDetails_result()
2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
2181 
    if result.success is not None:
2182 
      return result.success
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2184 
 
2185 
  def getActiveBanners(self, ):
2186 
    self.send_getActiveBanners()
2187 
    return self.recv_getActiveBanners()
2188 
 
2189 
  def send_getActiveBanners(self, ):
2190 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2191 
    args = getActiveBanners_args()
2192 
    args.write(self._oprot)
2193 
    self._oprot.writeMessageEnd()
2194 
    self._oprot.trans.flush()
2195 
 
2196 
  def recv_getActiveBanners(self, ):
2197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2198 
    if mtype == TMessageType.EXCEPTION:
2199 
      x = TApplicationException()
2200 
      x.read(self._iprot)
2201 
      self._iprot.readMessageEnd()
2202 
      raise x
2203 
    result = getActiveBanners_result()
2204 
    result.read(self._iprot)
2205 
    self._iprot.readMessageEnd()
2206 
    if result.success is not None:
2207 
      return result.success
2208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2209 
 
6849 kshitij.so 2210 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2211 
    """
2212 
    Parameters:
2213 
     - bannerName
2214 
     - mapLink
2215 
     - coordinates
2216 
    """
2217 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2218 
    return self.recv_addBannerMap()
2219 
 
2220 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2221 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2222 
    args = addBannerMap_args()
2223 
    args.bannerName = bannerName
2224 
    args.mapLink = mapLink
2225 
    args.coordinates = coordinates
2226 
    args.write(self._oprot)
2227 
    self._oprot.writeMessageEnd()
2228 
    self._oprot.trans.flush()
2229 
 
2230 
  def recv_addBannerMap(self, ):
2231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2232 
    if mtype == TMessageType.EXCEPTION:
2233 
      x = TApplicationException()
2234 
      x.read(self._iprot)
2235 
      self._iprot.readMessageEnd()
2236 
      raise x
2237 
    result = addBannerMap_result()
2238 
    result.read(self._iprot)
2239 
    self._iprot.readMessageEnd()
2240 
    if result.success is not None:
2241 
      return result.success
2242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2243 
 
2244 
  def deleteBannerMap(self, bannerName):
2245 
    """
2246 
    Parameters:
2247 
     - bannerName
2248 
    """
2249 
    self.send_deleteBannerMap(bannerName)
2250 
    return self.recv_deleteBannerMap()
2251 
 
2252 
  def send_deleteBannerMap(self, bannerName):
2253 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2254 
    args = deleteBannerMap_args()
2255 
    args.bannerName = bannerName
2256 
    args.write(self._oprot)
2257 
    self._oprot.writeMessageEnd()
2258 
    self._oprot.trans.flush()
2259 
 
2260 
  def recv_deleteBannerMap(self, ):
2261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2262 
    if mtype == TMessageType.EXCEPTION:
2263 
      x = TApplicationException()
2264 
      x.read(self._iprot)
2265 
      self._iprot.readMessageEnd()
2266 
      raise x
2267 
    result = deleteBannerMap_result()
2268 
    result.read(self._iprot)
2269 
    self._iprot.readMessageEnd()
2270 
    if result.success is not None:
2271 
      return result.success
2272 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2273 
 
2274 
  def getBannerMapDetails(self, bannerName):
2275 
    """
2276 
    Parameters:
2277 
     - bannerName
2278 
    """
2279 
    self.send_getBannerMapDetails(bannerName)
2280 
    return self.recv_getBannerMapDetails()
2281 
 
2282 
  def send_getBannerMapDetails(self, bannerName):
2283 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2284 
    args = getBannerMapDetails_args()
2285 
    args.bannerName = bannerName
2286 
    args.write(self._oprot)
2287 
    self._oprot.writeMessageEnd()
2288 
    self._oprot.trans.flush()
2289 
 
2290 
  def recv_getBannerMapDetails(self, ):
2291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2292 
    if mtype == TMessageType.EXCEPTION:
2293 
      x = TApplicationException()
2294 
      x.read(self._iprot)
2295 
      self._iprot.readMessageEnd()
2296 
      raise x
2297 
    result = getBannerMapDetails_result()
2298 
    result.read(self._iprot)
2299 
    self._iprot.readMessageEnd()
2300 
    if result.success is not None:
2301 
      return result.success
2302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2303 
 
5944 mandeep.dh 2304 
  def deleteSimilarItem(self, itemId, catalogItemId):
2305 
    """
2306 
    Delete similar item.
2307 
 
2308 
    Parameters:
2309 
     - itemId
2310 
     - catalogItemId
2311 
    """
2312 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2313 
    return self.recv_deleteSimilarItem()
2314 
 
2315 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2316 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2317 
    args = deleteSimilarItem_args()
2318 
    args.itemId = itemId
2319 
    args.catalogItemId = catalogItemId
2320 
    args.write(self._oprot)
2321 
    self._oprot.writeMessageEnd()
2322 
    self._oprot.trans.flush()
2323 
 
2324 
  def recv_deleteSimilarItem(self, ):
2325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2326 
    if mtype == TMessageType.EXCEPTION:
2327 
      x = TApplicationException()
2328 
      x.read(self._iprot)
2329 
      self._iprot.readMessageEnd()
2330 
      raise x
2331 
    result = deleteSimilarItem_result()
2332 
    result.read(self._iprot)
2333 
    self._iprot.readMessageEnd()
2334 
    if result.success is not None:
2335 
      return result.success
2336 
    if result.cex is not None:
2337 
      raise result.cex
2338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2339 
 
2340 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2341 
    """
2342 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2343 
    If yes, returns the itemId else returns 0
2344 
 
2345 
    Parameters:
2346 
     - brand
2347 
     - modelNumber
2348 
     - modelName
2349 
     - color
2350 
    """
2351 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2352 
    return self.recv_checkSimilarItem()
2353 
 
2354 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2355 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2356 
    args = checkSimilarItem_args()
2357 
    args.brand = brand
2358 
    args.modelNumber = modelNumber
2359 
    args.modelName = modelName
2360 
    args.color = color
2361 
    args.write(self._oprot)
2362 
    self._oprot.writeMessageEnd()
2363 
    self._oprot.trans.flush()
2364 
 
2365 
  def recv_checkSimilarItem(self, ):
2366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2367 
    if mtype == TMessageType.EXCEPTION:
2368 
      x = TApplicationException()
2369 
      x.read(self._iprot)
2370 
      self._iprot.readMessageEnd()
2371 
      raise x
2372 
    result = checkSimilarItem_result()
2373 
    result.read(self._iprot)
2374 
    self._iprot.readMessageEnd()
2375 
    if result.success is not None:
2376 
      return result.success
2377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2378 
 
2379 
  def validateRiskyStatus(self, itemId):
2380 
    """
2381 
    Check wether item is risky and change status if inventory is not available for risky items
2382 
 
2383 
    Parameters:
2384 
     - itemId
2385 
    """
2386 
    self.send_validateRiskyStatus(itemId)
2387 
    self.recv_validateRiskyStatus()
2388 
 
2389 
  def send_validateRiskyStatus(self, itemId):
2390 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2391 
    args = validateRiskyStatus_args()
2392 
    args.itemId = itemId
2393 
    args.write(self._oprot)
2394 
    self._oprot.writeMessageEnd()
2395 
    self._oprot.trans.flush()
2396 
 
2397 
  def recv_validateRiskyStatus(self, ):
2398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2399 
    if mtype == TMessageType.EXCEPTION:
2400 
      x = TApplicationException()
2401 
      x.read(self._iprot)
2402 
      self._iprot.readMessageEnd()
2403 
      raise x
2404 
    result = validateRiskyStatus_result()
2405 
    result.read(self._iprot)
2406 
    self._iprot.readMessageEnd()
2407 
    return
2408 
 
2409 
  def changeItemRiskyFlag(self, itemId, risky):
2410 
    """
2411 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2412 
 
2413 
    Parameters:
2414 
     - itemId
2415 
     - risky
2416 
    """
2417 
    self.send_changeItemRiskyFlag(itemId, risky)
2418 
    self.recv_changeItemRiskyFlag()
2419 
 
2420 
  def send_changeItemRiskyFlag(self, itemId, risky):
2421 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2422 
    args = changeItemRiskyFlag_args()
2423 
    args.itemId = itemId
2424 
    args.risky = risky
2425 
    args.write(self._oprot)
2426 
    self._oprot.writeMessageEnd()
2427 
    self._oprot.trans.flush()
2428 
 
2429 
  def recv_changeItemRiskyFlag(self, ):
2430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2431 
    if mtype == TMessageType.EXCEPTION:
2432 
      x = TApplicationException()
2433 
      x.read(self._iprot)
2434 
      self._iprot.readMessageEnd()
2435 
      raise x
2436 
    result = changeItemRiskyFlag_result()
2437 
    result.read(self._iprot)
2438 
    self._iprot.readMessageEnd()
2439 
    return
2440 
 
2441 
  def getItemsByRiskyFlag(self, ):
2442 
    """
2443 
    Returns list of items marked as risky.
2444 
    """
2445 
    self.send_getItemsByRiskyFlag()
2446 
    return self.recv_getItemsByRiskyFlag()
2447 
 
2448 
  def send_getItemsByRiskyFlag(self, ):
2449 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2450 
    args = getItemsByRiskyFlag_args()
2451 
    args.write(self._oprot)
2452 
    self._oprot.writeMessageEnd()
2453 
    self._oprot.trans.flush()
2454 
 
2455 
  def recv_getItemsByRiskyFlag(self, ):
2456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2457 
    if mtype == TMessageType.EXCEPTION:
2458 
      x = TApplicationException()
2459 
      x.read(self._iprot)
2460 
      self._iprot.readMessageEnd()
2461 
      raise x
2462 
    result = getItemsByRiskyFlag_result()
2463 
    result.read(self._iprot)
2464 
    self._iprot.readMessageEnd()
2465 
    if result.success is not None:
2466 
      return result.success
2467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2468 
 
2469 
  def getItemsForMasterSheet(self, category, brand):
2470 
    """
2471 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2472 
 
2473 
    Parameters:
2474 
     - category
2475 
     - brand
2476 
    """
2477 
    self.send_getItemsForMasterSheet(category, brand)
2478 
    return self.recv_getItemsForMasterSheet()
2479 
 
2480 
  def send_getItemsForMasterSheet(self, category, brand):
2481 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2482 
    args = getItemsForMasterSheet_args()
2483 
    args.category = category
2484 
    args.brand = brand
2485 
    args.write(self._oprot)
2486 
    self._oprot.writeMessageEnd()
2487 
    self._oprot.trans.flush()
2488 
 
2489 
  def recv_getItemsForMasterSheet(self, ):
2490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2491 
    if mtype == TMessageType.EXCEPTION:
2492 
      x = TApplicationException()
2493 
      x.read(self._iprot)
2494 
      self._iprot.readMessageEnd()
2495 
      raise x
2496 
    result = getItemsForMasterSheet_result()
2497 
    result.read(self._iprot)
2498 
    self._iprot.readMessageEnd()
2499 
    if result.success is not None:
2500 
      return result.success
2501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2502 
 
2503 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2504 
    """
2505 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2506 
 
2507 
    Parameters:
2508 
     - beginIndex
2509 
     - totalItems
2510 
     - itemId
2511 
    """
2512 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2513 
    return self.recv_getSimilarItemsCatalogIds()
2514 
 
2515 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2516 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2517 
    args = getSimilarItemsCatalogIds_args()
2518 
    args.beginIndex = beginIndex
2519 
    args.totalItems = totalItems
2520 
    args.itemId = itemId
2521 
    args.write(self._oprot)
2522 
    self._oprot.writeMessageEnd()
2523 
    self._oprot.trans.flush()
2524 
 
2525 
  def recv_getSimilarItemsCatalogIds(self, ):
2526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2527 
    if mtype == TMessageType.EXCEPTION:
2528 
      x = TApplicationException()
2529 
      x.read(self._iprot)
2530 
      self._iprot.readMessageEnd()
2531 
      raise x
2532 
    result = getSimilarItemsCatalogIds_result()
2533 
    result.read(self._iprot)
2534 
    self._iprot.readMessageEnd()
2535 
    if result.success is not None:
2536 
      return result.success
2537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2538 
 
2539 
  def addProductNotification(self, itemId, email):
2540 
    """
2541 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2542 
 
2543 
    Parameters:
2544 
     - itemId
2545 
     - email
2546 
    """
2547 
    self.send_addProductNotification(itemId, email)
2548 
    return self.recv_addProductNotification()
2549 
 
2550 
  def send_addProductNotification(self, itemId, email):
2551 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2552 
    args = addProductNotification_args()
2553 
    args.itemId = itemId
2554 
    args.email = email
2555 
    args.write(self._oprot)
2556 
    self._oprot.writeMessageEnd()
2557 
    self._oprot.trans.flush()
2558 
 
2559 
  def recv_addProductNotification(self, ):
2560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2561 
    if mtype == TMessageType.EXCEPTION:
2562 
      x = TApplicationException()
2563 
      x.read(self._iprot)
2564 
      self._iprot.readMessageEnd()
2565 
      raise x
2566 
    result = addProductNotification_result()
2567 
    result.read(self._iprot)
2568 
    self._iprot.readMessageEnd()
2569 
    if result.success is not None:
2570 
      return result.success
2571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2572 
 
2573 
  def sendProductNotifications(self, ):
2574 
    """
2575 
    Send the product notifications to the users for items which has stock.
2576 
    """
2577 
    self.send_sendProductNotifications()
2578 
    return self.recv_sendProductNotifications()
2579 
 
2580 
  def send_sendProductNotifications(self, ):
2581 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2582 
    args = sendProductNotifications_args()
2583 
    args.write(self._oprot)
2584 
    self._oprot.writeMessageEnd()
2585 
    self._oprot.trans.flush()
2586 
 
2587 
  def recv_sendProductNotifications(self, ):
2588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2589 
    if mtype == TMessageType.EXCEPTION:
2590 
      x = TApplicationException()
2591 
      x.read(self._iprot)
2592 
      self._iprot.readMessageEnd()
2593 
      raise x
2594 
    result = sendProductNotifications_result()
2595 
    result.read(self._iprot)
2596 
    self._iprot.readMessageEnd()
2597 
    if result.success is not None:
2598 
      return result.success
2599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2600 
 
2601 
  def getAllBrandsByCategory(self, categoryId):
2602 
    """
2603 
    Returns list of brand names for a given category Id
2604 
 
2605 
    Parameters:
2606 
     - categoryId
2607 
    """
2608 
    self.send_getAllBrandsByCategory(categoryId)
2609 
    return self.recv_getAllBrandsByCategory()
2610 
 
2611 
  def send_getAllBrandsByCategory(self, categoryId):
2612 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2613 
    args = getAllBrandsByCategory_args()
2614 
    args.categoryId = categoryId
2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
2619 
  def recv_getAllBrandsByCategory(self, ):
2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
2626 
    result = getAllBrandsByCategory_result()
2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
2629 
    if result.success is not None:
2630 
      return result.success
2631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2632 
 
2633 
  def getAllBrands(self, ):
2634 
    """
2635 
    Returns list of brand names
2636 
    """
2637 
    self.send_getAllBrands()
2638 
    return self.recv_getAllBrands()
2639 
 
2640 
  def send_getAllBrands(self, ):
2641 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2642 
    args = getAllBrands_args()
2643 
    args.write(self._oprot)
2644 
    self._oprot.writeMessageEnd()
2645 
    self._oprot.trans.flush()
2646 
 
2647 
  def recv_getAllBrands(self, ):
2648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2649 
    if mtype == TMessageType.EXCEPTION:
2650 
      x = TApplicationException()
2651 
      x.read(self._iprot)
2652 
      self._iprot.readMessageEnd()
2653 
      raise x
2654 
    result = getAllBrands_result()
2655 
    result.read(self._iprot)
2656 
    self._iprot.readMessageEnd()
2657 
    if result.success is not None:
2658 
      return result.success
2659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2660 
 
2661 
  def getAllSources(self, ):
2662 
    """
2663 
    Return list of all sources
2664 
    """
2665 
    self.send_getAllSources()
2666 
    return self.recv_getAllSources()
2667 
 
2668 
  def send_getAllSources(self, ):
2669 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2670 
    args = getAllSources_args()
2671 
    args.write(self._oprot)
2672 
    self._oprot.writeMessageEnd()
2673 
    self._oprot.trans.flush()
2674 
 
2675 
  def recv_getAllSources(self, ):
2676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2677 
    if mtype == TMessageType.EXCEPTION:
2678 
      x = TApplicationException()
2679 
      x.read(self._iprot)
2680 
      self._iprot.readMessageEnd()
2681 
      raise x
2682 
    result = getAllSources_result()
2683 
    result.read(self._iprot)
2684 
    self._iprot.readMessageEnd()
2685 
    if result.success is not None:
2686 
      return result.success
2687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2688 
 
2689 
  def getItemPricingBySource(self, itemId, sourceId):
2690 
    """
2691 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2692 
 
2693 
    Parameters:
2694 
     - itemId
2695 
     - sourceId
2696 
    """
2697 
    self.send_getItemPricingBySource(itemId, sourceId)
2698 
    return self.recv_getItemPricingBySource()
2699 
 
2700 
  def send_getItemPricingBySource(self, itemId, sourceId):
2701 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2702 
    args = getItemPricingBySource_args()
2703 
    args.itemId = itemId
2704 
    args.sourceId = sourceId
2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2709 
  def recv_getItemPricingBySource(self, ):
2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2716 
    result = getItemPricingBySource_result()
2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
2719 
    if result.success is not None:
2720 
      return result.success
2721 
    if result.cex is not None:
2722 
      raise result.cex
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2724 
 
2725 
  def addSourceItemPricing(self, sourceItemPricing):
2726 
    """
2727 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2728 
    If item is not found or source is not found, it will throw exception.
2729 
 
2730 
    Parameters:
2731 
     - sourceItemPricing
2732 
    """
2733 
    self.send_addSourceItemPricing(sourceItemPricing)
2734 
    self.recv_addSourceItemPricing()
2735 
 
2736 
  def send_addSourceItemPricing(self, sourceItemPricing):
2737 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2738 
    args = addSourceItemPricing_args()
2739 
    args.sourceItemPricing = sourceItemPricing
2740 
    args.write(self._oprot)
2741 
    self._oprot.writeMessageEnd()
2742 
    self._oprot.trans.flush()
2743 
 
2744 
  def recv_addSourceItemPricing(self, ):
2745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2746 
    if mtype == TMessageType.EXCEPTION:
2747 
      x = TApplicationException()
2748 
      x.read(self._iprot)
2749 
      self._iprot.readMessageEnd()
2750 
      raise x
2751 
    result = addSourceItemPricing_result()
2752 
    result.read(self._iprot)
2753 
    self._iprot.readMessageEnd()
2754 
    if result.cex is not None:
2755 
      raise result.cex
2756 
    return
2757 
 
2758 
  def getAllSourcePricing(self, itemId):
2759 
    """
2760 
    Returns the list of source pricing information of an item.
2761 
    Raises an exception if item not found corresponding to itemId
2762 
 
2763 
    Parameters:
2764 
     - itemId
2765 
    """
2766 
    self.send_getAllSourcePricing(itemId)
2767 
    return self.recv_getAllSourcePricing()
2768 
 
2769 
  def send_getAllSourcePricing(self, itemId):
2770 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2771 
    args = getAllSourcePricing_args()
2772 
    args.itemId = itemId
2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2777 
  def recv_getAllSourcePricing(self, ):
2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2784 
    result = getAllSourcePricing_result()
2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
2787 
    if result.success is not None:
2788 
      return result.success
2789 
    if result.cex is not None:
2790 
      raise result.cex
2791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2792 
 
2793 
  def getItemForSource(self, item_id, sourceId):
2794 
    """
2795 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2796 
 
2797 
    Parameters:
2798 
     - item_id
2799 
     - sourceId
2800 
    """
2801 
    self.send_getItemForSource(item_id, sourceId)
2802 
    return self.recv_getItemForSource()
2803 
 
2804 
  def send_getItemForSource(self, item_id, sourceId):
2805 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2806 
    args = getItemForSource_args()
2807 
    args.item_id = item_id
2808 
    args.sourceId = sourceId
2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2813 
  def recv_getItemForSource(self, ):
2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
2820 
    result = getItemForSource_result()
2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
2823 
    if result.success is not None:
2824 
      return result.success
2825 
    if result.cex is not None:
2826 
      raise result.cex
2827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2828 
 
2829 
  def searchItemsInRange(self, searchTerms, offset, limit):
2830 
    """
2831 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2832 
 
2833 
    Parameters:
2834 
     - searchTerms
2835 
     - offset
2836 
     - limit
2837 
    """
2838 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2839 
    return self.recv_searchItemsInRange()
2840 
 
2841 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2842 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2843 
    args = searchItemsInRange_args()
2844 
    args.searchTerms = searchTerms
2845 
    args.offset = offset
2846 
    args.limit = limit
2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
2851 
  def recv_searchItemsInRange(self, ):
2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
2858 
    result = searchItemsInRange_result()
2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
2861 
    if result.success is not None:
2862 
      return result.success
2863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2864 
 
2865 
  def getSearchResultCount(self, searchTerms):
2866 
    """
2867 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2868 
 
2869 
    Parameters:
2870 
     - searchTerms
2871 
    """
2872 
    self.send_getSearchResultCount(searchTerms)
2873 
    return self.recv_getSearchResultCount()
2874 
 
2875 
  def send_getSearchResultCount(self, searchTerms):
2876 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2877 
    args = getSearchResultCount_args()
2878 
    args.searchTerms = searchTerms
2879 
    args.write(self._oprot)
2880 
    self._oprot.writeMessageEnd()
2881 
    self._oprot.trans.flush()
2882 
 
2883 
  def recv_getSearchResultCount(self, ):
2884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2885 
    if mtype == TMessageType.EXCEPTION:
2886 
      x = TApplicationException()
2887 
      x.read(self._iprot)
2888 
      self._iprot.readMessageEnd()
2889 
      raise x
2890 
    result = getSearchResultCount_result()
2891 
    result.read(self._iprot)
2892 
    self._iprot.readMessageEnd()
2893 
    if result.success is not None:
2894 
      return result.success
2895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2896 
 
2897 
  def getProductNotifications(self, startDateTime):
2898 
    """
2899 
    Returns a list of product notifications added after a supplied datetime
2900 
 
2901 
    Parameters:
2902 
     - startDateTime
2903 
    """
2904 
    self.send_getProductNotifications(startDateTime)
2905 
    return self.recv_getProductNotifications()
2906 
 
2907 
  def send_getProductNotifications(self, startDateTime):
2908 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2909 
    args = getProductNotifications_args()
2910 
    args.startDateTime = startDateTime
2911 
    args.write(self._oprot)
2912 
    self._oprot.writeMessageEnd()
2913 
    self._oprot.trans.flush()
2914 
 
2915 
  def recv_getProductNotifications(self, ):
2916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2917 
    if mtype == TMessageType.EXCEPTION:
2918 
      x = TApplicationException()
2919 
      x.read(self._iprot)
2920 
      self._iprot.readMessageEnd()
2921 
      raise x
2922 
    result = getProductNotifications_result()
2923 
    result.read(self._iprot)
2924 
    self._iprot.readMessageEnd()
2925 
    if result.success is not None:
2926 
      return result.success
2927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2928 
 
2929 
  def getProductNotificationRequestCount(self, startDateTime):
2930 
    """
2931 
    Returns a list of count of requests for product notification against each item
2932 
 
2933 
    Parameters:
2934 
     - startDateTime
2935 
    """
2936 
    self.send_getProductNotificationRequestCount(startDateTime)
2937 
    return self.recv_getProductNotificationRequestCount()
2938 
 
2939 
  def send_getProductNotificationRequestCount(self, startDateTime):
2940 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2941 
    args = getProductNotificationRequestCount_args()
2942 
    args.startDateTime = startDateTime
2943 
    args.write(self._oprot)
2944 
    self._oprot.writeMessageEnd()
2945 
    self._oprot.trans.flush()
2946 
 
2947 
  def recv_getProductNotificationRequestCount(self, ):
2948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2949 
    if mtype == TMessageType.EXCEPTION:
2950 
      x = TApplicationException()
2951 
      x.read(self._iprot)
2952 
      self._iprot.readMessageEnd()
2953 
      raise x
2954 
    result = getProductNotificationRequestCount_result()
2955 
    result.read(self._iprot)
2956 
    self._iprot.readMessageEnd()
2957 
    if result.success is not None:
2958 
      return result.success
2959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2960 
 
2961 
  def addAuthorizationLog(self, itemId, username, reason):
2962 
    """
2963 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2964 
 
2965 
    Parameters:
2966 
     - itemId
2967 
     - username
2968 
     - reason
2969 
    """
2970 
    self.send_addAuthorizationLog(itemId, username, reason)
2971 
    return self.recv_addAuthorizationLog()
2972 
 
2973 
  def send_addAuthorizationLog(self, itemId, username, reason):
2974 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2975 
    args = addAuthorizationLog_args()
2976 
    args.itemId = itemId
2977 
    args.username = username
2978 
    args.reason = reason
2979 
    args.write(self._oprot)
2980 
    self._oprot.writeMessageEnd()
2981 
    self._oprot.trans.flush()
2982 
 
2983 
  def recv_addAuthorizationLog(self, ):
2984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2985 
    if mtype == TMessageType.EXCEPTION:
2986 
      x = TApplicationException()
2987 
      x.read(self._iprot)
2988 
      self._iprot.readMessageEnd()
2989 
      raise x
2990 
    result = addAuthorizationLog_result()
2991 
    result.read(self._iprot)
2992 
    self._iprot.readMessageEnd()
2993 
    if result.success is not None:
2994 
      return result.success
2995 
    if result.cex is not None:
2996 
      raise result.cex
2997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2998 
 
2999 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3000 
    """
3001 
    Parameters:
3002 
     - catalog_item_id
3003 
     - voucherType
3004 
     - voucherAmount
3005 
    """
3006 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3007 
    return self.recv_addupdateVoucherForItem()
3008 
 
3009 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3010 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3011 
    args = addupdateVoucherForItem_args()
3012 
    args.catalog_item_id = catalog_item_id
3013 
    args.voucherType = voucherType
3014 
    args.voucherAmount = voucherAmount
3015 
    args.write(self._oprot)
3016 
    self._oprot.writeMessageEnd()
3017 
    self._oprot.trans.flush()
3018 
 
3019 
  def recv_addupdateVoucherForItem(self, ):
3020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3021 
    if mtype == TMessageType.EXCEPTION:
3022 
      x = TApplicationException()
3023 
      x.read(self._iprot)
3024 
      self._iprot.readMessageEnd()
3025 
      raise x
3026 
    result = addupdateVoucherForItem_result()
3027 
    result.read(self._iprot)
3028 
    self._iprot.readMessageEnd()
3029 
    if result.success is not None:
3030 
      return result.success
3031 
    if result.cex is not None:
3032 
      raise result.cex
3033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3034 
 
3035 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3036 
    """
3037 
    Parameters:
3038 
     - catalog_item_id
3039 
     - voucherType
3040 
    """
3041 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3042 
    return self.recv_deleteVoucherForItem()
3043 
 
3044 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3045 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3046 
    args = deleteVoucherForItem_args()
3047 
    args.catalog_item_id = catalog_item_id
3048 
    args.voucherType = voucherType
3049 
    args.write(self._oprot)
3050 
    self._oprot.writeMessageEnd()
3051 
    self._oprot.trans.flush()
3052 
 
3053 
  def recv_deleteVoucherForItem(self, ):
3054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3055 
    if mtype == TMessageType.EXCEPTION:
3056 
      x = TApplicationException()
3057 
      x.read(self._iprot)
3058 
      self._iprot.readMessageEnd()
3059 
      raise x
3060 
    result = deleteVoucherForItem_result()
3061 
    result.read(self._iprot)
3062 
    self._iprot.readMessageEnd()
3063 
    if result.success is not None:
3064 
      return result.success
3065 
    if result.cex is not None:
3066 
      raise result.cex
3067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3068 
 
3069 
  def getVoucherAmount(self, itemId, voucherType):
3070 
    """
3071 
    Parameters:
3072 
     - itemId
3073 
     - voucherType
3074 
    """
3075 
    self.send_getVoucherAmount(itemId, voucherType)
3076 
    return self.recv_getVoucherAmount()
3077 
 
3078 
  def send_getVoucherAmount(self, itemId, voucherType):
3079 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3080 
    args = getVoucherAmount_args()
3081 
    args.itemId = itemId
3082 
    args.voucherType = voucherType
3083 
    args.write(self._oprot)
3084 
    self._oprot.writeMessageEnd()
3085 
    self._oprot.trans.flush()
3086 
 
3087 
  def recv_getVoucherAmount(self, ):
3088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3089 
    if mtype == TMessageType.EXCEPTION:
3090 
      x = TApplicationException()
3091 
      x.read(self._iprot)
3092 
      self._iprot.readMessageEnd()
3093 
      raise x
3094 
    result = getVoucherAmount_result()
3095 
    result.read(self._iprot)
3096 
    self._iprot.readMessageEnd()
3097 
    if result.success is not None:
3098 
      return result.success
3099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3100 
 
3101 
  def getAllItemVouchers(self, itemId):
3102 
    """
3103 
    Parameters:
3104 
     - itemId
3105 
    """
3106 
    self.send_getAllItemVouchers(itemId)
3107 
    return self.recv_getAllItemVouchers()
3108 
 
3109 
  def send_getAllItemVouchers(self, itemId):
3110 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3111 
    args = getAllItemVouchers_args()
3112 
    args.itemId = itemId
3113 
    args.write(self._oprot)
3114 
    self._oprot.writeMessageEnd()
3115 
    self._oprot.trans.flush()
3116 
 
3117 
  def recv_getAllItemVouchers(self, ):
3118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3119 
    if mtype == TMessageType.EXCEPTION:
3120 
      x = TApplicationException()
3121 
      x.read(self._iprot)
3122 
      self._iprot.readMessageEnd()
3123 
      raise x
3124 
    result = getAllItemVouchers_result()
3125 
    result.read(self._iprot)
3126 
    self._iprot.readMessageEnd()
3127 
    if result.success is not None:
3128 
      return result.success
3129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3130 
 
3131 
  def isValidCatalogItemId(self, catalog_item_id):
3132 
    """
3133 
    Parameters:
3134 
     - catalog_item_id
3135 
    """
3136 
    self.send_isValidCatalogItemId(catalog_item_id)
3137 
    return self.recv_isValidCatalogItemId()
3138 
 
3139 
  def send_isValidCatalogItemId(self, catalog_item_id):
3140 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3141 
    args = isValidCatalogItemId_args()
3142 
    args.catalog_item_id = catalog_item_id
3143 
    args.write(self._oprot)
3144 
    self._oprot.writeMessageEnd()
3145 
    self._oprot.trans.flush()
3146 
 
3147 
  def recv_isValidCatalogItemId(self, ):
3148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3149 
    if mtype == TMessageType.EXCEPTION:
3150 
      x = TApplicationException()
3151 
      x.read(self._iprot)
3152 
      self._iprot.readMessageEnd()
3153 
      raise x
3154 
    result = isValidCatalogItemId_result()
3155 
    result.read(self._iprot)
3156 
    self._iprot.readMessageEnd()
3157 
    if result.success is not None:
3158 
      return result.success
3159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3160 
 
7330 amit.gupta 3161 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3162 
    """
3163 
    Parameters:
3164 
     - itemId
7330 amit.gupta 3165 
     - stateId
6039 amit.gupta 3166 
     - price
3167 
    """
7330 amit.gupta 3168 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3169 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3170 
 
7330 amit.gupta 3171 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3172 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3173 
    args = getVatPercentageForItem_args()
3174 
    args.itemId = itemId
7330 amit.gupta 3175 
    args.stateId = stateId
6039 amit.gupta 3176 
    args.price = price
3177 
    args.write(self._oprot)
3178 
    self._oprot.writeMessageEnd()
3179 
    self._oprot.trans.flush()
3180 
 
3181 
  def recv_getVatPercentageForItem(self, ):
3182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3183 
    if mtype == TMessageType.EXCEPTION:
3184 
      x = TApplicationException()
3185 
      x.read(self._iprot)
3186 
      self._iprot.readMessageEnd()
3187 
      raise x
3188 
    result = getVatPercentageForItem_result()
3189 
    result.read(self._iprot)
3190 
    self._iprot.readMessageEnd()
3191 
    if result.success is not None:
3192 
      return result.success
7340 amit.gupta 3193 
    if result.cex is not None:
3194 
      raise result.cex
6039 amit.gupta 3195 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3196 
 
3197 
  def getVatAmountForItem(self, itemId, price):
3198 
    """
3199 
    Parameters:
3200 
     - itemId
3201 
     - price
3202 
    """
3203 
    self.send_getVatAmountForItem(itemId, price)
3204 
    return self.recv_getVatAmountForItem()
3205 
 
3206 
  def send_getVatAmountForItem(self, itemId, price):
3207 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3208 
    args = getVatAmountForItem_args()
3209 
    args.itemId = itemId
3210 
    args.price = price
3211 
    args.write(self._oprot)
3212 
    self._oprot.writeMessageEnd()
3213 
    self._oprot.trans.flush()
3214 
 
3215 
  def recv_getVatAmountForItem(self, ):
3216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3217 
    if mtype == TMessageType.EXCEPTION:
3218 
      x = TApplicationException()
3219 
      x.read(self._iprot)
3220 
      self._iprot.readMessageEnd()
3221 
      raise x
3222 
    result = getVatAmountForItem_result()
3223 
    result.read(self._iprot)
3224 
    self._iprot.readMessageEnd()
3225 
    if result.success is not None:
3226 
      return result.success
3227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3228 
 
6531 vikram.rag 3229 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3230 
    """
3231 
    Parameters:
3232 
     - offset
3233 
     - limit
3234 
    """
3235 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3236 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3237 
 
6531 vikram.rag 3238 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3239 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3240 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3241 
    args.offset = offset
3242 
    args.limit = limit
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
3257 
    if result.success is not None:
3258 
      return result.success
3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3260 
 
6821 amar.kumar 3261 
  def getAllAliveItems(self, ):
3262 
    self.send_getAllAliveItems()
3263 
    return self.recv_getAllAliveItems()
3264 
 
3265 
  def send_getAllAliveItems(self, ):
3266 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3267 
    args = getAllAliveItems_args()
3268 
    args.write(self._oprot)
3269 
    self._oprot.writeMessageEnd()
3270 
    self._oprot.trans.flush()
3271 
 
3272 
  def recv_getAllAliveItems(self, ):
3273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3274 
    if mtype == TMessageType.EXCEPTION:
3275 
      x = TApplicationException()
3276 
      x.read(self._iprot)
3277 
      self._iprot.readMessageEnd()
3278 
      raise x
3279 
    result = getAllAliveItems_result()
3280 
    result.read(self._iprot)
3281 
    self._iprot.readMessageEnd()
3282 
    if result.success is not None:
3283 
      return result.success
3284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3285 
 
6921 anupam.sin 3286 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3287 
    """
3288 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3289 
 
6805 anupam.sin 3290 
    Parameters:
3291 
     - itemId
6921 anupam.sin 3292 
     - price
6805 anupam.sin 3293 
     - insurerId
3294 
     - quantity
3295 
    """
6921 anupam.sin 3296 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3297 
    return self.recv_getInsuranceAmount()
3298 
 
6921 anupam.sin 3299 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3300 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3301 
    args = getInsuranceAmount_args()
3302 
    args.itemId = itemId
6921 anupam.sin 3303 
    args.price = price
6805 anupam.sin 3304 
    args.insurerId = insurerId
3305 
    args.quantity = quantity
3306 
    args.write(self._oprot)
3307 
    self._oprot.writeMessageEnd()
3308 
    self._oprot.trans.flush()
3309 
 
3310 
  def recv_getInsuranceAmount(self, ):
3311 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3312 
    if mtype == TMessageType.EXCEPTION:
3313 
      x = TApplicationException()
3314 
      x.read(self._iprot)
3315 
      self._iprot.readMessageEnd()
3316 
      raise x
3317 
    result = getInsuranceAmount_result()
3318 
    result.read(self._iprot)
3319 
    self._iprot.readMessageEnd()
3320 
    if result.success is not None:
3321 
      return result.success
3322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3323 
 
3324 
  def getInsurer(self, insurerId):
3325 
    """
3326 
    Parameters:
3327 
     - insurerId
3328 
    """
3329 
    self.send_getInsurer(insurerId)
3330 
    return self.recv_getInsurer()
3331 
 
3332 
  def send_getInsurer(self, insurerId):
3333 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3334 
    args = getInsurer_args()
3335 
    args.insurerId = insurerId
3336 
    args.write(self._oprot)
3337 
    self._oprot.writeMessageEnd()
3338 
    self._oprot.trans.flush()
3339 
 
3340 
  def recv_getInsurer(self, ):
3341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3342 
    if mtype == TMessageType.EXCEPTION:
3343 
      x = TApplicationException()
3344 
      x.read(self._iprot)
3345 
      self._iprot.readMessageEnd()
3346 
      raise x
3347 
    result = getInsurer_result()
3348 
    result.read(self._iprot)
3349 
    self._iprot.readMessageEnd()
3350 
    if result.success is not None:
3351 
      return result.success
3352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3353 
 
6838 vikram.rag 3354 
  def getAllInsurers(self, ):
3355 
    self.send_getAllInsurers()
3356 
    return self.recv_getAllInsurers()
6805 anupam.sin 3357 
 
6838 vikram.rag 3358 
  def send_getAllInsurers(self, ):
3359 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3360 
    args = getAllInsurers_args()
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_getAllInsurers(self, ):
3366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3367 
    if mtype == TMessageType.EXCEPTION:
3368 
      x = TApplicationException()
3369 
      x.read(self._iprot)
3370 
      self._iprot.readMessageEnd()
3371 
      raise x
3372 
    result = getAllInsurers_result()
3373 
    result.read(self._iprot)
3374 
    self._iprot.readMessageEnd()
3375 
    if result.success is not None:
3376 
      return result.success
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3378 
 
6962 rajveer 3379 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3380 
    """
3381 
    Parameters:
3382 
     - insurerId
3383 
     - amount
3384 
    """
3385 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3386 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3387 
 
6962 rajveer 3388 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3389 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3390 
    args = updateInsuranceDeclaredAmount_args()
3391 
    args.insurerId = insurerId
3392 
    args.amount = amount
3393 
    args.write(self._oprot)
3394 
    self._oprot.writeMessageEnd()
3395 
    self._oprot.trans.flush()
3396 
 
3397 
  def recv_updateInsuranceDeclaredAmount(self, ):
3398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3399 
    if mtype == TMessageType.EXCEPTION:
3400 
      x = TApplicationException()
3401 
      x.read(self._iprot)
3402 
      self._iprot.readMessageEnd()
3403 
      raise x
3404 
    result = updateInsuranceDeclaredAmount_result()
3405 
    result.read(self._iprot)
3406 
    self._iprot.readMessageEnd()
3407 
    return
3408 
 
7190 amar.kumar 3409 
  def getFreebieForItem(self, itemId):
3410 
    """
3411 
    Parameters:
3412 
     - itemId
3413 
    """
3414 
    self.send_getFreebieForItem(itemId)
3415 
    return self.recv_getFreebieForItem()
6962 rajveer 3416 
 
7190 amar.kumar 3417 
  def send_getFreebieForItem(self, itemId):
3418 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3419 
    args = getFreebieForItem_args()
3420 
    args.itemId = itemId
3421 
    args.write(self._oprot)
3422 
    self._oprot.writeMessageEnd()
3423 
    self._oprot.trans.flush()
3424 
 
3425 
  def recv_getFreebieForItem(self, ):
3426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3427 
    if mtype == TMessageType.EXCEPTION:
3428 
      x = TApplicationException()
3429 
      x.read(self._iprot)
3430 
      self._iprot.readMessageEnd()
3431 
      raise x
3432 
    result = getFreebieForItem_result()
3433 
    result.read(self._iprot)
3434 
    self._iprot.readMessageEnd()
3435 
    if result.success is not None:
3436 
      return result.success
3437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3438 
 
3439 
  def addOrUpdateFreebieForItem(self, freebieItem):
3440 
    """
3441 
    Parameters:
3442 
     - freebieItem
3443 
    """
3444 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3445 
    self.recv_addOrUpdateFreebieForItem()
3446 
 
3447 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3448 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3449 
    args = addOrUpdateFreebieForItem_args()
3450 
    args.freebieItem = freebieItem
3451 
    args.write(self._oprot)
3452 
    self._oprot.writeMessageEnd()
3453 
    self._oprot.trans.flush()
3454 
 
3455 
  def recv_addOrUpdateFreebieForItem(self, ):
3456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3457 
    if mtype == TMessageType.EXCEPTION:
3458 
      x = TApplicationException()
3459 
      x.read(self._iprot)
3460 
      self._iprot.readMessageEnd()
3461 
      raise x
3462 
    result = addOrUpdateFreebieForItem_result()
3463 
    result.read(self._iprot)
3464 
    self._iprot.readMessageEnd()
3465 
    return
3466 
 
7272 amit.gupta 3467 
  def addOrUpdateBrandInfo(self, brandInfo):
3468 
    """
3469 
    Parameters:
3470 
     - brandInfo
3471 
    """
3472 
    self.send_addOrUpdateBrandInfo(brandInfo)
3473 
    self.recv_addOrUpdateBrandInfo()
3474 
 
3475 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3476 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3477 
    args = addOrUpdateBrandInfo_args()
3478 
    args.brandInfo = brandInfo
3479 
    args.write(self._oprot)
3480 
    self._oprot.writeMessageEnd()
3481 
    self._oprot.trans.flush()
3482 
 
3483 
  def recv_addOrUpdateBrandInfo(self, ):
3484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3485 
    if mtype == TMessageType.EXCEPTION:
3486 
      x = TApplicationException()
3487 
      x.read(self._iprot)
3488 
      self._iprot.readMessageEnd()
3489 
      raise x
3490 
    result = addOrUpdateBrandInfo_result()
3491 
    result.read(self._iprot)
3492 
    self._iprot.readMessageEnd()
3493 
    return
3494 
 
3495 
  def getBrandInfo(self, ):
3496 
    self.send_getBrandInfo()
3497 
    return self.recv_getBrandInfo()
3498 
 
3499 
  def send_getBrandInfo(self, ):
3500 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3501 
    args = getBrandInfo_args()
3502 
    args.write(self._oprot)
3503 
    self._oprot.writeMessageEnd()
3504 
    self._oprot.trans.flush()
3505 
 
3506 
  def recv_getBrandInfo(self, ):
3507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3508 
    if mtype == TMessageType.EXCEPTION:
3509 
      x = TApplicationException()
3510 
      x.read(self._iprot)
3511 
      self._iprot.readMessageEnd()
3512 
      raise x
3513 
    result = getBrandInfo_result()
3514 
    result.read(self._iprot)
3515 
    self._iprot.readMessageEnd()
3516 
    if result.success is not None:
3517 
      return result.success
3518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3519 
 
7256 rajveer 3520 
  def getStorePricing(self, itemId):
3521 
    """
3522 
    Parameters:
3523 
     - itemId
3524 
    """
3525 
    self.send_getStorePricing(itemId)
3526 
    return self.recv_getStorePricing()
7190 amar.kumar 3527 
 
7256 rajveer 3528 
  def send_getStorePricing(self, itemId):
3529 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3530 
    args = getStorePricing_args()
3531 
    args.itemId = itemId
3532 
    args.write(self._oprot)
3533 
    self._oprot.writeMessageEnd()
3534 
    self._oprot.trans.flush()
3535 
 
3536 
  def recv_getStorePricing(self, ):
3537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3538 
    if mtype == TMessageType.EXCEPTION:
3539 
      x = TApplicationException()
3540 
      x.read(self._iprot)
3541 
      self._iprot.readMessageEnd()
3542 
      raise x
3543 
    result = getStorePricing_result()
3544 
    result.read(self._iprot)
3545 
    self._iprot.readMessageEnd()
3546 
    if result.success is not None:
3547 
      return result.success
3548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3549 
 
7306 rajveer 3550 
  def getStorePricings(self, itemIds):
3551 
    """
3552 
    Parameters:
3553 
     - itemIds
3554 
    """
3555 
    self.send_getStorePricings(itemIds)
3556 
    return self.recv_getStorePricings()
3557 
 
3558 
  def send_getStorePricings(self, itemIds):
3559 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3560 
    args = getStorePricings_args()
3561 
    args.itemIds = itemIds
3562 
    args.write(self._oprot)
3563 
    self._oprot.writeMessageEnd()
3564 
    self._oprot.trans.flush()
3565 
 
3566 
  def recv_getStorePricings(self, ):
3567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3568 
    if mtype == TMessageType.EXCEPTION:
3569 
      x = TApplicationException()
3570 
      x.read(self._iprot)
3571 
      self._iprot.readMessageEnd()
3572 
      raise x
3573 
    result = getStorePricings_result()
3574 
    result.read(self._iprot)
3575 
    self._iprot.readMessageEnd()
3576 
    if result.success is not None:
3577 
      return result.success
3578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3579 
 
7382 rajveer 3580 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3581 
    """
3582 
    Parameters:
3583 
     - sp
7382 rajveer 3584 
     - allColors
7265 rajveer 3585 
    """
7382 rajveer 3586 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3587 
    self.recv_updateStorePricing()
7256 rajveer 3588 
 
7382 rajveer 3589 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3590 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3591 
    args = updateStorePricing_args()
3592 
    args.sp = sp
7382 rajveer 3593 
    args.allColors = allColors
7265 rajveer 3594 
    args.write(self._oprot)
3595 
    self._oprot.writeMessageEnd()
3596 
    self._oprot.trans.flush()
3597 
 
3598 
  def recv_updateStorePricing(self, ):
3599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3600 
    if mtype == TMessageType.EXCEPTION:
3601 
      x = TApplicationException()
3602 
      x.read(self._iprot)
3603 
      self._iprot.readMessageEnd()
3604 
      raise x
3605 
    result = updateStorePricing_result()
3606 
    result.read(self._iprot)
3607 
    self._iprot.readMessageEnd()
3608 
    return
3609 
 
7281 kshitij.so 3610 
  def getAllAmazonListedItems(self, ):
3611 
    self.send_getAllAmazonListedItems()
3612 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3613 
 
7281 kshitij.so 3614 
  def send_getAllAmazonListedItems(self, ):
3615 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3616 
    args = getAllAmazonListedItems_args()
3617 
    args.write(self._oprot)
3618 
    self._oprot.writeMessageEnd()
3619 
    self._oprot.trans.flush()
3620 
 
3621 
  def recv_getAllAmazonListedItems(self, ):
3622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3623 
    if mtype == TMessageType.EXCEPTION:
3624 
      x = TApplicationException()
3625 
      x.read(self._iprot)
3626 
      self._iprot.readMessageEnd()
3627 
      raise x
3628 
    result = getAllAmazonListedItems_result()
3629 
    result.read(self._iprot)
3630 
    self._iprot.readMessageEnd()
3631 
    if result.success is not None:
3632 
      return result.success
3633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3634 
 
3635 
  def getAmazonItemDetails(self, itemId):
3636 
    """
3637 
    Parameters:
3638 
     - itemId
3639 
    """
3640 
    self.send_getAmazonItemDetails(itemId)
3641 
    return self.recv_getAmazonItemDetails()
3642 
 
3643 
  def send_getAmazonItemDetails(self, itemId):
3644 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3645 
    args = getAmazonItemDetails_args()
3646 
    args.itemId = itemId
3647 
    args.write(self._oprot)
3648 
    self._oprot.writeMessageEnd()
3649 
    self._oprot.trans.flush()
3650 
 
3651 
  def recv_getAmazonItemDetails(self, ):
3652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3653 
    if mtype == TMessageType.EXCEPTION:
3654 
      x = TApplicationException()
3655 
      x.read(self._iprot)
3656 
      self._iprot.readMessageEnd()
3657 
      raise x
3658 
    result = getAmazonItemDetails_result()
3659 
    result.read(self._iprot)
3660 
    self._iprot.readMessageEnd()
3661 
    if result.success is not None:
3662 
      return result.success
3663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3664 
 
7367 kshitij.so 3665 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3666 
    """
3667 
    Parameters:
3668 
     - itemId
3669 
     - fbaPrice
3670 
     - sellingPrice
3671 
     - isFba
3672 
     - isNonFba
3673 
     - isInventoryOverride
7367 kshitij.so 3674 
     - handlingTime
3675 
     - isCustomTime
7281 kshitij.so 3676 
    """
7367 kshitij.so 3677 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3678 
    self.recv_updateAmazonItemDetails()
3679 
 
7367 kshitij.so 3680 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3681 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3682 
    args = updateAmazonItemDetails_args()
3683 
    args.itemId = itemId
3684 
    args.fbaPrice = fbaPrice
3685 
    args.sellingPrice = sellingPrice
3686 
    args.isFba = isFba
3687 
    args.isNonFba = isNonFba
3688 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3689 
    args.handlingTime = handlingTime
3690 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3691 
    args.write(self._oprot)
3692 
    self._oprot.writeMessageEnd()
3693 
    self._oprot.trans.flush()
3694 
 
3695 
  def recv_updateAmazonItemDetails(self, ):
3696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3697 
    if mtype == TMessageType.EXCEPTION:
3698 
      x = TApplicationException()
3699 
      x.read(self._iprot)
3700 
      self._iprot.readMessageEnd()
3701 
      raise x
3702 
    result = updateAmazonItemDetails_result()
3703 
    result.read(self._iprot)
3704 
    self._iprot.readMessageEnd()
3705 
    return
3706 
 
3707 
  def addAmazonItem(self, amazonlisted):
3708 
    """
3709 
    Parameters:
3710 
     - amazonlisted
3711 
    """
3712 
    self.send_addAmazonItem(amazonlisted)
3713 
    self.recv_addAmazonItem()
3714 
 
3715 
  def send_addAmazonItem(self, amazonlisted):
3716 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3717 
    args = addAmazonItem_args()
3718 
    args.amazonlisted = amazonlisted
3719 
    args.write(self._oprot)
3720 
    self._oprot.writeMessageEnd()
3721 
    self._oprot.trans.flush()
3722 
 
3723 
  def recv_addAmazonItem(self, ):
3724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3725 
    if mtype == TMessageType.EXCEPTION:
3726 
      x = TApplicationException()
3727 
      x.read(self._iprot)
3728 
      self._iprot.readMessageEnd()
3729 
      raise x
3730 
    result = addAmazonItem_result()
3731 
    result.read(self._iprot)
3732 
    self._iprot.readMessageEnd()
3733 
    return
3734 
 
7291 vikram.rag 3735 
  def getAsinItems(self, ):
3736 
    self.send_getAsinItems()
3737 
    return self.recv_getAsinItems()
7281 kshitij.so 3738 
 
7291 vikram.rag 3739 
  def send_getAsinItems(self, ):
3740 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3741 
    args = getAsinItems_args()
3742 
    args.write(self._oprot)
3743 
    self._oprot.writeMessageEnd()
3744 
    self._oprot.trans.flush()
3745 
 
3746 
  def recv_getAsinItems(self, ):
3747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3748 
    if mtype == TMessageType.EXCEPTION:
3749 
      x = TApplicationException()
3750 
      x.read(self._iprot)
3751 
      self._iprot.readMessageEnd()
3752 
      raise x
3753 
    result = getAsinItems_result()
3754 
    result.read(self._iprot)
3755 
    self._iprot.readMessageEnd()
3756 
    if result.success is not None:
3757 
      return result.success
3758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3759 
 
3760 
  def getAllFbaListedItems(self, ):
3761 
    self.send_getAllFbaListedItems()
3762 
    return self.recv_getAllFbaListedItems()
3763 
 
3764 
  def send_getAllFbaListedItems(self, ):
3765 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3766 
    args = getAllFbaListedItems_args()
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_getAllFbaListedItems(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = getAllFbaListedItems_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
3781 
    if result.success is not None:
3782 
      return result.success
3783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3784 
 
3785 
  def getAllNonFbaListedItems(self, ):
3786 
    self.send_getAllNonFbaListedItems()
3787 
    return self.recv_getAllNonFbaListedItems()
3788 
 
3789 
  def send_getAllNonFbaListedItems(self, ):
3790 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3791 
    args = getAllNonFbaListedItems_args()
3792 
    args.write(self._oprot)
3793 
    self._oprot.writeMessageEnd()
3794 
    self._oprot.trans.flush()
3795 
 
3796 
  def recv_getAllNonFbaListedItems(self, ):
3797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3798 
    if mtype == TMessageType.EXCEPTION:
3799 
      x = TApplicationException()
3800 
      x.read(self._iprot)
3801 
      self._iprot.readMessageEnd()
3802 
      raise x
3803 
    result = getAllNonFbaListedItems_result()
3804 
    result.read(self._iprot)
3805 
    self._iprot.readMessageEnd()
3806 
    if result.success is not None:
3807 
      return result.success
3808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3809 
 
3810 
 
5944 mandeep.dh 3811 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3812 
  def __init__(self, handler):
3813 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3814 
    self._processMap["addItem"] = Processor.process_addItem
3815 
    self._processMap["updateItem"] = Processor.process_updateItem
3816 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 3817 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 3818 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3819 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3820 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3821 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3822 
    self._processMap["getItem"] = Processor.process_getItem
3823 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3824 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3825 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3826 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3827 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3828 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3829 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3830 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3831 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3832 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3833 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3834 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3835 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3836 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3837 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3838 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3839 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3840 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3841 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3842 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3843 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3844 
    self._processMap["addCategory"] = Processor.process_addCategory
3845 
    self._processMap["getCategory"] = Processor.process_getCategory
3846 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3847 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3848 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3849 
    self._processMap["addTag"] = Processor.process_addTag
3850 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3851 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3852 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3853 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3854 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3855 
    self._processMap["addBanner"] = Processor.process_addBanner
3856 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3857 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3858 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3859 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3860 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3861 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3862 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3863 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3864 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3865 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3866 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3867 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3868 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3869 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3870 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3871 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3872 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3873 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3874 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3875 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3876 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3877 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3878 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3879 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3880 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3881 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3882 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3883 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3884 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3885 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3886 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3887 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3888 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3889 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3890 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3891 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3892 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3893 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3894 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3895 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3896 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3897 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3898 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3899 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3900 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3901 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3902 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3903 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3904 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3905 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3906 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3907 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3908 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3909 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3910 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3911 
 
3912 
  def process(self, iprot, oprot):
3913 
    (name, type, seqid) = iprot.readMessageBegin()
3914 
    if name not in self._processMap:
3915 
      iprot.skip(TType.STRUCT)
3916 
      iprot.readMessageEnd()
3917 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3918 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3919 
      x.write(oprot)
3920 
      oprot.writeMessageEnd()
3921 
      oprot.trans.flush()
3922 
      return
3923 
    else:
3924 
      self._processMap[name](self, seqid, iprot, oprot)
3925 
    return True
3926 
 
3927 
  def process_addItem(self, seqid, iprot, oprot):
3928 
    args = addItem_args()
3929 
    args.read(iprot)
3930 
    iprot.readMessageEnd()
3931 
    result = addItem_result()
3932 
    try:
3933 
      result.success = self._handler.addItem(args.item)
3934 
    except CatalogServiceException, cex:
3935 
      result.cex = cex
3936 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3937 
    result.write(oprot)
3938 
    oprot.writeMessageEnd()
3939 
    oprot.trans.flush()
3940 
 
3941 
  def process_updateItem(self, seqid, iprot, oprot):
3942 
    args = updateItem_args()
3943 
    args.read(iprot)
3944 
    iprot.readMessageEnd()
3945 
    result = updateItem_result()
3946 
    try:
3947 
      result.success = self._handler.updateItem(args.item)
3948 
    except CatalogServiceException, cex:
3949 
      result.cex = cex
3950 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3951 
    result.write(oprot)
3952 
    oprot.writeMessageEnd()
3953 
    oprot.trans.flush()
3954 
 
3955 
  def process_isActive(self, seqid, iprot, oprot):
3956 
    args = isActive_args()
3957 
    args.read(iprot)
3958 
    iprot.readMessageEnd()
3959 
    result = isActive_result()
3960 
    try:
3961 
      result.success = self._handler.isActive(args.itemId)
3962 
    except CatalogServiceException, isex:
3963 
      result.isex = isex
3964 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3965 
    result.write(oprot)
3966 
    oprot.writeMessageEnd()
3967 
    oprot.trans.flush()
3968 
 
7438 amit.gupta 3969 
  def process_getItemsStatus(self, seqid, iprot, oprot):
3970 
    args = getItemsStatus_args()
3971 
    args.read(iprot)
3972 
    iprot.readMessageEnd()
3973 
    result = getItemsStatus_result()
3974 
    try:
3975 
      result.success = self._handler.getItemsStatus(args.itemIds)
3976 
    except CatalogServiceException, isex:
3977 
      result.isex = isex
3978 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
3982 
 
5944 mandeep.dh 3983 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3984 
    args = getItemStatusDescription_args()
3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
3987 
    result = getItemStatusDescription_result()
3988 
    try:
3989 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3990 
    except CatalogServiceException, isex:
3991 
      result.isex = isex
3992 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
3997 
  def process_startItemOn(self, seqid, iprot, oprot):
3998 
    args = startItemOn_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = startItemOn_result()
4002 
    try:
4003 
      self._handler.startItemOn(args.item_id, args.timestamp)
4004 
    except CatalogServiceException, cex:
4005 
      result.cex = cex
4006 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
4011 
  def process_retireItemOn(self, seqid, iprot, oprot):
4012 
    args = retireItemOn_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = retireItemOn_result()
4016 
    try:
4017 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4018 
    except CatalogServiceException, cex:
4019 
      result.cex = cex
4020 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
4025 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4026 
    args = changeItemStatus_args()
4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
4029 
    result = changeItemStatus_result()
4030 
    try:
4031 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4032 
    except CatalogServiceException, cex:
4033 
      result.cex = cex
4034 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
4039 
  def process_getItem(self, seqid, iprot, oprot):
4040 
    args = getItem_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = getItem_result()
4044 
    try:
4045 
      result.success = self._handler.getItem(args.item_id)
4046 
    except CatalogServiceException, cex:
4047 
      result.cex = cex
4048 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
4053 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4054 
    args = getItemsByCatalogId_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = getItemsByCatalogId_result()
4058 
    try:
4059 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4060 
    except CatalogServiceException, cex:
4061 
      result.cex = cex
4062 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
4067 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4068 
    args = getValidItemsByCatalogId_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = getValidItemsByCatalogId_result()
4072 
    try:
4073 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4074 
    except CatalogServiceException, cex:
4075 
      result.cex = cex
4076 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
4081 
  def process_getAllItems(self, seqid, iprot, oprot):
4082 
    args = getAllItems_args()
4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
4085 
    result = getAllItems_result()
4086 
    try:
4087 
      result.success = self._handler.getAllItems(args.isActive)
4088 
    except CatalogServiceException, cex:
4089 
      result.cex = cex
4090 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4091 
    result.write(oprot)
4092 
    oprot.writeMessageEnd()
4093 
    oprot.trans.flush()
4094 
 
4095 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4096 
    args = getAllItemsByStatus_args()
4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
4099 
    result = getAllItemsByStatus_result()
4100 
    try:
4101 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4102 
    except CatalogServiceException, cex:
4103 
      result.cex = cex
4104 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
4109 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4110 
    args = markItemAsContentComplete_args()
4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
4113 
    result = markItemAsContentComplete_result()
4114 
    try:
4115 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4116 
    except CatalogServiceException, cex:
4117 
      result.cex = cex
4118 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
4123 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4124 
    args = getAllItemsInRange_args()
4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
4127 
    result = getAllItemsInRange_result()
4128 
    try:
4129 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4130 
    except CatalogServiceException, cex:
4131 
      result.cex = cex
4132 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
4137 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4138 
    args = getAllItemsByStatusInRange_args()
4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
4141 
    result = getAllItemsByStatusInRange_result()
4142 
    try:
4143 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4144 
    except CatalogServiceException, cex:
4145 
      result.cex = cex
4146 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4147 
    result.write(oprot)
4148 
    oprot.writeMessageEnd()
4149 
    oprot.trans.flush()
4150 
 
4151 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4152 
    args = getItemCountByStatus_args()
4153 
    args.read(iprot)
4154 
    iprot.readMessageEnd()
4155 
    result = getItemCountByStatus_result()
4156 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4157 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4158 
    result.write(oprot)
4159 
    oprot.writeMessageEnd()
4160 
    oprot.trans.flush()
4161 
 
4162 
  def process_getBestSellers(self, seqid, iprot, oprot):
4163 
    args = getBestSellers_args()
4164 
    args.read(iprot)
4165 
    iprot.readMessageEnd()
4166 
    result = getBestSellers_result()
4167 
    try:
4168 
      result.success = self._handler.getBestSellers()
4169 
    except CatalogServiceException, isex:
4170 
      result.isex = isex
4171 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4172 
    result.write(oprot)
4173 
    oprot.writeMessageEnd()
4174 
    oprot.trans.flush()
4175 
 
4176 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4177 
    args = getBestSellersCatalogIds_args()
4178 
    args.read(iprot)
4179 
    iprot.readMessageEnd()
4180 
    result = getBestSellersCatalogIds_result()
4181 
    try:
4182 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4183 
    except CatalogServiceException, cex:
4184 
      result.cex = cex
4185 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4186 
    result.write(oprot)
4187 
    oprot.writeMessageEnd()
4188 
    oprot.trans.flush()
4189 
 
4190 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4191 
    args = getBestSellersCount_args()
4192 
    args.read(iprot)
4193 
    iprot.readMessageEnd()
4194 
    result = getBestSellersCount_result()
4195 
    try:
4196 
      result.success = self._handler.getBestSellersCount()
4197 
    except CatalogServiceException, cex:
4198 
      result.cex = cex
4199 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4200 
    result.write(oprot)
4201 
    oprot.writeMessageEnd()
4202 
    oprot.trans.flush()
4203 
 
4204 
  def process_getBestDeals(self, seqid, iprot, oprot):
4205 
    args = getBestDeals_args()
4206 
    args.read(iprot)
4207 
    iprot.readMessageEnd()
4208 
    result = getBestDeals_result()
4209 
    try:
4210 
      result.success = self._handler.getBestDeals()
4211 
    except CatalogServiceException, isex:
4212 
      result.isex = isex
4213 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4214 
    result.write(oprot)
4215 
    oprot.writeMessageEnd()
4216 
    oprot.trans.flush()
4217 
 
4218 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4219 
    args = getBestDealsCatalogIds_args()
4220 
    args.read(iprot)
4221 
    iprot.readMessageEnd()
4222 
    result = getBestDealsCatalogIds_result()
4223 
    try:
4224 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4225 
    except CatalogServiceException, cex:
4226 
      result.cex = cex
4227 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4228 
    result.write(oprot)
4229 
    oprot.writeMessageEnd()
4230 
    oprot.trans.flush()
4231 
 
4232 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4233 
    args = getBestDealsCount_args()
4234 
    args.read(iprot)
4235 
    iprot.readMessageEnd()
4236 
    result = getBestDealsCount_result()
4237 
    try:
4238 
      result.success = self._handler.getBestDealsCount()
4239 
    except CatalogServiceException, cex:
4240 
      result.cex = cex
4241 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4242 
    result.write(oprot)
4243 
    oprot.writeMessageEnd()
4244 
    oprot.trans.flush()
4245 
 
4246 
  def process_getComingSoon(self, seqid, iprot, oprot):
4247 
    args = getComingSoon_args()
4248 
    args.read(iprot)
4249 
    iprot.readMessageEnd()
4250 
    result = getComingSoon_result()
4251 
    try:
4252 
      result.success = self._handler.getComingSoon()
4253 
    except CatalogServiceException, isex:
4254 
      result.isex = isex
4255 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4256 
    result.write(oprot)
4257 
    oprot.writeMessageEnd()
4258 
    oprot.trans.flush()
4259 
 
4260 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4261 
    args = getComingSoonCatalogIds_args()
4262 
    args.read(iprot)
4263 
    iprot.readMessageEnd()
4264 
    result = getComingSoonCatalogIds_result()
4265 
    try:
4266 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4267 
    except CatalogServiceException, cex:
4268 
      result.cex = cex
4269 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4270 
    result.write(oprot)
4271 
    oprot.writeMessageEnd()
4272 
    oprot.trans.flush()
4273 
 
4274 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4275 
    args = getComingSoonCount_args()
4276 
    args.read(iprot)
4277 
    iprot.readMessageEnd()
4278 
    result = getComingSoonCount_result()
4279 
    try:
4280 
      result.success = self._handler.getComingSoonCount()
4281 
    except CatalogServiceException, cex:
4282 
      result.cex = cex
4283 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4284 
    result.write(oprot)
4285 
    oprot.writeMessageEnd()
4286 
    oprot.trans.flush()
4287 
 
4288 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4289 
    args = getLatestArrivals_args()
4290 
    args.read(iprot)
4291 
    iprot.readMessageEnd()
4292 
    result = getLatestArrivals_result()
4293 
    try:
4294 
      result.success = self._handler.getLatestArrivals()
4295 
    except CatalogServiceException, isex:
4296 
      result.isex = isex
4297 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4298 
    result.write(oprot)
4299 
    oprot.writeMessageEnd()
4300 
    oprot.trans.flush()
4301 
 
4302 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4303 
    args = getLatestArrivalsCatalogIds_args()
4304 
    args.read(iprot)
4305 
    iprot.readMessageEnd()
4306 
    result = getLatestArrivalsCatalogIds_result()
4307 
    try:
4308 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4309 
    except CatalogServiceException, cex:
4310 
      result.cex = cex
4311 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4312 
    result.write(oprot)
4313 
    oprot.writeMessageEnd()
4314 
    oprot.trans.flush()
4315 
 
4316 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4317 
    args = getLatestArrivalsCount_args()
4318 
    args.read(iprot)
4319 
    iprot.readMessageEnd()
4320 
    result = getLatestArrivalsCount_result()
4321 
    try:
4322 
      result.success = self._handler.getLatestArrivalsCount()
4323 
    except CatalogServiceException, cex:
4324 
      result.cex = cex
4325 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4326 
    result.write(oprot)
4327 
    oprot.writeMessageEnd()
4328 
    oprot.trans.flush()
4329 
 
4330 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4331 
    args = generateNewEntityID_args()
4332 
    args.read(iprot)
4333 
    iprot.readMessageEnd()
4334 
    result = generateNewEntityID_result()
4335 
    result.success = self._handler.generateNewEntityID()
4336 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4337 
    result.write(oprot)
4338 
    oprot.writeMessageEnd()
4339 
    oprot.trans.flush()
4340 
 
4341 
  def process_addCategory(self, seqid, iprot, oprot):
4342 
    args = addCategory_args()
4343 
    args.read(iprot)
4344 
    iprot.readMessageEnd()
4345 
    result = addCategory_result()
4346 
    result.success = self._handler.addCategory(args.category)
4347 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4348 
    result.write(oprot)
4349 
    oprot.writeMessageEnd()
4350 
    oprot.trans.flush()
4351 
 
4352 
  def process_getCategory(self, seqid, iprot, oprot):
4353 
    args = getCategory_args()
4354 
    args.read(iprot)
4355 
    iprot.readMessageEnd()
4356 
    result = getCategory_result()
4357 
    result.success = self._handler.getCategory(args.id)
4358 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4359 
    result.write(oprot)
4360 
    oprot.writeMessageEnd()
4361 
    oprot.trans.flush()
4362 
 
4363 
  def process_getAllCategories(self, seqid, iprot, oprot):
4364 
    args = getAllCategories_args()
4365 
    args.read(iprot)
4366 
    iprot.readMessageEnd()
4367 
    result = getAllCategories_result()
4368 
    result.success = self._handler.getAllCategories()
4369 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4375 
    args = getAllSimilarItems_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = getAllSimilarItems_result()
4379 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4380 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4385 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4386 
    args = addSimilarItem_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = addSimilarItem_result()
4390 
    try:
4391 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4392 
    except CatalogServiceException, cex:
4393 
      result.cex = cex
4394 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4395 
    result.write(oprot)
4396 
    oprot.writeMessageEnd()
4397 
    oprot.trans.flush()
4398 
 
6512 kshitij.so 4399 
  def process_addTag(self, seqid, iprot, oprot):
4400 
    args = addTag_args()
4401 
    args.read(iprot)
4402 
    iprot.readMessageEnd()
4403 
    result = addTag_result()
4404 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4405 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4406 
    result.write(oprot)
4407 
    oprot.writeMessageEnd()
4408 
    oprot.trans.flush()
4409 
 
4410 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4411 
    args = deleteEntityTag_args()
4412 
    args.read(iprot)
4413 
    iprot.readMessageEnd()
4414 
    result = deleteEntityTag_result()
4415 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4416 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4417 
    result.write(oprot)
4418 
    oprot.writeMessageEnd()
4419 
    oprot.trans.flush()
4420 
 
4421 
  def process_deleteTag(self, seqid, iprot, oprot):
4422 
    args = deleteTag_args()
4423 
    args.read(iprot)
4424 
    iprot.readMessageEnd()
4425 
    result = deleteTag_result()
4426 
    result.success = self._handler.deleteTag(args.displayName)
4427 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4428 
    result.write(oprot)
4429 
    oprot.writeMessageEnd()
4430 
    oprot.trans.flush()
4431 
 
4432 
  def process_getAllTags(self, seqid, iprot, oprot):
4433 
    args = getAllTags_args()
4434 
    args.read(iprot)
4435 
    iprot.readMessageEnd()
4436 
    result = getAllTags_result()
4437 
    result.success = self._handler.getAllTags()
4438 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
4443 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4444 
    args = getAllEntitiesByTagName_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = getAllEntitiesByTagName_result()
4448 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4449 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4450 
    result.write(oprot)
4451 
    oprot.writeMessageEnd()
4452 
    oprot.trans.flush()
4453 
 
6845 amit.gupta 4454 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4455 
    args = getAllEntityTags_args()
4456 
    args.read(iprot)
4457 
    iprot.readMessageEnd()
4458 
    result = getAllEntityTags_result()
4459 
    result.success = self._handler.getAllEntityTags()
4460 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4464 
 
6850 kshitij.so 4465 
  def process_addBanner(self, seqid, iprot, oprot):
4466 
    args = addBanner_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = addBanner_result()
4470 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4471 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4472 
    result.write(oprot)
4473 
    oprot.writeMessageEnd()
4474 
    oprot.trans.flush()
4475 
 
4476 
  def process_getAllBanners(self, seqid, iprot, oprot):
4477 
    args = getAllBanners_args()
4478 
    args.read(iprot)
4479 
    iprot.readMessageEnd()
4480 
    result = getAllBanners_result()
4481 
    result.success = self._handler.getAllBanners()
4482 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4483 
    result.write(oprot)
4484 
    oprot.writeMessageEnd()
4485 
    oprot.trans.flush()
4486 
 
4487 
  def process_deleteBanner(self, seqid, iprot, oprot):
4488 
    args = deleteBanner_args()
4489 
    args.read(iprot)
4490 
    iprot.readMessageEnd()
4491 
    result = deleteBanner_result()
4492 
    result.success = self._handler.deleteBanner(args.bannerName)
4493 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4494 
    result.write(oprot)
4495 
    oprot.writeMessageEnd()
4496 
    oprot.trans.flush()
4497 
 
4498 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4499 
    args = getBannerDetails_args()
4500 
    args.read(iprot)
4501 
    iprot.readMessageEnd()
4502 
    result = getBannerDetails_result()
4503 
    result.success = self._handler.getBannerDetails(args.bannerName)
4504 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
4508 
 
4509 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4510 
    args = getActiveBanners_args()
4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
4513 
    result = getActiveBanners_result()
4514 
    result.success = self._handler.getActiveBanners()
4515 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4516 
    result.write(oprot)
4517 
    oprot.writeMessageEnd()
4518 
    oprot.trans.flush()
4519 
 
6849 kshitij.so 4520 
  def process_addBannerMap(self, seqid, iprot, oprot):
4521 
    args = addBannerMap_args()
4522 
    args.read(iprot)
4523 
    iprot.readMessageEnd()
4524 
    result = addBannerMap_result()
4525 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4526 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
4531 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4532 
    args = deleteBannerMap_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = deleteBannerMap_result()
4536 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4537 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
4542 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4543 
    args = getBannerMapDetails_args()
4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
4546 
    result = getBannerMapDetails_result()
4547 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4548 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4549 
    result.write(oprot)
4550 
    oprot.writeMessageEnd()
4551 
    oprot.trans.flush()
4552 
 
5944 mandeep.dh 4553 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4554 
    args = deleteSimilarItem_args()
4555 
    args.read(iprot)
4556 
    iprot.readMessageEnd()
4557 
    result = deleteSimilarItem_result()
4558 
    try:
4559 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4560 
    except CatalogServiceException, cex:
4561 
      result.cex = cex
4562 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4563 
    result.write(oprot)
4564 
    oprot.writeMessageEnd()
4565 
    oprot.trans.flush()
4566 
 
4567 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4568 
    args = checkSimilarItem_args()
4569 
    args.read(iprot)
4570 
    iprot.readMessageEnd()
4571 
    result = checkSimilarItem_result()
4572 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4573 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4574 
    result.write(oprot)
4575 
    oprot.writeMessageEnd()
4576 
    oprot.trans.flush()
4577 
 
4578 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4579 
    args = validateRiskyStatus_args()
4580 
    args.read(iprot)
4581 
    iprot.readMessageEnd()
4582 
    result = validateRiskyStatus_result()
4583 
    self._handler.validateRiskyStatus(args.itemId)
4584 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4585 
    result.write(oprot)
4586 
    oprot.writeMessageEnd()
4587 
    oprot.trans.flush()
4588 
 
4589 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4590 
    args = changeItemRiskyFlag_args()
4591 
    args.read(iprot)
4592 
    iprot.readMessageEnd()
4593 
    result = changeItemRiskyFlag_result()
4594 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4595 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4596 
    result.write(oprot)
4597 
    oprot.writeMessageEnd()
4598 
    oprot.trans.flush()
4599 
 
4600 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4601 
    args = getItemsByRiskyFlag_args()
4602 
    args.read(iprot)
4603 
    iprot.readMessageEnd()
4604 
    result = getItemsByRiskyFlag_result()
4605 
    result.success = self._handler.getItemsByRiskyFlag()
4606 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4612 
    args = getItemsForMasterSheet_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = getItemsForMasterSheet_result()
4616 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4617 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
4622 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4623 
    args = getSimilarItemsCatalogIds_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = getSimilarItemsCatalogIds_result()
4627 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4628 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
4633 
  def process_addProductNotification(self, seqid, iprot, oprot):
4634 
    args = addProductNotification_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = addProductNotification_result()
4638 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4639 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
4644 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4645 
    args = sendProductNotifications_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = sendProductNotifications_result()
4649 
    result.success = self._handler.sendProductNotifications()
4650 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
4655 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4656 
    args = getAllBrandsByCategory_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = getAllBrandsByCategory_result()
4660 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4661 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4666 
  def process_getAllBrands(self, seqid, iprot, oprot):
4667 
    args = getAllBrands_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = getAllBrands_result()
4671 
    result.success = self._handler.getAllBrands()
4672 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4673 
    result.write(oprot)
4674 
    oprot.writeMessageEnd()
4675 
    oprot.trans.flush()
4676 
 
4677 
  def process_getAllSources(self, seqid, iprot, oprot):
4678 
    args = getAllSources_args()
4679 
    args.read(iprot)
4680 
    iprot.readMessageEnd()
4681 
    result = getAllSources_result()
4682 
    result.success = self._handler.getAllSources()
4683 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4684 
    result.write(oprot)
4685 
    oprot.writeMessageEnd()
4686 
    oprot.trans.flush()
4687 
 
4688 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4689 
    args = getItemPricingBySource_args()
4690 
    args.read(iprot)
4691 
    iprot.readMessageEnd()
4692 
    result = getItemPricingBySource_result()
4693 
    try:
4694 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4695 
    except CatalogServiceException, cex:
4696 
      result.cex = cex
4697 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4698 
    result.write(oprot)
4699 
    oprot.writeMessageEnd()
4700 
    oprot.trans.flush()
4701 
 
4702 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4703 
    args = addSourceItemPricing_args()
4704 
    args.read(iprot)
4705 
    iprot.readMessageEnd()
4706 
    result = addSourceItemPricing_result()
4707 
    try:
4708 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4709 
    except CatalogServiceException, cex:
4710 
      result.cex = cex
4711 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4712 
    result.write(oprot)
4713 
    oprot.writeMessageEnd()
4714 
    oprot.trans.flush()
4715 
 
4716 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4717 
    args = getAllSourcePricing_args()
4718 
    args.read(iprot)
4719 
    iprot.readMessageEnd()
4720 
    result = getAllSourcePricing_result()
4721 
    try:
4722 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4723 
    except CatalogServiceException, cex:
4724 
      result.cex = cex
4725 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4726 
    result.write(oprot)
4727 
    oprot.writeMessageEnd()
4728 
    oprot.trans.flush()
4729 
 
4730 
  def process_getItemForSource(self, seqid, iprot, oprot):
4731 
    args = getItemForSource_args()
4732 
    args.read(iprot)
4733 
    iprot.readMessageEnd()
4734 
    result = getItemForSource_result()
4735 
    try:
4736 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4737 
    except CatalogServiceException, cex:
4738 
      result.cex = cex
4739 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4740 
    result.write(oprot)
4741 
    oprot.writeMessageEnd()
4742 
    oprot.trans.flush()
4743 
 
4744 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4745 
    args = searchItemsInRange_args()
4746 
    args.read(iprot)
4747 
    iprot.readMessageEnd()
4748 
    result = searchItemsInRange_result()
4749 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4750 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4751 
    result.write(oprot)
4752 
    oprot.writeMessageEnd()
4753 
    oprot.trans.flush()
4754 
 
4755 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4756 
    args = getSearchResultCount_args()
4757 
    args.read(iprot)
4758 
    iprot.readMessageEnd()
4759 
    result = getSearchResultCount_result()
4760 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4761 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4762 
    result.write(oprot)
4763 
    oprot.writeMessageEnd()
4764 
    oprot.trans.flush()
4765 
 
4766 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4767 
    args = getProductNotifications_args()
4768 
    args.read(iprot)
4769 
    iprot.readMessageEnd()
4770 
    result = getProductNotifications_result()
4771 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4772 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4773 
    result.write(oprot)
4774 
    oprot.writeMessageEnd()
4775 
    oprot.trans.flush()
4776 
 
4777 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4778 
    args = getProductNotificationRequestCount_args()
4779 
    args.read(iprot)
4780 
    iprot.readMessageEnd()
4781 
    result = getProductNotificationRequestCount_result()
4782 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4783 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4784 
    result.write(oprot)
4785 
    oprot.writeMessageEnd()
4786 
    oprot.trans.flush()
4787 
 
4788 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4789 
    args = addAuthorizationLog_args()
4790 
    args.read(iprot)
4791 
    iprot.readMessageEnd()
4792 
    result = addAuthorizationLog_result()
4793 
    try:
4794 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4795 
    except CatalogServiceException, cex:
4796 
      result.cex = cex
4797 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4798 
    result.write(oprot)
4799 
    oprot.writeMessageEnd()
4800 
    oprot.trans.flush()
4801 
 
4802 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4803 
    args = addupdateVoucherForItem_args()
4804 
    args.read(iprot)
4805 
    iprot.readMessageEnd()
4806 
    result = addupdateVoucherForItem_result()
4807 
    try:
4808 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4809 
    except CatalogServiceException, cex:
4810 
      result.cex = cex
4811 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4812 
    result.write(oprot)
4813 
    oprot.writeMessageEnd()
4814 
    oprot.trans.flush()
4815 
 
4816 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4817 
    args = deleteVoucherForItem_args()
4818 
    args.read(iprot)
4819 
    iprot.readMessageEnd()
4820 
    result = deleteVoucherForItem_result()
4821 
    try:
4822 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4823 
    except CatalogServiceException, cex:
4824 
      result.cex = cex
4825 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4826 
    result.write(oprot)
4827 
    oprot.writeMessageEnd()
4828 
    oprot.trans.flush()
4829 
 
4830 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4831 
    args = getVoucherAmount_args()
4832 
    args.read(iprot)
4833 
    iprot.readMessageEnd()
4834 
    result = getVoucherAmount_result()
4835 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4836 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4837 
    result.write(oprot)
4838 
    oprot.writeMessageEnd()
4839 
    oprot.trans.flush()
4840 
 
4841 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4842 
    args = getAllItemVouchers_args()
4843 
    args.read(iprot)
4844 
    iprot.readMessageEnd()
4845 
    result = getAllItemVouchers_result()
4846 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4847 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4848 
    result.write(oprot)
4849 
    oprot.writeMessageEnd()
4850 
    oprot.trans.flush()
4851 
 
4852 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4853 
    args = isValidCatalogItemId_args()
4854 
    args.read(iprot)
4855 
    iprot.readMessageEnd()
4856 
    result = isValidCatalogItemId_result()
4857 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4858 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4859 
    result.write(oprot)
4860 
    oprot.writeMessageEnd()
4861 
    oprot.trans.flush()
4862 
 
6039 amit.gupta 4863 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4864 
    args = getVatPercentageForItem_args()
4865 
    args.read(iprot)
4866 
    iprot.readMessageEnd()
4867 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4868 
    try:
4869 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4870 
    except CatalogServiceException, cex:
4871 
      result.cex = cex
6039 amit.gupta 4872 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4873 
    result.write(oprot)
4874 
    oprot.writeMessageEnd()
4875 
    oprot.trans.flush()
5944 mandeep.dh 4876 
 
6039 amit.gupta 4877 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4878 
    args = getVatAmountForItem_args()
4879 
    args.read(iprot)
4880 
    iprot.readMessageEnd()
4881 
    result = getVatAmountForItem_result()
4882 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4883 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4884 
    result.write(oprot)
4885 
    oprot.writeMessageEnd()
4886 
    oprot.trans.flush()
4887 
 
6531 vikram.rag 4888 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4889 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4890 
    args.read(iprot)
4891 
    iprot.readMessageEnd()
4892 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4893 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4894 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4895 
    result.write(oprot)
4896 
    oprot.writeMessageEnd()
4897 
    oprot.trans.flush()
6039 amit.gupta 4898 
 
6821 amar.kumar 4899 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4900 
    args = getAllAliveItems_args()
4901 
    args.read(iprot)
4902 
    iprot.readMessageEnd()
4903 
    result = getAllAliveItems_result()
4904 
    result.success = self._handler.getAllAliveItems()
4905 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4906 
    result.write(oprot)
4907 
    oprot.writeMessageEnd()
4908 
    oprot.trans.flush()
4909 
 
6805 anupam.sin 4910 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4911 
    args = getInsuranceAmount_args()
4912 
    args.read(iprot)
4913 
    iprot.readMessageEnd()
4914 
    result = getInsuranceAmount_result()
6921 anupam.sin 4915 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4916 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
6531 vikram.rag 4920 
 
6805 anupam.sin 4921 
  def process_getInsurer(self, seqid, iprot, oprot):
4922 
    args = getInsurer_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = getInsurer_result()
4926 
    result.success = self._handler.getInsurer(args.insurerId)
4927 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
4931 
 
6838 vikram.rag 4932 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4933 
    args = getAllInsurers_args()
4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
4936 
    result = getAllInsurers_result()
4937 
    result.success = self._handler.getAllInsurers()
4938 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
6805 anupam.sin 4942 
 
6962 rajveer 4943 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4944 
    args = updateInsuranceDeclaredAmount_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = updateInsuranceDeclaredAmount_result()
4948 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4949 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
6838 vikram.rag 4953 
 
7190 amar.kumar 4954 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4955 
    args = getFreebieForItem_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = getFreebieForItem_result()
4959 
    result.success = self._handler.getFreebieForItem(args.itemId)
4960 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
6962 rajveer 4964 
 
7190 amar.kumar 4965 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4966 
    args = addOrUpdateFreebieForItem_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = addOrUpdateFreebieForItem_result()
4970 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4971 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
7272 amit.gupta 4976 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4977 
    args = addOrUpdateBrandInfo_args()
4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
4980 
    result = addOrUpdateBrandInfo_result()
4981 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4982 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
4986 
 
4987 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4988 
    args = getBrandInfo_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = getBrandInfo_result()
4992 
    result.success = self._handler.getBrandInfo()
4993 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4994 
    result.write(oprot)
4995 
    oprot.writeMessageEnd()
4996 
    oprot.trans.flush()
4997 
 
7256 rajveer 4998 
  def process_getStorePricing(self, seqid, iprot, oprot):
4999 
    args = getStorePricing_args()
5000 
    args.read(iprot)
5001 
    iprot.readMessageEnd()
5002 
    result = getStorePricing_result()
5003 
    result.success = self._handler.getStorePricing(args.itemId)
5004 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5005 
    result.write(oprot)
5006 
    oprot.writeMessageEnd()
5007 
    oprot.trans.flush()
7190 amar.kumar 5008 
 
7306 rajveer 5009 
  def process_getStorePricings(self, seqid, iprot, oprot):
5010 
    args = getStorePricings_args()
5011 
    args.read(iprot)
5012 
    iprot.readMessageEnd()
5013 
    result = getStorePricings_result()
5014 
    result.success = self._handler.getStorePricings(args.itemIds)
5015 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5016 
    result.write(oprot)
5017 
    oprot.writeMessageEnd()
5018 
    oprot.trans.flush()
5019 
 
7265 rajveer 5020 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5021 
    args = updateStorePricing_args()
5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
5024 
    result = updateStorePricing_result()
7382 rajveer 5025 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5026 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5027 
    result.write(oprot)
5028 
    oprot.writeMessageEnd()
5029 
    oprot.trans.flush()
7256 rajveer 5030 
 
7281 kshitij.so 5031 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5032 
    args = getAllAmazonListedItems_args()
5033 
    args.read(iprot)
5034 
    iprot.readMessageEnd()
5035 
    result = getAllAmazonListedItems_result()
5036 
    result.success = self._handler.getAllAmazonListedItems()
5037 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5038 
    result.write(oprot)
5039 
    oprot.writeMessageEnd()
5040 
    oprot.trans.flush()
7265 rajveer 5041 
 
7281 kshitij.so 5042 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5043 
    args = getAmazonItemDetails_args()
5044 
    args.read(iprot)
5045 
    iprot.readMessageEnd()
5046 
    result = getAmazonItemDetails_result()
5047 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5048 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5049 
    result.write(oprot)
5050 
    oprot.writeMessageEnd()
5051 
    oprot.trans.flush()
5052 
 
5053 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5054 
    args = updateAmazonItemDetails_args()
5055 
    args.read(iprot)
5056 
    iprot.readMessageEnd()
5057 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5058 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5059 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
5063 
 
5064 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5065 
    args = addAmazonItem_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = addAmazonItem_result()
5069 
    self._handler.addAmazonItem(args.amazonlisted)
5070 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
5074 
 
7291 vikram.rag 5075 
  def process_getAsinItems(self, seqid, iprot, oprot):
5076 
    args = getAsinItems_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = getAsinItems_result()
5080 
    result.success = self._handler.getAsinItems()
5081 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5082 
    result.write(oprot)
5083 
    oprot.writeMessageEnd()
5084 
    oprot.trans.flush()
7281 kshitij.so 5085 
 
7291 vikram.rag 5086 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5087 
    args = getAllFbaListedItems_args()
5088 
    args.read(iprot)
5089 
    iprot.readMessageEnd()
5090 
    result = getAllFbaListedItems_result()
5091 
    result.success = self._handler.getAllFbaListedItems()
5092 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5093 
    result.write(oprot)
5094 
    oprot.writeMessageEnd()
5095 
    oprot.trans.flush()
5096 
 
5097 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5098 
    args = getAllNonFbaListedItems_args()
5099 
    args.read(iprot)
5100 
    iprot.readMessageEnd()
5101 
    result = getAllNonFbaListedItems_result()
5102 
    result.success = self._handler.getAllNonFbaListedItems()
5103 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
5108 
 
5944 mandeep.dh 5109 
# HELPER FUNCTIONS AND STRUCTURES
5110 
 
5111 
class addItem_args:
5112 
  """
5113 
  Attributes:
5114 
   - item
5115 
  """
5116 
 
5117 
  thrift_spec = (
5118 
    None, # 0
5119 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5120 
  )
5121 
 
5122 
  def __init__(self, item=None,):
5123 
    self.item = item
5124 
 
5125 
  def read(self, iprot):
5126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5128 
      return
5129 
    iprot.readStructBegin()
5130 
    while True:
5131 
      (fname, ftype, fid) = iprot.readFieldBegin()
5132 
      if ftype == TType.STOP:
5133 
        break
5134 
      if fid == 1:
5135 
        if ftype == TType.STRUCT:
5136 
          self.item = Item()
5137 
          self.item.read(iprot)
5138 
        else:
5139 
          iprot.skip(ftype)
5140 
      else:
5141 
        iprot.skip(ftype)
5142 
      iprot.readFieldEnd()
5143 
    iprot.readStructEnd()
5144 
 
5145 
  def write(self, oprot):
5146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5148 
      return
5149 
    oprot.writeStructBegin('addItem_args')
5150 
    if self.item is not None:
5151 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5152 
      self.item.write(oprot)
5153 
      oprot.writeFieldEnd()
5154 
    oprot.writeFieldStop()
5155 
    oprot.writeStructEnd()
5156 
 
5157 
  def validate(self):
5158 
    return
5159 
 
5160 
 
5161 
  def __repr__(self):
5162 
    L = ['%s=%r' % (key, value)
5163 
      for key, value in self.__dict__.iteritems()]
5164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5165 
 
5166 
  def __eq__(self, other):
5167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5168 
 
5169 
  def __ne__(self, other):
5170 
    return not (self == other)
5171 
 
5172 
class addItem_result:
5173 
  """
5174 
  Attributes:
5175 
   - success
5176 
   - cex
5177 
  """
5178 
 
5179 
  thrift_spec = (
5180 
    (0, TType.I64, 'success', None, None, ), # 0
5181 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5182 
  )
5183 
 
5184 
  def __init__(self, success=None, cex=None,):
5185 
    self.success = success
5186 
    self.cex = cex
5187 
 
5188 
  def read(self, iprot):
5189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5191 
      return
5192 
    iprot.readStructBegin()
5193 
    while True:
5194 
      (fname, ftype, fid) = iprot.readFieldBegin()
5195 
      if ftype == TType.STOP:
5196 
        break
5197 
      if fid == 0:
5198 
        if ftype == TType.I64:
5199 
          self.success = iprot.readI64();
5200 
        else:
5201 
          iprot.skip(ftype)
5202 
      elif fid == 1:
5203 
        if ftype == TType.STRUCT:
5204 
          self.cex = CatalogServiceException()
5205 
          self.cex.read(iprot)
5206 
        else:
5207 
          iprot.skip(ftype)
5208 
      else:
5209 
        iprot.skip(ftype)
5210 
      iprot.readFieldEnd()
5211 
    iprot.readStructEnd()
5212 
 
5213 
  def write(self, oprot):
5214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5216 
      return
5217 
    oprot.writeStructBegin('addItem_result')
5218 
    if self.success is not None:
5219 
      oprot.writeFieldBegin('success', TType.I64, 0)
5220 
      oprot.writeI64(self.success)
5221 
      oprot.writeFieldEnd()
5222 
    if self.cex is not None:
5223 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5224 
      self.cex.write(oprot)
5225 
      oprot.writeFieldEnd()
5226 
    oprot.writeFieldStop()
5227 
    oprot.writeStructEnd()
5228 
 
5229 
  def validate(self):
5230 
    return
5231 
 
5232 
 
5233 
  def __repr__(self):
5234 
    L = ['%s=%r' % (key, value)
5235 
      for key, value in self.__dict__.iteritems()]
5236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5237 
 
5238 
  def __eq__(self, other):
5239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5240 
 
5241 
  def __ne__(self, other):
5242 
    return not (self == other)
5243 
 
5244 
class updateItem_args:
5245 
  """
5246 
  Attributes:
5247 
   - item
5248 
  """
5249 
 
5250 
  thrift_spec = (
5251 
    None, # 0
5252 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5253 
  )
5254 
 
5255 
  def __init__(self, item=None,):
5256 
    self.item = item
5257 
 
5258 
  def read(self, iprot):
5259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5261 
      return
5262 
    iprot.readStructBegin()
5263 
    while True:
5264 
      (fname, ftype, fid) = iprot.readFieldBegin()
5265 
      if ftype == TType.STOP:
5266 
        break
5267 
      if fid == 1:
5268 
        if ftype == TType.STRUCT:
5269 
          self.item = Item()
5270 
          self.item.read(iprot)
5271 
        else:
5272 
          iprot.skip(ftype)
5273 
      else:
5274 
        iprot.skip(ftype)
5275 
      iprot.readFieldEnd()
5276 
    iprot.readStructEnd()
5277 
 
5278 
  def write(self, oprot):
5279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5281 
      return
5282 
    oprot.writeStructBegin('updateItem_args')
5283 
    if self.item is not None:
5284 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5285 
      self.item.write(oprot)
5286 
      oprot.writeFieldEnd()
5287 
    oprot.writeFieldStop()
5288 
    oprot.writeStructEnd()
5289 
 
5290 
  def validate(self):
5291 
    return
5292 
 
5293 
 
5294 
  def __repr__(self):
5295 
    L = ['%s=%r' % (key, value)
5296 
      for key, value in self.__dict__.iteritems()]
5297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5298 
 
5299 
  def __eq__(self, other):
5300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5301 
 
5302 
  def __ne__(self, other):
5303 
    return not (self == other)
5304 
 
5305 
class updateItem_result:
5306 
  """
5307 
  Attributes:
5308 
   - success
5309 
   - cex
5310 
  """
5311 
 
5312 
  thrift_spec = (
5313 
    (0, TType.I64, 'success', None, None, ), # 0
5314 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5315 
  )
5316 
 
5317 
  def __init__(self, success=None, cex=None,):
5318 
    self.success = success
5319 
    self.cex = cex
5320 
 
5321 
  def read(self, iprot):
5322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5324 
      return
5325 
    iprot.readStructBegin()
5326 
    while True:
5327 
      (fname, ftype, fid) = iprot.readFieldBegin()
5328 
      if ftype == TType.STOP:
5329 
        break
5330 
      if fid == 0:
5331 
        if ftype == TType.I64:
5332 
          self.success = iprot.readI64();
5333 
        else:
5334 
          iprot.skip(ftype)
5335 
      elif fid == 1:
5336 
        if ftype == TType.STRUCT:
5337 
          self.cex = CatalogServiceException()
5338 
          self.cex.read(iprot)
5339 
        else:
5340 
          iprot.skip(ftype)
5341 
      else:
5342 
        iprot.skip(ftype)
5343 
      iprot.readFieldEnd()
5344 
    iprot.readStructEnd()
5345 
 
5346 
  def write(self, oprot):
5347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5349 
      return
5350 
    oprot.writeStructBegin('updateItem_result')
5351 
    if self.success is not None:
5352 
      oprot.writeFieldBegin('success', TType.I64, 0)
5353 
      oprot.writeI64(self.success)
5354 
      oprot.writeFieldEnd()
5355 
    if self.cex is not None:
5356 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5357 
      self.cex.write(oprot)
5358 
      oprot.writeFieldEnd()
5359 
    oprot.writeFieldStop()
5360 
    oprot.writeStructEnd()
5361 
 
5362 
  def validate(self):
5363 
    return
5364 
 
5365 
 
5366 
  def __repr__(self):
5367 
    L = ['%s=%r' % (key, value)
5368 
      for key, value in self.__dict__.iteritems()]
5369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5370 
 
5371 
  def __eq__(self, other):
5372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5373 
 
5374 
  def __ne__(self, other):
5375 
    return not (self == other)
5376 
 
5377 
class isActive_args:
5378 
  """
5379 
  Attributes:
5380 
   - itemId
5381 
  """
5382 
 
5383 
  thrift_spec = (
5384 
    None, # 0
5385 
    (1, TType.I64, 'itemId', None, None, ), # 1
5386 
  )
5387 
 
5388 
  def __init__(self, itemId=None,):
5389 
    self.itemId = itemId
5390 
 
5391 
  def read(self, iprot):
5392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5394 
      return
5395 
    iprot.readStructBegin()
5396 
    while True:
5397 
      (fname, ftype, fid) = iprot.readFieldBegin()
5398 
      if ftype == TType.STOP:
5399 
        break
5400 
      if fid == 1:
5401 
        if ftype == TType.I64:
5402 
          self.itemId = iprot.readI64();
5403 
        else:
5404 
          iprot.skip(ftype)
5405 
      else:
5406 
        iprot.skip(ftype)
5407 
      iprot.readFieldEnd()
5408 
    iprot.readStructEnd()
5409 
 
5410 
  def write(self, oprot):
5411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5413 
      return
5414 
    oprot.writeStructBegin('isActive_args')
5415 
    if self.itemId is not None:
5416 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5417 
      oprot.writeI64(self.itemId)
5418 
      oprot.writeFieldEnd()
5419 
    oprot.writeFieldStop()
5420 
    oprot.writeStructEnd()
5421 
 
5422 
  def validate(self):
5423 
    return
5424 
 
5425 
 
5426 
  def __repr__(self):
5427 
    L = ['%s=%r' % (key, value)
5428 
      for key, value in self.__dict__.iteritems()]
5429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5430 
 
5431 
  def __eq__(self, other):
5432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5433 
 
5434 
  def __ne__(self, other):
5435 
    return not (self == other)
5436 
 
5437 
class isActive_result:
5438 
  """
5439 
  Attributes:
5440 
   - success
5441 
   - isex
5442 
  """
5443 
 
5444 
  thrift_spec = (
5445 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5446 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5447 
  )
5448 
 
5449 
  def __init__(self, success=None, isex=None,):
5450 
    self.success = success
5451 
    self.isex = isex
5452 
 
5453 
  def read(self, iprot):
5454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5456 
      return
5457 
    iprot.readStructBegin()
5458 
    while True:
5459 
      (fname, ftype, fid) = iprot.readFieldBegin()
5460 
      if ftype == TType.STOP:
5461 
        break
5462 
      if fid == 0:
5463 
        if ftype == TType.STRUCT:
5464 
          self.success = ItemShippingInfo()
5465 
          self.success.read(iprot)
5466 
        else:
5467 
          iprot.skip(ftype)
5468 
      elif fid == 1:
5469 
        if ftype == TType.STRUCT:
5470 
          self.isex = CatalogServiceException()
5471 
          self.isex.read(iprot)
5472 
        else:
5473 
          iprot.skip(ftype)
5474 
      else:
5475 
        iprot.skip(ftype)
5476 
      iprot.readFieldEnd()
5477 
    iprot.readStructEnd()
5478 
 
5479 
  def write(self, oprot):
5480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5482 
      return
5483 
    oprot.writeStructBegin('isActive_result')
5484 
    if self.success is not None:
5485 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5486 
      self.success.write(oprot)
5487 
      oprot.writeFieldEnd()
5488 
    if self.isex is not None:
5489 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5490 
      self.isex.write(oprot)
5491 
      oprot.writeFieldEnd()
5492 
    oprot.writeFieldStop()
5493 
    oprot.writeStructEnd()
5494 
 
5495 
  def validate(self):
5496 
    return
5497 
 
5498 
 
5499 
  def __repr__(self):
5500 
    L = ['%s=%r' % (key, value)
5501 
      for key, value in self.__dict__.iteritems()]
5502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5503 
 
5504 
  def __eq__(self, other):
5505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5506 
 
5507 
  def __ne__(self, other):
5508 
    return not (self == other)
5509 
 
7438 amit.gupta 5510 
class getItemsStatus_args:
5511 
  """
5512 
  Attributes:
5513 
   - itemIds
5514 
  """
5515 
 
5516 
  thrift_spec = (
5517 
    None, # 0
5518 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5519 
  )
5520 
 
5521 
  def __init__(self, itemIds=None,):
5522 
    self.itemIds = itemIds
5523 
 
5524 
  def read(self, iprot):
5525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5527 
      return
5528 
    iprot.readStructBegin()
5529 
    while True:
5530 
      (fname, ftype, fid) = iprot.readFieldBegin()
5531 
      if ftype == TType.STOP:
5532 
        break
5533 
      if fid == 1:
5534 
        if ftype == TType.LIST:
5535 
          self.itemIds = []
5536 
          (_etype19, _size16) = iprot.readListBegin()
5537 
          for _i20 in xrange(_size16):
5538 
            _elem21 = iprot.readI64();
5539 
            self.itemIds.append(_elem21)
5540 
          iprot.readListEnd()
5541 
        else:
5542 
          iprot.skip(ftype)
5543 
      else:
5544 
        iprot.skip(ftype)
5545 
      iprot.readFieldEnd()
5546 
    iprot.readStructEnd()
5547 
 
5548 
  def write(self, oprot):
5549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5551 
      return
5552 
    oprot.writeStructBegin('getItemsStatus_args')
5553 
    if self.itemIds is not None:
5554 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5555 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5556 
      for iter22 in self.itemIds:
5557 
        oprot.writeI64(iter22)
5558 
      oprot.writeListEnd()
5559 
      oprot.writeFieldEnd()
5560 
    oprot.writeFieldStop()
5561 
    oprot.writeStructEnd()
5562 
 
5563 
  def validate(self):
5564 
    return
5565 
 
5566 
 
5567 
  def __repr__(self):
5568 
    L = ['%s=%r' % (key, value)
5569 
      for key, value in self.__dict__.iteritems()]
5570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5571 
 
5572 
  def __eq__(self, other):
5573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5574 
 
5575 
  def __ne__(self, other):
5576 
    return not (self == other)
5577 
 
5578 
class getItemsStatus_result:
5579 
  """
5580 
  Attributes:
5581 
   - success
5582 
   - isex
5583 
  """
5584 
 
5585 
  thrift_spec = (
5586 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5587 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5588 
  )
5589 
 
5590 
  def __init__(self, success=None, isex=None,):
5591 
    self.success = success
5592 
    self.isex = isex
5593 
 
5594 
  def read(self, iprot):
5595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5597 
      return
5598 
    iprot.readStructBegin()
5599 
    while True:
5600 
      (fname, ftype, fid) = iprot.readFieldBegin()
5601 
      if ftype == TType.STOP:
5602 
        break
5603 
      if fid == 0:
5604 
        if ftype == TType.MAP:
5605 
          self.success = {}
5606 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5607 
          for _i27 in xrange(_size23):
5608 
            _key28 = iprot.readI64();
5609 
            _val29 = iprot.readBool();
5610 
            self.success[_key28] = _val29
5611 
          iprot.readMapEnd()
5612 
        else:
5613 
          iprot.skip(ftype)
5614 
      elif fid == 1:
5615 
        if ftype == TType.STRUCT:
5616 
          self.isex = CatalogServiceException()
5617 
          self.isex.read(iprot)
5618 
        else:
5619 
          iprot.skip(ftype)
5620 
      else:
5621 
        iprot.skip(ftype)
5622 
      iprot.readFieldEnd()
5623 
    iprot.readStructEnd()
5624 
 
5625 
  def write(self, oprot):
5626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5628 
      return
5629 
    oprot.writeStructBegin('getItemsStatus_result')
5630 
    if self.success is not None:
5631 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5632 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5633 
      for kiter30,viter31 in self.success.items():
5634 
        oprot.writeI64(kiter30)
5635 
        oprot.writeBool(viter31)
5636 
      oprot.writeMapEnd()
5637 
      oprot.writeFieldEnd()
5638 
    if self.isex is not None:
5639 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5640 
      self.isex.write(oprot)
5641 
      oprot.writeFieldEnd()
5642 
    oprot.writeFieldStop()
5643 
    oprot.writeStructEnd()
5644 
 
5645 
  def validate(self):
5646 
    return
5647 
 
5648 
 
5649 
  def __repr__(self):
5650 
    L = ['%s=%r' % (key, value)
5651 
      for key, value in self.__dict__.iteritems()]
5652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5653 
 
5654 
  def __eq__(self, other):
5655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5656 
 
5657 
  def __ne__(self, other):
5658 
    return not (self == other)
5659 
 
5944 mandeep.dh 5660 
class getItemStatusDescription_args:
5661 
  """
5662 
  Attributes:
5663 
   - itemId
5664 
  """
5665 
 
5666 
  thrift_spec = (
5667 
    None, # 0
5668 
    (1, TType.I64, 'itemId', None, None, ), # 1
5669 
  )
5670 
 
5671 
  def __init__(self, itemId=None,):
5672 
    self.itemId = itemId
5673 
 
5674 
  def read(self, iprot):
5675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5677 
      return
5678 
    iprot.readStructBegin()
5679 
    while True:
5680 
      (fname, ftype, fid) = iprot.readFieldBegin()
5681 
      if ftype == TType.STOP:
5682 
        break
5683 
      if fid == 1:
5684 
        if ftype == TType.I64:
5685 
          self.itemId = iprot.readI64();
5686 
        else:
5687 
          iprot.skip(ftype)
5688 
      else:
5689 
        iprot.skip(ftype)
5690 
      iprot.readFieldEnd()
5691 
    iprot.readStructEnd()
5692 
 
5693 
  def write(self, oprot):
5694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5696 
      return
5697 
    oprot.writeStructBegin('getItemStatusDescription_args')
5698 
    if self.itemId is not None:
5699 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5700 
      oprot.writeI64(self.itemId)
5701 
      oprot.writeFieldEnd()
5702 
    oprot.writeFieldStop()
5703 
    oprot.writeStructEnd()
5704 
 
5705 
  def validate(self):
5706 
    return
5707 
 
5708 
 
5709 
  def __repr__(self):
5710 
    L = ['%s=%r' % (key, value)
5711 
      for key, value in self.__dict__.iteritems()]
5712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5713 
 
5714 
  def __eq__(self, other):
5715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5716 
 
5717 
  def __ne__(self, other):
5718 
    return not (self == other)
5719 
 
5720 
class getItemStatusDescription_result:
5721 
  """
5722 
  Attributes:
5723 
   - success
5724 
   - isex
5725 
  """
5726 
 
5727 
  thrift_spec = (
5728 
    (0, TType.STRING, 'success', None, None, ), # 0
5729 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5730 
  )
5731 
 
5732 
  def __init__(self, success=None, isex=None,):
5733 
    self.success = success
5734 
    self.isex = isex
5735 
 
5736 
  def read(self, iprot):
5737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5739 
      return
5740 
    iprot.readStructBegin()
5741 
    while True:
5742 
      (fname, ftype, fid) = iprot.readFieldBegin()
5743 
      if ftype == TType.STOP:
5744 
        break
5745 
      if fid == 0:
5746 
        if ftype == TType.STRING:
5747 
          self.success = iprot.readString();
5748 
        else:
5749 
          iprot.skip(ftype)
5750 
      elif fid == 1:
5751 
        if ftype == TType.STRUCT:
5752 
          self.isex = CatalogServiceException()
5753 
          self.isex.read(iprot)
5754 
        else:
5755 
          iprot.skip(ftype)
5756 
      else:
5757 
        iprot.skip(ftype)
5758 
      iprot.readFieldEnd()
5759 
    iprot.readStructEnd()
5760 
 
5761 
  def write(self, oprot):
5762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5764 
      return
5765 
    oprot.writeStructBegin('getItemStatusDescription_result')
5766 
    if self.success is not None:
5767 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5768 
      oprot.writeString(self.success)
5769 
      oprot.writeFieldEnd()
5770 
    if self.isex is not None:
5771 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5772 
      self.isex.write(oprot)
5773 
      oprot.writeFieldEnd()
5774 
    oprot.writeFieldStop()
5775 
    oprot.writeStructEnd()
5776 
 
5777 
  def validate(self):
5778 
    return
5779 
 
5780 
 
5781 
  def __repr__(self):
5782 
    L = ['%s=%r' % (key, value)
5783 
      for key, value in self.__dict__.iteritems()]
5784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5785 
 
5786 
  def __eq__(self, other):
5787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5788 
 
5789 
  def __ne__(self, other):
5790 
    return not (self == other)
5791 
 
5792 
class startItemOn_args:
5793 
  """
5794 
  Attributes:
5795 
   - item_id
5796 
   - timestamp
5797 
  """
5798 
 
5799 
  thrift_spec = (
5800 
    None, # 0
5801 
    (1, TType.I64, 'item_id', None, None, ), # 1
5802 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5803 
  )
5804 
 
5805 
  def __init__(self, item_id=None, timestamp=None,):
5806 
    self.item_id = item_id
5807 
    self.timestamp = timestamp
5808 
 
5809 
  def read(self, iprot):
5810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5812 
      return
5813 
    iprot.readStructBegin()
5814 
    while True:
5815 
      (fname, ftype, fid) = iprot.readFieldBegin()
5816 
      if ftype == TType.STOP:
5817 
        break
5818 
      if fid == 1:
5819 
        if ftype == TType.I64:
5820 
          self.item_id = iprot.readI64();
5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      elif fid == 2:
5824 
        if ftype == TType.I64:
5825 
          self.timestamp = iprot.readI64();
5826 
        else:
5827 
          iprot.skip(ftype)
5828 
      else:
5829 
        iprot.skip(ftype)
5830 
      iprot.readFieldEnd()
5831 
    iprot.readStructEnd()
5832 
 
5833 
  def write(self, oprot):
5834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5836 
      return
5837 
    oprot.writeStructBegin('startItemOn_args')
5838 
    if self.item_id is not None:
5839 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5840 
      oprot.writeI64(self.item_id)
5841 
      oprot.writeFieldEnd()
5842 
    if self.timestamp is not None:
5843 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5844 
      oprot.writeI64(self.timestamp)
5845 
      oprot.writeFieldEnd()
5846 
    oprot.writeFieldStop()
5847 
    oprot.writeStructEnd()
5848 
 
5849 
  def validate(self):
5850 
    return
5851 
 
5852 
 
5853 
  def __repr__(self):
5854 
    L = ['%s=%r' % (key, value)
5855 
      for key, value in self.__dict__.iteritems()]
5856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5857 
 
5858 
  def __eq__(self, other):
5859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5860 
 
5861 
  def __ne__(self, other):
5862 
    return not (self == other)
5863 
 
5864 
class startItemOn_result:
5865 
  """
5866 
  Attributes:
5867 
   - cex
5868 
  """
5869 
 
5870 
  thrift_spec = (
5871 
    None, # 0
5872 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5873 
  )
5874 
 
5875 
  def __init__(self, cex=None,):
5876 
    self.cex = cex
5877 
 
5878 
  def read(self, iprot):
5879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5881 
      return
5882 
    iprot.readStructBegin()
5883 
    while True:
5884 
      (fname, ftype, fid) = iprot.readFieldBegin()
5885 
      if ftype == TType.STOP:
5886 
        break
5887 
      if fid == 1:
5888 
        if ftype == TType.STRUCT:
5889 
          self.cex = CatalogServiceException()
5890 
          self.cex.read(iprot)
5891 
        else:
5892 
          iprot.skip(ftype)
5893 
      else:
5894 
        iprot.skip(ftype)
5895 
      iprot.readFieldEnd()
5896 
    iprot.readStructEnd()
5897 
 
5898 
  def write(self, oprot):
5899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5901 
      return
5902 
    oprot.writeStructBegin('startItemOn_result')
5903 
    if self.cex is not None:
5904 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5905 
      self.cex.write(oprot)
5906 
      oprot.writeFieldEnd()
5907 
    oprot.writeFieldStop()
5908 
    oprot.writeStructEnd()
5909 
 
5910 
  def validate(self):
5911 
    return
5912 
 
5913 
 
5914 
  def __repr__(self):
5915 
    L = ['%s=%r' % (key, value)
5916 
      for key, value in self.__dict__.iteritems()]
5917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5918 
 
5919 
  def __eq__(self, other):
5920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5921 
 
5922 
  def __ne__(self, other):
5923 
    return not (self == other)
5924 
 
5925 
class retireItemOn_args:
5926 
  """
5927 
  Attributes:
5928 
   - item_id
5929 
   - timestamp
5930 
  """
5931 
 
5932 
  thrift_spec = (
5933 
    None, # 0
5934 
    (1, TType.I64, 'item_id', None, None, ), # 1
5935 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5936 
  )
5937 
 
5938 
  def __init__(self, item_id=None, timestamp=None,):
5939 
    self.item_id = item_id
5940 
    self.timestamp = timestamp
5941 
 
5942 
  def read(self, iprot):
5943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5945 
      return
5946 
    iprot.readStructBegin()
5947 
    while True:
5948 
      (fname, ftype, fid) = iprot.readFieldBegin()
5949 
      if ftype == TType.STOP:
5950 
        break
5951 
      if fid == 1:
5952 
        if ftype == TType.I64:
5953 
          self.item_id = iprot.readI64();
5954 
        else:
5955 
          iprot.skip(ftype)
5956 
      elif fid == 2:
5957 
        if ftype == TType.I64:
5958 
          self.timestamp = iprot.readI64();
5959 
        else:
5960 
          iprot.skip(ftype)
5961 
      else:
5962 
        iprot.skip(ftype)
5963 
      iprot.readFieldEnd()
5964 
    iprot.readStructEnd()
5965 
 
5966 
  def write(self, oprot):
5967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5969 
      return
5970 
    oprot.writeStructBegin('retireItemOn_args')
5971 
    if self.item_id is not None:
5972 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5973 
      oprot.writeI64(self.item_id)
5974 
      oprot.writeFieldEnd()
5975 
    if self.timestamp is not None:
5976 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5977 
      oprot.writeI64(self.timestamp)
5978 
      oprot.writeFieldEnd()
5979 
    oprot.writeFieldStop()
5980 
    oprot.writeStructEnd()
5981 
 
5982 
  def validate(self):
5983 
    return
5984 
 
5985 
 
5986 
  def __repr__(self):
5987 
    L = ['%s=%r' % (key, value)
5988 
      for key, value in self.__dict__.iteritems()]
5989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5990 
 
5991 
  def __eq__(self, other):
5992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5993 
 
5994 
  def __ne__(self, other):
5995 
    return not (self == other)
5996 
 
5997 
class retireItemOn_result:
5998 
  """
5999 
  Attributes:
6000 
   - cex
6001 
  """
6002 
 
6003 
  thrift_spec = (
6004 
    None, # 0
6005 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6006 
  )
6007 
 
6008 
  def __init__(self, cex=None,):
6009 
    self.cex = cex
6010 
 
6011 
  def read(self, iprot):
6012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6014 
      return
6015 
    iprot.readStructBegin()
6016 
    while True:
6017 
      (fname, ftype, fid) = iprot.readFieldBegin()
6018 
      if ftype == TType.STOP:
6019 
        break
6020 
      if fid == 1:
6021 
        if ftype == TType.STRUCT:
6022 
          self.cex = CatalogServiceException()
6023 
          self.cex.read(iprot)
6024 
        else:
6025 
          iprot.skip(ftype)
6026 
      else:
6027 
        iprot.skip(ftype)
6028 
      iprot.readFieldEnd()
6029 
    iprot.readStructEnd()
6030 
 
6031 
  def write(self, oprot):
6032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6034 
      return
6035 
    oprot.writeStructBegin('retireItemOn_result')
6036 
    if self.cex is not None:
6037 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6038 
      self.cex.write(oprot)
6039 
      oprot.writeFieldEnd()
6040 
    oprot.writeFieldStop()
6041 
    oprot.writeStructEnd()
6042 
 
6043 
  def validate(self):
6044 
    return
6045 
 
6046 
 
6047 
  def __repr__(self):
6048 
    L = ['%s=%r' % (key, value)
6049 
      for key, value in self.__dict__.iteritems()]
6050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6051 
 
6052 
  def __eq__(self, other):
6053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6054 
 
6055 
  def __ne__(self, other):
6056 
    return not (self == other)
6057 
 
6058 
class changeItemStatus_args:
6059 
  """
6060 
  Attributes:
6061 
   - item_id
6062 
   - timestamp
6063 
   - newstatus
6064 
  """
6065 
 
6066 
  thrift_spec = (
6067 
    None, # 0
6068 
    (1, TType.I64, 'item_id', None, None, ), # 1
6069 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6070 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6071 
  )
6072 
 
6073 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6074 
    self.item_id = item_id
6075 
    self.timestamp = timestamp
6076 
    self.newstatus = newstatus
6077 
 
6078 
  def read(self, iprot):
6079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6081 
      return
6082 
    iprot.readStructBegin()
6083 
    while True:
6084 
      (fname, ftype, fid) = iprot.readFieldBegin()
6085 
      if ftype == TType.STOP:
6086 
        break
6087 
      if fid == 1:
6088 
        if ftype == TType.I64:
6089 
          self.item_id = iprot.readI64();
6090 
        else:
6091 
          iprot.skip(ftype)
6092 
      elif fid == 2:
6093 
        if ftype == TType.I64:
6094 
          self.timestamp = iprot.readI64();
6095 
        else:
6096 
          iprot.skip(ftype)
6097 
      elif fid == 3:
6098 
        if ftype == TType.I32:
6099 
          self.newstatus = iprot.readI32();
6100 
        else:
6101 
          iprot.skip(ftype)
6102 
      else:
6103 
        iprot.skip(ftype)
6104 
      iprot.readFieldEnd()
6105 
    iprot.readStructEnd()
6106 
 
6107 
  def write(self, oprot):
6108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6110 
      return
6111 
    oprot.writeStructBegin('changeItemStatus_args')
6112 
    if self.item_id is not None:
6113 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6114 
      oprot.writeI64(self.item_id)
6115 
      oprot.writeFieldEnd()
6116 
    if self.timestamp is not None:
6117 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6118 
      oprot.writeI64(self.timestamp)
6119 
      oprot.writeFieldEnd()
6120 
    if self.newstatus is not None:
6121 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6122 
      oprot.writeI32(self.newstatus)
6123 
      oprot.writeFieldEnd()
6124 
    oprot.writeFieldStop()
6125 
    oprot.writeStructEnd()
6126 
 
6127 
  def validate(self):
6128 
    return
6129 
 
6130 
 
6131 
  def __repr__(self):
6132 
    L = ['%s=%r' % (key, value)
6133 
      for key, value in self.__dict__.iteritems()]
6134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6135 
 
6136 
  def __eq__(self, other):
6137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6138 
 
6139 
  def __ne__(self, other):
6140 
    return not (self == other)
6141 
 
6142 
class changeItemStatus_result:
6143 
  """
6144 
  Attributes:
6145 
   - cex
6146 
  """
6147 
 
6148 
  thrift_spec = (
6149 
    None, # 0
6150 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6151 
  )
6152 
 
6153 
  def __init__(self, cex=None,):
6154 
    self.cex = cex
6155 
 
6156 
  def read(self, iprot):
6157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6159 
      return
6160 
    iprot.readStructBegin()
6161 
    while True:
6162 
      (fname, ftype, fid) = iprot.readFieldBegin()
6163 
      if ftype == TType.STOP:
6164 
        break
6165 
      if fid == 1:
6166 
        if ftype == TType.STRUCT:
6167 
          self.cex = CatalogServiceException()
6168 
          self.cex.read(iprot)
6169 
        else:
6170 
          iprot.skip(ftype)
6171 
      else:
6172 
        iprot.skip(ftype)
6173 
      iprot.readFieldEnd()
6174 
    iprot.readStructEnd()
6175 
 
6176 
  def write(self, oprot):
6177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6179 
      return
6180 
    oprot.writeStructBegin('changeItemStatus_result')
6181 
    if self.cex is not None:
6182 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6183 
      self.cex.write(oprot)
6184 
      oprot.writeFieldEnd()
6185 
    oprot.writeFieldStop()
6186 
    oprot.writeStructEnd()
6187 
 
6188 
  def validate(self):
6189 
    return
6190 
 
6191 
 
6192 
  def __repr__(self):
6193 
    L = ['%s=%r' % (key, value)
6194 
      for key, value in self.__dict__.iteritems()]
6195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6196 
 
6197 
  def __eq__(self, other):
6198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6199 
 
6200 
  def __ne__(self, other):
6201 
    return not (self == other)
6202 
 
6203 
class getItem_args:
6204 
  """
6205 
  Attributes:
6206 
   - item_id
6207 
  """
6208 
 
6209 
  thrift_spec = (
6210 
    None, # 0
6211 
    (1, TType.I64, 'item_id', None, None, ), # 1
6212 
  )
6213 
 
6214 
  def __init__(self, item_id=None,):
6215 
    self.item_id = item_id
6216 
 
6217 
  def read(self, iprot):
6218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6220 
      return
6221 
    iprot.readStructBegin()
6222 
    while True:
6223 
      (fname, ftype, fid) = iprot.readFieldBegin()
6224 
      if ftype == TType.STOP:
6225 
        break
6226 
      if fid == 1:
6227 
        if ftype == TType.I64:
6228 
          self.item_id = iprot.readI64();
6229 
        else:
6230 
          iprot.skip(ftype)
6231 
      else:
6232 
        iprot.skip(ftype)
6233 
      iprot.readFieldEnd()
6234 
    iprot.readStructEnd()
6235 
 
6236 
  def write(self, oprot):
6237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6239 
      return
6240 
    oprot.writeStructBegin('getItem_args')
6241 
    if self.item_id is not None:
6242 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6243 
      oprot.writeI64(self.item_id)
6244 
      oprot.writeFieldEnd()
6245 
    oprot.writeFieldStop()
6246 
    oprot.writeStructEnd()
6247 
 
6248 
  def validate(self):
6249 
    return
6250 
 
6251 
 
6252 
  def __repr__(self):
6253 
    L = ['%s=%r' % (key, value)
6254 
      for key, value in self.__dict__.iteritems()]
6255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6256 
 
6257 
  def __eq__(self, other):
6258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6259 
 
6260 
  def __ne__(self, other):
6261 
    return not (self == other)
6262 
 
6263 
class getItem_result:
6264 
  """
6265 
  Attributes:
6266 
   - success
6267 
   - cex
6268 
  """
6269 
 
6270 
  thrift_spec = (
6271 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6272 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6273 
  )
6274 
 
6275 
  def __init__(self, success=None, cex=None,):
6276 
    self.success = success
6277 
    self.cex = cex
6278 
 
6279 
  def read(self, iprot):
6280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6282 
      return
6283 
    iprot.readStructBegin()
6284 
    while True:
6285 
      (fname, ftype, fid) = iprot.readFieldBegin()
6286 
      if ftype == TType.STOP:
6287 
        break
6288 
      if fid == 0:
6289 
        if ftype == TType.STRUCT:
6290 
          self.success = Item()
6291 
          self.success.read(iprot)
6292 
        else:
6293 
          iprot.skip(ftype)
6294 
      elif fid == 1:
6295 
        if ftype == TType.STRUCT:
6296 
          self.cex = CatalogServiceException()
6297 
          self.cex.read(iprot)
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      else:
6301 
        iprot.skip(ftype)
6302 
      iprot.readFieldEnd()
6303 
    iprot.readStructEnd()
6304 
 
6305 
  def write(self, oprot):
6306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6308 
      return
6309 
    oprot.writeStructBegin('getItem_result')
6310 
    if self.success is not None:
6311 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6312 
      self.success.write(oprot)
6313 
      oprot.writeFieldEnd()
6314 
    if self.cex is not None:
6315 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6316 
      self.cex.write(oprot)
6317 
      oprot.writeFieldEnd()
6318 
    oprot.writeFieldStop()
6319 
    oprot.writeStructEnd()
6320 
 
6321 
  def validate(self):
6322 
    return
6323 
 
6324 
 
6325 
  def __repr__(self):
6326 
    L = ['%s=%r' % (key, value)
6327 
      for key, value in self.__dict__.iteritems()]
6328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6329 
 
6330 
  def __eq__(self, other):
6331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6332 
 
6333 
  def __ne__(self, other):
6334 
    return not (self == other)
6335 
 
6336 
class getItemsByCatalogId_args:
6337 
  """
6338 
  Attributes:
6339 
   - catalog_item_id
6340 
  """
6341 
 
6342 
  thrift_spec = (
6343 
    None, # 0
6344 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6345 
  )
6346 
 
6347 
  def __init__(self, catalog_item_id=None,):
6348 
    self.catalog_item_id = catalog_item_id
6349 
 
6350 
  def read(self, iprot):
6351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6353 
      return
6354 
    iprot.readStructBegin()
6355 
    while True:
6356 
      (fname, ftype, fid) = iprot.readFieldBegin()
6357 
      if ftype == TType.STOP:
6358 
        break
6359 
      if fid == 1:
6360 
        if ftype == TType.I64:
6361 
          self.catalog_item_id = iprot.readI64();
6362 
        else:
6363 
          iprot.skip(ftype)
6364 
      else:
6365 
        iprot.skip(ftype)
6366 
      iprot.readFieldEnd()
6367 
    iprot.readStructEnd()
6368 
 
6369 
  def write(self, oprot):
6370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6372 
      return
6373 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6374 
    if self.catalog_item_id is not None:
6375 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6376 
      oprot.writeI64(self.catalog_item_id)
6377 
      oprot.writeFieldEnd()
6378 
    oprot.writeFieldStop()
6379 
    oprot.writeStructEnd()
6380 
 
6381 
  def validate(self):
6382 
    return
6383 
 
6384 
 
6385 
  def __repr__(self):
6386 
    L = ['%s=%r' % (key, value)
6387 
      for key, value in self.__dict__.iteritems()]
6388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6389 
 
6390 
  def __eq__(self, other):
6391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6392 
 
6393 
  def __ne__(self, other):
6394 
    return not (self == other)
6395 
 
6396 
class getItemsByCatalogId_result:
6397 
  """
6398 
  Attributes:
6399 
   - success
6400 
   - cex
6401 
  """
6402 
 
6403 
  thrift_spec = (
6404 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6405 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6406 
  )
6407 
 
6408 
  def __init__(self, success=None, cex=None,):
6409 
    self.success = success
6410 
    self.cex = cex
6411 
 
6412 
  def read(self, iprot):
6413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6415 
      return
6416 
    iprot.readStructBegin()
6417 
    while True:
6418 
      (fname, ftype, fid) = iprot.readFieldBegin()
6419 
      if ftype == TType.STOP:
6420 
        break
6421 
      if fid == 0:
6422 
        if ftype == TType.LIST:
6423 
          self.success = []
7438 amit.gupta 6424 
          (_etype35, _size32) = iprot.readListBegin()
6425 
          for _i36 in xrange(_size32):
6426 
            _elem37 = Item()
6427 
            _elem37.read(iprot)
6428 
            self.success.append(_elem37)
5944 mandeep.dh 6429 
          iprot.readListEnd()
6430 
        else:
6431 
          iprot.skip(ftype)
6432 
      elif fid == 1:
6433 
        if ftype == TType.STRUCT:
6434 
          self.cex = CatalogServiceException()
6435 
          self.cex.read(iprot)
6436 
        else:
6437 
          iprot.skip(ftype)
6438 
      else:
6439 
        iprot.skip(ftype)
6440 
      iprot.readFieldEnd()
6441 
    iprot.readStructEnd()
6442 
 
6443 
  def write(self, oprot):
6444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6446 
      return
6447 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6448 
    if self.success is not None:
6449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6451 
      for iter38 in self.success:
6452 
        iter38.write(oprot)
5944 mandeep.dh 6453 
      oprot.writeListEnd()
6454 
      oprot.writeFieldEnd()
6455 
    if self.cex is not None:
6456 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6457 
      self.cex.write(oprot)
6458 
      oprot.writeFieldEnd()
6459 
    oprot.writeFieldStop()
6460 
    oprot.writeStructEnd()
6461 
 
6462 
  def validate(self):
6463 
    return
6464 
 
6465 
 
6466 
  def __repr__(self):
6467 
    L = ['%s=%r' % (key, value)
6468 
      for key, value in self.__dict__.iteritems()]
6469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6470 
 
6471 
  def __eq__(self, other):
6472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6473 
 
6474 
  def __ne__(self, other):
6475 
    return not (self == other)
6476 
 
6477 
class getValidItemsByCatalogId_args:
6478 
  """
6479 
  Attributes:
6480 
   - catalog_item_id
6481 
  """
6482 
 
6483 
  thrift_spec = (
6484 
    None, # 0
6485 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6486 
  )
6487 
 
6488 
  def __init__(self, catalog_item_id=None,):
6489 
    self.catalog_item_id = catalog_item_id
6490 
 
6491 
  def read(self, iprot):
6492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6494 
      return
6495 
    iprot.readStructBegin()
6496 
    while True:
6497 
      (fname, ftype, fid) = iprot.readFieldBegin()
6498 
      if ftype == TType.STOP:
6499 
        break
6500 
      if fid == 1:
6501 
        if ftype == TType.I64:
6502 
          self.catalog_item_id = iprot.readI64();
6503 
        else:
6504 
          iprot.skip(ftype)
6505 
      else:
6506 
        iprot.skip(ftype)
6507 
      iprot.readFieldEnd()
6508 
    iprot.readStructEnd()
6509 
 
6510 
  def write(self, oprot):
6511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6513 
      return
6514 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6515 
    if self.catalog_item_id is not None:
6516 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6517 
      oprot.writeI64(self.catalog_item_id)
6518 
      oprot.writeFieldEnd()
6519 
    oprot.writeFieldStop()
6520 
    oprot.writeStructEnd()
6521 
 
6522 
  def validate(self):
6523 
    return
6524 
 
6525 
 
6526 
  def __repr__(self):
6527 
    L = ['%s=%r' % (key, value)
6528 
      for key, value in self.__dict__.iteritems()]
6529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6530 
 
6531 
  def __eq__(self, other):
6532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6533 
 
6534 
  def __ne__(self, other):
6535 
    return not (self == other)
6536 
 
6537 
class getValidItemsByCatalogId_result:
6538 
  """
6539 
  Attributes:
6540 
   - success
6541 
   - cex
6542 
  """
6543 
 
6544 
  thrift_spec = (
6545 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6546 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6547 
  )
6548 
 
6549 
  def __init__(self, success=None, cex=None,):
6550 
    self.success = success
6551 
    self.cex = cex
6552 
 
6553 
  def read(self, iprot):
6554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6556 
      return
6557 
    iprot.readStructBegin()
6558 
    while True:
6559 
      (fname, ftype, fid) = iprot.readFieldBegin()
6560 
      if ftype == TType.STOP:
6561 
        break
6562 
      if fid == 0:
6563 
        if ftype == TType.LIST:
6564 
          self.success = []
7438 amit.gupta 6565 
          (_etype42, _size39) = iprot.readListBegin()
6566 
          for _i43 in xrange(_size39):
6567 
            _elem44 = Item()
6568 
            _elem44.read(iprot)
6569 
            self.success.append(_elem44)
5944 mandeep.dh 6570 
          iprot.readListEnd()
6571 
        else:
6572 
          iprot.skip(ftype)
6573 
      elif fid == 1:
6574 
        if ftype == TType.STRUCT:
6575 
          self.cex = CatalogServiceException()
6576 
          self.cex.read(iprot)
6577 
        else:
6578 
          iprot.skip(ftype)
6579 
      else:
6580 
        iprot.skip(ftype)
6581 
      iprot.readFieldEnd()
6582 
    iprot.readStructEnd()
6583 
 
6584 
  def write(self, oprot):
6585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6587 
      return
6588 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6589 
    if self.success is not None:
6590 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6591 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6592 
      for iter45 in self.success:
6593 
        iter45.write(oprot)
5944 mandeep.dh 6594 
      oprot.writeListEnd()
6595 
      oprot.writeFieldEnd()
6596 
    if self.cex is not None:
6597 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6598 
      self.cex.write(oprot)
6599 
      oprot.writeFieldEnd()
6600 
    oprot.writeFieldStop()
6601 
    oprot.writeStructEnd()
6602 
 
6603 
  def validate(self):
6604 
    return
6605 
 
6606 
 
6607 
  def __repr__(self):
6608 
    L = ['%s=%r' % (key, value)
6609 
      for key, value in self.__dict__.iteritems()]
6610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6611 
 
6612 
  def __eq__(self, other):
6613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6614 
 
6615 
  def __ne__(self, other):
6616 
    return not (self == other)
6617 
 
6618 
class getAllItems_args:
6619 
  """
6620 
  Attributes:
6621 
   - isActive
6622 
  """
6623 
 
6624 
  thrift_spec = (
6625 
    None, # 0
6626 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6627 
  )
6628 
 
6629 
  def __init__(self, isActive=None,):
6630 
    self.isActive = isActive
6631 
 
6632 
  def read(self, iprot):
6633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6635 
      return
6636 
    iprot.readStructBegin()
6637 
    while True:
6638 
      (fname, ftype, fid) = iprot.readFieldBegin()
6639 
      if ftype == TType.STOP:
6640 
        break
6641 
      if fid == 1:
6642 
        if ftype == TType.BOOL:
6643 
          self.isActive = iprot.readBool();
6644 
        else:
6645 
          iprot.skip(ftype)
6646 
      else:
6647 
        iprot.skip(ftype)
6648 
      iprot.readFieldEnd()
6649 
    iprot.readStructEnd()
6650 
 
6651 
  def write(self, oprot):
6652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6654 
      return
6655 
    oprot.writeStructBegin('getAllItems_args')
6656 
    if self.isActive is not None:
6657 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6658 
      oprot.writeBool(self.isActive)
6659 
      oprot.writeFieldEnd()
6660 
    oprot.writeFieldStop()
6661 
    oprot.writeStructEnd()
6662 
 
6663 
  def validate(self):
6664 
    return
6665 
 
6666 
 
6667 
  def __repr__(self):
6668 
    L = ['%s=%r' % (key, value)
6669 
      for key, value in self.__dict__.iteritems()]
6670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6671 
 
6672 
  def __eq__(self, other):
6673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6674 
 
6675 
  def __ne__(self, other):
6676 
    return not (self == other)
6677 
 
6678 
class getAllItems_result:
6679 
  """
6680 
  Attributes:
6681 
   - success
6682 
   - cex
6683 
  """
6684 
 
6685 
  thrift_spec = (
6686 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6687 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6688 
  )
6689 
 
6690 
  def __init__(self, success=None, cex=None,):
6691 
    self.success = success
6692 
    self.cex = cex
6693 
 
6694 
  def read(self, iprot):
6695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6697 
      return
6698 
    iprot.readStructBegin()
6699 
    while True:
6700 
      (fname, ftype, fid) = iprot.readFieldBegin()
6701 
      if ftype == TType.STOP:
6702 
        break
6703 
      if fid == 0:
6704 
        if ftype == TType.LIST:
6705 
          self.success = []
7438 amit.gupta 6706 
          (_etype49, _size46) = iprot.readListBegin()
6707 
          for _i50 in xrange(_size46):
6708 
            _elem51 = Item()
6709 
            _elem51.read(iprot)
6710 
            self.success.append(_elem51)
5944 mandeep.dh 6711 
          iprot.readListEnd()
6712 
        else:
6713 
          iprot.skip(ftype)
6714 
      elif fid == 1:
6715 
        if ftype == TType.STRUCT:
6716 
          self.cex = CatalogServiceException()
6717 
          self.cex.read(iprot)
6718 
        else:
6719 
          iprot.skip(ftype)
6720 
      else:
6721 
        iprot.skip(ftype)
6722 
      iprot.readFieldEnd()
6723 
    iprot.readStructEnd()
6724 
 
6725 
  def write(self, oprot):
6726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6728 
      return
6729 
    oprot.writeStructBegin('getAllItems_result')
6730 
    if self.success is not None:
6731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6732 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6733 
      for iter52 in self.success:
6734 
        iter52.write(oprot)
5944 mandeep.dh 6735 
      oprot.writeListEnd()
6736 
      oprot.writeFieldEnd()
6737 
    if self.cex is not None:
6738 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6739 
      self.cex.write(oprot)
6740 
      oprot.writeFieldEnd()
6741 
    oprot.writeFieldStop()
6742 
    oprot.writeStructEnd()
6743 
 
6744 
  def validate(self):
6745 
    return
6746 
 
6747 
 
6748 
  def __repr__(self):
6749 
    L = ['%s=%r' % (key, value)
6750 
      for key, value in self.__dict__.iteritems()]
6751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6752 
 
6753 
  def __eq__(self, other):
6754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6755 
 
6756 
  def __ne__(self, other):
6757 
    return not (self == other)
6758 
 
6759 
class getAllItemsByStatus_args:
6760 
  """
6761 
  Attributes:
6762 
   - itemStatus
6763 
  """
6764 
 
6765 
  thrift_spec = (
6766 
    None, # 0
6767 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6768 
  )
6769 
 
6770 
  def __init__(self, itemStatus=None,):
6771 
    self.itemStatus = itemStatus
6772 
 
6773 
  def read(self, iprot):
6774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6776 
      return
6777 
    iprot.readStructBegin()
6778 
    while True:
6779 
      (fname, ftype, fid) = iprot.readFieldBegin()
6780 
      if ftype == TType.STOP:
6781 
        break
6782 
      if fid == 1:
6783 
        if ftype == TType.I32:
6784 
          self.itemStatus = iprot.readI32();
6785 
        else:
6786 
          iprot.skip(ftype)
6787 
      else:
6788 
        iprot.skip(ftype)
6789 
      iprot.readFieldEnd()
6790 
    iprot.readStructEnd()
6791 
 
6792 
  def write(self, oprot):
6793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6795 
      return
6796 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6797 
    if self.itemStatus is not None:
6798 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6799 
      oprot.writeI32(self.itemStatus)
6800 
      oprot.writeFieldEnd()
6801 
    oprot.writeFieldStop()
6802 
    oprot.writeStructEnd()
6803 
 
6804 
  def validate(self):
6805 
    return
6806 
 
6807 
 
6808 
  def __repr__(self):
6809 
    L = ['%s=%r' % (key, value)
6810 
      for key, value in self.__dict__.iteritems()]
6811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6812 
 
6813 
  def __eq__(self, other):
6814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6815 
 
6816 
  def __ne__(self, other):
6817 
    return not (self == other)
6818 
 
6819 
class getAllItemsByStatus_result:
6820 
  """
6821 
  Attributes:
6822 
   - success
6823 
   - cex
6824 
  """
6825 
 
6826 
  thrift_spec = (
6827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6828 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6829 
  )
6830 
 
6831 
  def __init__(self, success=None, cex=None,):
6832 
    self.success = success
6833 
    self.cex = cex
6834 
 
6835 
  def read(self, iprot):
6836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6838 
      return
6839 
    iprot.readStructBegin()
6840 
    while True:
6841 
      (fname, ftype, fid) = iprot.readFieldBegin()
6842 
      if ftype == TType.STOP:
6843 
        break
6844 
      if fid == 0:
6845 
        if ftype == TType.LIST:
6846 
          self.success = []
7438 amit.gupta 6847 
          (_etype56, _size53) = iprot.readListBegin()
6848 
          for _i57 in xrange(_size53):
6849 
            _elem58 = Item()
6850 
            _elem58.read(iprot)
6851 
            self.success.append(_elem58)
5944 mandeep.dh 6852 
          iprot.readListEnd()
6853 
        else:
6854 
          iprot.skip(ftype)
6855 
      elif fid == 1:
6856 
        if ftype == TType.STRUCT:
6857 
          self.cex = CatalogServiceException()
6858 
          self.cex.read(iprot)
6859 
        else:
6860 
          iprot.skip(ftype)
6861 
      else:
6862 
        iprot.skip(ftype)
6863 
      iprot.readFieldEnd()
6864 
    iprot.readStructEnd()
6865 
 
6866 
  def write(self, oprot):
6867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6869 
      return
6870 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6871 
    if self.success is not None:
6872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6874 
      for iter59 in self.success:
6875 
        iter59.write(oprot)
5944 mandeep.dh 6876 
      oprot.writeListEnd()
6877 
      oprot.writeFieldEnd()
6878 
    if self.cex is not None:
6879 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6880 
      self.cex.write(oprot)
6881 
      oprot.writeFieldEnd()
6882 
    oprot.writeFieldStop()
6883 
    oprot.writeStructEnd()
6884 
 
6885 
  def validate(self):
6886 
    return
6887 
 
6888 
 
6889 
  def __repr__(self):
6890 
    L = ['%s=%r' % (key, value)
6891 
      for key, value in self.__dict__.iteritems()]
6892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6893 
 
6894 
  def __eq__(self, other):
6895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6896 
 
6897 
  def __ne__(self, other):
6898 
    return not (self == other)
6899 
 
6900 
class markItemAsContentComplete_args:
6901 
  """
6902 
  Attributes:
6903 
   - entityId
6904 
   - category
6905 
   - brand
6906 
   - modelName
6907 
   - modelNumber
6908 
  """
6909 
 
6910 
  thrift_spec = (
6911 
    None, # 0
6912 
    (1, TType.I64, 'entityId', None, None, ), # 1
6913 
    (2, TType.I64, 'category', None, None, ), # 2
6914 
    (3, TType.STRING, 'brand', None, None, ), # 3
6915 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6916 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6917 
  )
6918 
 
6919 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6920 
    self.entityId = entityId
6921 
    self.category = category
6922 
    self.brand = brand
6923 
    self.modelName = modelName
6924 
    self.modelNumber = modelNumber
6925 
 
6926 
  def read(self, iprot):
6927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6929 
      return
6930 
    iprot.readStructBegin()
6931 
    while True:
6932 
      (fname, ftype, fid) = iprot.readFieldBegin()
6933 
      if ftype == TType.STOP:
6934 
        break
6935 
      if fid == 1:
6936 
        if ftype == TType.I64:
6937 
          self.entityId = iprot.readI64();
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      elif fid == 2:
6941 
        if ftype == TType.I64:
6942 
          self.category = iprot.readI64();
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      elif fid == 3:
6946 
        if ftype == TType.STRING:
6947 
          self.brand = iprot.readString();
6948 
        else:
6949 
          iprot.skip(ftype)
6950 
      elif fid == 4:
6951 
        if ftype == TType.STRING:
6952 
          self.modelName = iprot.readString();
6953 
        else:
6954 
          iprot.skip(ftype)
6955 
      elif fid == 5:
6956 
        if ftype == TType.STRING:
6957 
          self.modelNumber = iprot.readString();
6958 
        else:
6959 
          iprot.skip(ftype)
6960 
      else:
6961 
        iprot.skip(ftype)
6962 
      iprot.readFieldEnd()
6963 
    iprot.readStructEnd()
6964 
 
6965 
  def write(self, oprot):
6966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6968 
      return
6969 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6970 
    if self.entityId is not None:
6971 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6972 
      oprot.writeI64(self.entityId)
6973 
      oprot.writeFieldEnd()
6974 
    if self.category is not None:
6975 
      oprot.writeFieldBegin('category', TType.I64, 2)
6976 
      oprot.writeI64(self.category)
6977 
      oprot.writeFieldEnd()
6978 
    if self.brand is not None:
6979 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6980 
      oprot.writeString(self.brand)
6981 
      oprot.writeFieldEnd()
6982 
    if self.modelName is not None:
6983 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6984 
      oprot.writeString(self.modelName)
6985 
      oprot.writeFieldEnd()
6986 
    if self.modelNumber is not None:
6987 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6988 
      oprot.writeString(self.modelNumber)
6989 
      oprot.writeFieldEnd()
6990 
    oprot.writeFieldStop()
6991 
    oprot.writeStructEnd()
6992 
 
6993 
  def validate(self):
6994 
    return
6995 
 
6996 
 
6997 
  def __repr__(self):
6998 
    L = ['%s=%r' % (key, value)
6999 
      for key, value in self.__dict__.iteritems()]
7000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7001 
 
7002 
  def __eq__(self, other):
7003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7004 
 
7005 
  def __ne__(self, other):
7006 
    return not (self == other)
7007 
 
7008 
class markItemAsContentComplete_result:
7009 
  """
7010 
  Attributes:
7011 
   - success
7012 
   - cex
7013 
  """
7014 
 
7015 
  thrift_spec = (
7016 
    (0, TType.BOOL, 'success', None, None, ), # 0
7017 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7018 
  )
7019 
 
7020 
  def __init__(self, success=None, cex=None,):
7021 
    self.success = success
7022 
    self.cex = cex
7023 
 
7024 
  def read(self, iprot):
7025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7027 
      return
7028 
    iprot.readStructBegin()
7029 
    while True:
7030 
      (fname, ftype, fid) = iprot.readFieldBegin()
7031 
      if ftype == TType.STOP:
7032 
        break
7033 
      if fid == 0:
7034 
        if ftype == TType.BOOL:
7035 
          self.success = iprot.readBool();
7036 
        else:
7037 
          iprot.skip(ftype)
7038 
      elif fid == 1:
7039 
        if ftype == TType.STRUCT:
7040 
          self.cex = CatalogServiceException()
7041 
          self.cex.read(iprot)
7042 
        else:
7043 
          iprot.skip(ftype)
7044 
      else:
7045 
        iprot.skip(ftype)
7046 
      iprot.readFieldEnd()
7047 
    iprot.readStructEnd()
7048 
 
7049 
  def write(self, oprot):
7050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7052 
      return
7053 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7054 
    if self.success is not None:
7055 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7056 
      oprot.writeBool(self.success)
7057 
      oprot.writeFieldEnd()
7058 
    if self.cex is not None:
7059 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7060 
      self.cex.write(oprot)
7061 
      oprot.writeFieldEnd()
7062 
    oprot.writeFieldStop()
7063 
    oprot.writeStructEnd()
7064 
 
7065 
  def validate(self):
7066 
    return
7067 
 
7068 
 
7069 
  def __repr__(self):
7070 
    L = ['%s=%r' % (key, value)
7071 
      for key, value in self.__dict__.iteritems()]
7072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7073 
 
7074 
  def __eq__(self, other):
7075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7076 
 
7077 
  def __ne__(self, other):
7078 
    return not (self == other)
7079 
 
7080 
class getAllItemsInRange_args:
7081 
  """
7082 
  Attributes:
7083 
   - offset
7084 
   - limit
7085 
  """
7086 
 
7087 
  thrift_spec = (
7088 
    None, # 0
7089 
    (1, TType.I64, 'offset', None, None, ), # 1
7090 
    (2, TType.I64, 'limit', None, None, ), # 2
7091 
  )
7092 
 
7093 
  def __init__(self, offset=None, limit=None,):
7094 
    self.offset = offset
7095 
    self.limit = limit
7096 
 
7097 
  def read(self, iprot):
7098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7100 
      return
7101 
    iprot.readStructBegin()
7102 
    while True:
7103 
      (fname, ftype, fid) = iprot.readFieldBegin()
7104 
      if ftype == TType.STOP:
7105 
        break
7106 
      if fid == 1:
7107 
        if ftype == TType.I64:
7108 
          self.offset = iprot.readI64();
7109 
        else:
7110 
          iprot.skip(ftype)
7111 
      elif fid == 2:
7112 
        if ftype == TType.I64:
7113 
          self.limit = iprot.readI64();
7114 
        else:
7115 
          iprot.skip(ftype)
7116 
      else:
7117 
        iprot.skip(ftype)
7118 
      iprot.readFieldEnd()
7119 
    iprot.readStructEnd()
7120 
 
7121 
  def write(self, oprot):
7122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7124 
      return
7125 
    oprot.writeStructBegin('getAllItemsInRange_args')
7126 
    if self.offset is not None:
7127 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7128 
      oprot.writeI64(self.offset)
7129 
      oprot.writeFieldEnd()
7130 
    if self.limit is not None:
7131 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7132 
      oprot.writeI64(self.limit)
7133 
      oprot.writeFieldEnd()
7134 
    oprot.writeFieldStop()
7135 
    oprot.writeStructEnd()
7136 
 
7137 
  def validate(self):
7138 
    return
7139 
 
7140 
 
7141 
  def __repr__(self):
7142 
    L = ['%s=%r' % (key, value)
7143 
      for key, value in self.__dict__.iteritems()]
7144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7145 
 
7146 
  def __eq__(self, other):
7147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7148 
 
7149 
  def __ne__(self, other):
7150 
    return not (self == other)
7151 
 
7152 
class getAllItemsInRange_result:
7153 
  """
7154 
  Attributes:
7155 
   - success
7156 
   - cex
7157 
  """
7158 
 
7159 
  thrift_spec = (
7160 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7161 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7162 
  )
7163 
 
7164 
  def __init__(self, success=None, cex=None,):
7165 
    self.success = success
7166 
    self.cex = cex
7167 
 
7168 
  def read(self, iprot):
7169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7171 
      return
7172 
    iprot.readStructBegin()
7173 
    while True:
7174 
      (fname, ftype, fid) = iprot.readFieldBegin()
7175 
      if ftype == TType.STOP:
7176 
        break
7177 
      if fid == 0:
7178 
        if ftype == TType.LIST:
7179 
          self.success = []
7438 amit.gupta 7180 
          (_etype63, _size60) = iprot.readListBegin()
7181 
          for _i64 in xrange(_size60):
7182 
            _elem65 = Item()
7183 
            _elem65.read(iprot)
7184 
            self.success.append(_elem65)
5944 mandeep.dh 7185 
          iprot.readListEnd()
7186 
        else:
7187 
          iprot.skip(ftype)
7188 
      elif fid == 1:
7189 
        if ftype == TType.STRUCT:
7190 
          self.cex = CatalogServiceException()
7191 
          self.cex.read(iprot)
7192 
        else:
7193 
          iprot.skip(ftype)
7194 
      else:
7195 
        iprot.skip(ftype)
7196 
      iprot.readFieldEnd()
7197 
    iprot.readStructEnd()
7198 
 
7199 
  def write(self, oprot):
7200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7202 
      return
7203 
    oprot.writeStructBegin('getAllItemsInRange_result')
7204 
    if self.success is not None:
7205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7207 
      for iter66 in self.success:
7208 
        iter66.write(oprot)
5944 mandeep.dh 7209 
      oprot.writeListEnd()
7210 
      oprot.writeFieldEnd()
7211 
    if self.cex is not None:
7212 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7213 
      self.cex.write(oprot)
7214 
      oprot.writeFieldEnd()
7215 
    oprot.writeFieldStop()
7216 
    oprot.writeStructEnd()
7217 
 
7218 
  def validate(self):
7219 
    return
7220 
 
7221 
 
7222 
  def __repr__(self):
7223 
    L = ['%s=%r' % (key, value)
7224 
      for key, value in self.__dict__.iteritems()]
7225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7226 
 
7227 
  def __eq__(self, other):
7228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7229 
 
7230 
  def __ne__(self, other):
7231 
    return not (self == other)
7232 
 
7233 
class getAllItemsByStatusInRange_args:
7234 
  """
7235 
  Attributes:
7236 
   - itemStatus
7237 
   - offset
7238 
   - limit
7239 
  """
7240 
 
7241 
  thrift_spec = (
7242 
    None, # 0
7243 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7244 
    (2, TType.I64, 'offset', None, None, ), # 2
7245 
    (3, TType.I64, 'limit', None, None, ), # 3
7246 
  )
7247 
 
7248 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7249 
    self.itemStatus = itemStatus
7250 
    self.offset = offset
7251 
    self.limit = limit
7252 
 
7253 
  def read(self, iprot):
7254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7256 
      return
7257 
    iprot.readStructBegin()
7258 
    while True:
7259 
      (fname, ftype, fid) = iprot.readFieldBegin()
7260 
      if ftype == TType.STOP:
7261 
        break
7262 
      if fid == 1:
7263 
        if ftype == TType.I32:
7264 
          self.itemStatus = iprot.readI32();
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 2:
7268 
        if ftype == TType.I64:
7269 
          self.offset = iprot.readI64();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      elif fid == 3:
7273 
        if ftype == TType.I64:
7274 
          self.limit = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      else:
7278 
        iprot.skip(ftype)
7279 
      iprot.readFieldEnd()
7280 
    iprot.readStructEnd()
7281 
 
7282 
  def write(self, oprot):
7283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7285 
      return
7286 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7287 
    if self.itemStatus is not None:
7288 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7289 
      oprot.writeI32(self.itemStatus)
7290 
      oprot.writeFieldEnd()
7291 
    if self.offset is not None:
7292 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7293 
      oprot.writeI64(self.offset)
7294 
      oprot.writeFieldEnd()
7295 
    if self.limit is not None:
7296 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7297 
      oprot.writeI64(self.limit)
7298 
      oprot.writeFieldEnd()
7299 
    oprot.writeFieldStop()
7300 
    oprot.writeStructEnd()
7301 
 
7302 
  def validate(self):
7303 
    return
7304 
 
7305 
 
7306 
  def __repr__(self):
7307 
    L = ['%s=%r' % (key, value)
7308 
      for key, value in self.__dict__.iteritems()]
7309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7310 
 
7311 
  def __eq__(self, other):
7312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7313 
 
7314 
  def __ne__(self, other):
7315 
    return not (self == other)
7316 
 
7317 
class getAllItemsByStatusInRange_result:
7318 
  """
7319 
  Attributes:
7320 
   - success
7321 
   - cex
7322 
  """
7323 
 
7324 
  thrift_spec = (
7325 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7326 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7327 
  )
7328 
 
7329 
  def __init__(self, success=None, cex=None,):
7330 
    self.success = success
7331 
    self.cex = cex
7332 
 
7333 
  def read(self, iprot):
7334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7336 
      return
7337 
    iprot.readStructBegin()
7338 
    while True:
7339 
      (fname, ftype, fid) = iprot.readFieldBegin()
7340 
      if ftype == TType.STOP:
7341 
        break
7342 
      if fid == 0:
7343 
        if ftype == TType.LIST:
7344 
          self.success = []
7438 amit.gupta 7345 
          (_etype70, _size67) = iprot.readListBegin()
7346 
          for _i71 in xrange(_size67):
7347 
            _elem72 = Item()
7348 
            _elem72.read(iprot)
7349 
            self.success.append(_elem72)
5944 mandeep.dh 7350 
          iprot.readListEnd()
7351 
        else:
7352 
          iprot.skip(ftype)
7353 
      elif fid == 1:
7354 
        if ftype == TType.STRUCT:
7355 
          self.cex = CatalogServiceException()
7356 
          self.cex.read(iprot)
7357 
        else:
7358 
          iprot.skip(ftype)
7359 
      else:
7360 
        iprot.skip(ftype)
7361 
      iprot.readFieldEnd()
7362 
    iprot.readStructEnd()
7363 
 
7364 
  def write(self, oprot):
7365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7367 
      return
7368 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7369 
    if self.success is not None:
7370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7372 
      for iter73 in self.success:
7373 
        iter73.write(oprot)
5944 mandeep.dh 7374 
      oprot.writeListEnd()
7375 
      oprot.writeFieldEnd()
7376 
    if self.cex is not None:
7377 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7378 
      self.cex.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def validate(self):
7384 
    return
7385 
 
7386 
 
7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class getItemCountByStatus_args:
7399 
  """
7400 
  Attributes:
7401 
   - useStatus
7402 
   - itemStatus
7403 
  """
7404 
 
7405 
  thrift_spec = (
7406 
    None, # 0
7407 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7408 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7409 
  )
7410 
 
7411 
  def __init__(self, useStatus=None, itemStatus=None,):
7412 
    self.useStatus = useStatus
7413 
    self.itemStatus = itemStatus
7414 
 
7415 
  def read(self, iprot):
7416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7418 
      return
7419 
    iprot.readStructBegin()
7420 
    while True:
7421 
      (fname, ftype, fid) = iprot.readFieldBegin()
7422 
      if ftype == TType.STOP:
7423 
        break
7424 
      if fid == 1:
7425 
        if ftype == TType.BOOL:
7426 
          self.useStatus = iprot.readBool();
7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      elif fid == 2:
7430 
        if ftype == TType.I32:
7431 
          self.itemStatus = iprot.readI32();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('getItemCountByStatus_args')
7444 
    if self.useStatus is not None:
7445 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7446 
      oprot.writeBool(self.useStatus)
7447 
      oprot.writeFieldEnd()
7448 
    if self.itemStatus is not None:
7449 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7450 
      oprot.writeI32(self.itemStatus)
7451 
      oprot.writeFieldEnd()
7452 
    oprot.writeFieldStop()
7453 
    oprot.writeStructEnd()
7454 
 
7455 
  def validate(self):
7456 
    return
7457 
 
7458 
 
7459 
  def __repr__(self):
7460 
    L = ['%s=%r' % (key, value)
7461 
      for key, value in self.__dict__.iteritems()]
7462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7463 
 
7464 
  def __eq__(self, other):
7465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7466 
 
7467 
  def __ne__(self, other):
7468 
    return not (self == other)
7469 
 
7470 
class getItemCountByStatus_result:
7471 
  """
7472 
  Attributes:
7473 
   - success
7474 
  """
7475 
 
7476 
  thrift_spec = (
7477 
    (0, TType.I32, 'success', None, None, ), # 0
7478 
  )
7479 
 
7480 
  def __init__(self, success=None,):
7481 
    self.success = success
7482 
 
7483 
  def read(self, iprot):
7484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7486 
      return
7487 
    iprot.readStructBegin()
7488 
    while True:
7489 
      (fname, ftype, fid) = iprot.readFieldBegin()
7490 
      if ftype == TType.STOP:
7491 
        break
7492 
      if fid == 0:
7493 
        if ftype == TType.I32:
7494 
          self.success = iprot.readI32();
7495 
        else:
7496 
          iprot.skip(ftype)
7497 
      else:
7498 
        iprot.skip(ftype)
7499 
      iprot.readFieldEnd()
7500 
    iprot.readStructEnd()
7501 
 
7502 
  def write(self, oprot):
7503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7505 
      return
7506 
    oprot.writeStructBegin('getItemCountByStatus_result')
7507 
    if self.success is not None:
7508 
      oprot.writeFieldBegin('success', TType.I32, 0)
7509 
      oprot.writeI32(self.success)
7510 
      oprot.writeFieldEnd()
7511 
    oprot.writeFieldStop()
7512 
    oprot.writeStructEnd()
7513 
 
7514 
  def validate(self):
7515 
    return
7516 
 
7517 
 
7518 
  def __repr__(self):
7519 
    L = ['%s=%r' % (key, value)
7520 
      for key, value in self.__dict__.iteritems()]
7521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7522 
 
7523 
  def __eq__(self, other):
7524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7525 
 
7526 
  def __ne__(self, other):
7527 
    return not (self == other)
7528 
 
7529 
class getBestSellers_args:
7530 
 
7531 
  thrift_spec = (
7532 
  )
7533 
 
7534 
  def read(self, iprot):
7535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7537 
      return
7538 
    iprot.readStructBegin()
7539 
    while True:
7540 
      (fname, ftype, fid) = iprot.readFieldBegin()
7541 
      if ftype == TType.STOP:
7542 
        break
7543 
      else:
7544 
        iprot.skip(ftype)
7545 
      iprot.readFieldEnd()
7546 
    iprot.readStructEnd()
7547 
 
7548 
  def write(self, oprot):
7549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7551 
      return
7552 
    oprot.writeStructBegin('getBestSellers_args')
7553 
    oprot.writeFieldStop()
7554 
    oprot.writeStructEnd()
7555 
 
7556 
  def validate(self):
7557 
    return
7558 
 
7559 
 
7560 
  def __repr__(self):
7561 
    L = ['%s=%r' % (key, value)
7562 
      for key, value in self.__dict__.iteritems()]
7563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7564 
 
7565 
  def __eq__(self, other):
7566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7567 
 
7568 
  def __ne__(self, other):
7569 
    return not (self == other)
7570 
 
7571 
class getBestSellers_result:
7572 
  """
7573 
  Attributes:
7574 
   - success
7575 
   - isex
7576 
  """
7577 
 
7578 
  thrift_spec = (
7579 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7580 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7581 
  )
7582 
 
7583 
  def __init__(self, success=None, isex=None,):
7584 
    self.success = success
7585 
    self.isex = isex
7586 
 
7587 
  def read(self, iprot):
7588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7590 
      return
7591 
    iprot.readStructBegin()
7592 
    while True:
7593 
      (fname, ftype, fid) = iprot.readFieldBegin()
7594 
      if ftype == TType.STOP:
7595 
        break
7596 
      if fid == 0:
7597 
        if ftype == TType.LIST:
7598 
          self.success = []
7438 amit.gupta 7599 
          (_etype77, _size74) = iprot.readListBegin()
7600 
          for _i78 in xrange(_size74):
7601 
            _elem79 = Item()
7602 
            _elem79.read(iprot)
7603 
            self.success.append(_elem79)
5944 mandeep.dh 7604 
          iprot.readListEnd()
7605 
        else:
7606 
          iprot.skip(ftype)
7607 
      elif fid == 1:
7608 
        if ftype == TType.STRUCT:
7609 
          self.isex = CatalogServiceException()
7610 
          self.isex.read(iprot)
7611 
        else:
7612 
          iprot.skip(ftype)
7613 
      else:
7614 
        iprot.skip(ftype)
7615 
      iprot.readFieldEnd()
7616 
    iprot.readStructEnd()
7617 
 
7618 
  def write(self, oprot):
7619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7621 
      return
7622 
    oprot.writeStructBegin('getBestSellers_result')
7623 
    if self.success is not None:
7624 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7625 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7626 
      for iter80 in self.success:
7627 
        iter80.write(oprot)
5944 mandeep.dh 7628 
      oprot.writeListEnd()
7629 
      oprot.writeFieldEnd()
7630 
    if self.isex is not None:
7631 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7632 
      self.isex.write(oprot)
7633 
      oprot.writeFieldEnd()
7634 
    oprot.writeFieldStop()
7635 
    oprot.writeStructEnd()
7636 
 
7637 
  def validate(self):
7638 
    return
7639 
 
7640 
 
7641 
  def __repr__(self):
7642 
    L = ['%s=%r' % (key, value)
7643 
      for key, value in self.__dict__.iteritems()]
7644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7645 
 
7646 
  def __eq__(self, other):
7647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7648 
 
7649 
  def __ne__(self, other):
7650 
    return not (self == other)
7651 
 
7652 
class getBestSellersCatalogIds_args:
7653 
  """
7654 
  Attributes:
7655 
   - beginIndex
7656 
   - totalItems
7657 
   - brand
7658 
   - category
7659 
  """
7660 
 
7661 
  thrift_spec = (
7662 
    None, # 0
7663 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7664 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7665 
    (3, TType.STRING, 'brand', None, None, ), # 3
7666 
    (4, TType.I64, 'category', None, None, ), # 4
7667 
  )
7668 
 
7669 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7670 
    self.beginIndex = beginIndex
7671 
    self.totalItems = totalItems
7672 
    self.brand = brand
7673 
    self.category = category
7674 
 
7675 
  def read(self, iprot):
7676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7678 
      return
7679 
    iprot.readStructBegin()
7680 
    while True:
7681 
      (fname, ftype, fid) = iprot.readFieldBegin()
7682 
      if ftype == TType.STOP:
7683 
        break
7684 
      if fid == 1:
7685 
        if ftype == TType.I64:
7686 
          self.beginIndex = iprot.readI64();
7687 
        else:
7688 
          iprot.skip(ftype)
7689 
      elif fid == 2:
7690 
        if ftype == TType.I64:
7691 
          self.totalItems = iprot.readI64();
7692 
        else:
7693 
          iprot.skip(ftype)
7694 
      elif fid == 3:
7695 
        if ftype == TType.STRING:
7696 
          self.brand = iprot.readString();
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      elif fid == 4:
7700 
        if ftype == TType.I64:
7701 
          self.category = iprot.readI64();
7702 
        else:
7703 
          iprot.skip(ftype)
7704 
      else:
7705 
        iprot.skip(ftype)
7706 
      iprot.readFieldEnd()
7707 
    iprot.readStructEnd()
7708 
 
7709 
  def write(self, oprot):
7710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7712 
      return
7713 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7714 
    if self.beginIndex is not None:
7715 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7716 
      oprot.writeI64(self.beginIndex)
7717 
      oprot.writeFieldEnd()
7718 
    if self.totalItems is not None:
7719 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7720 
      oprot.writeI64(self.totalItems)
7721 
      oprot.writeFieldEnd()
7722 
    if self.brand is not None:
7723 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7724 
      oprot.writeString(self.brand)
7725 
      oprot.writeFieldEnd()
7726 
    if self.category is not None:
7727 
      oprot.writeFieldBegin('category', TType.I64, 4)
7728 
      oprot.writeI64(self.category)
7729 
      oprot.writeFieldEnd()
7730 
    oprot.writeFieldStop()
7731 
    oprot.writeStructEnd()
7732 
 
7733 
  def validate(self):
7734 
    return
7735 
 
7736 
 
7737 
  def __repr__(self):
7738 
    L = ['%s=%r' % (key, value)
7739 
      for key, value in self.__dict__.iteritems()]
7740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7741 
 
7742 
  def __eq__(self, other):
7743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7744 
 
7745 
  def __ne__(self, other):
7746 
    return not (self == other)
7747 
 
7748 
class getBestSellersCatalogIds_result:
7749 
  """
7750 
  Attributes:
7751 
   - success
7752 
   - cex
7753 
  """
7754 
 
7755 
  thrift_spec = (
7756 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7757 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7758 
  )
7759 
 
7760 
  def __init__(self, success=None, cex=None,):
7761 
    self.success = success
7762 
    self.cex = cex
7763 
 
7764 
  def read(self, iprot):
7765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7767 
      return
7768 
    iprot.readStructBegin()
7769 
    while True:
7770 
      (fname, ftype, fid) = iprot.readFieldBegin()
7771 
      if ftype == TType.STOP:
7772 
        break
7773 
      if fid == 0:
7774 
        if ftype == TType.LIST:
7775 
          self.success = []
7438 amit.gupta 7776 
          (_etype84, _size81) = iprot.readListBegin()
7777 
          for _i85 in xrange(_size81):
7778 
            _elem86 = iprot.readI64();
7779 
            self.success.append(_elem86)
5944 mandeep.dh 7780 
          iprot.readListEnd()
7781 
        else:
7782 
          iprot.skip(ftype)
7783 
      elif fid == 1:
7784 
        if ftype == TType.STRUCT:
7785 
          self.cex = CatalogServiceException()
7786 
          self.cex.read(iprot)
7787 
        else:
7788 
          iprot.skip(ftype)
7789 
      else:
7790 
        iprot.skip(ftype)
7791 
      iprot.readFieldEnd()
7792 
    iprot.readStructEnd()
7793 
 
7794 
  def write(self, oprot):
7795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7797 
      return
7798 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7799 
    if self.success is not None:
7800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7801 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 7802 
      for iter87 in self.success:
7803 
        oprot.writeI64(iter87)
5944 mandeep.dh 7804 
      oprot.writeListEnd()
7805 
      oprot.writeFieldEnd()
7806 
    if self.cex is not None:
7807 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7808 
      self.cex.write(oprot)
7809 
      oprot.writeFieldEnd()
7810 
    oprot.writeFieldStop()
7811 
    oprot.writeStructEnd()
7812 
 
7813 
  def validate(self):
7814 
    return
7815 
 
7816 
 
7817 
  def __repr__(self):
7818 
    L = ['%s=%r' % (key, value)
7819 
      for key, value in self.__dict__.iteritems()]
7820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7821 
 
7822 
  def __eq__(self, other):
7823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7824 
 
7825 
  def __ne__(self, other):
7826 
    return not (self == other)
7827 
 
7828 
class getBestSellersCount_args:
7829 
 
7830 
  thrift_spec = (
7831 
  )
7832 
 
7833 
  def read(self, iprot):
7834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7836 
      return
7837 
    iprot.readStructBegin()
7838 
    while True:
7839 
      (fname, ftype, fid) = iprot.readFieldBegin()
7840 
      if ftype == TType.STOP:
7841 
        break
7842 
      else:
7843 
        iprot.skip(ftype)
7844 
      iprot.readFieldEnd()
7845 
    iprot.readStructEnd()
7846 
 
7847 
  def write(self, oprot):
7848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7850 
      return
7851 
    oprot.writeStructBegin('getBestSellersCount_args')
7852 
    oprot.writeFieldStop()
7853 
    oprot.writeStructEnd()
7854 
 
7855 
  def validate(self):
7856 
    return
7857 
 
7858 
 
7859 
  def __repr__(self):
7860 
    L = ['%s=%r' % (key, value)
7861 
      for key, value in self.__dict__.iteritems()]
7862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7863 
 
7864 
  def __eq__(self, other):
7865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7866 
 
7867 
  def __ne__(self, other):
7868 
    return not (self == other)
7869 
 
7870 
class getBestSellersCount_result:
7871 
  """
7872 
  Attributes:
7873 
   - success
7874 
   - cex
7875 
  """
7876 
 
7877 
  thrift_spec = (
7878 
    (0, TType.I64, 'success', None, None, ), # 0
7879 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7880 
  )
7881 
 
7882 
  def __init__(self, success=None, cex=None,):
7883 
    self.success = success
7884 
    self.cex = cex
7885 
 
7886 
  def read(self, iprot):
7887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7889 
      return
7890 
    iprot.readStructBegin()
7891 
    while True:
7892 
      (fname, ftype, fid) = iprot.readFieldBegin()
7893 
      if ftype == TType.STOP:
7894 
        break
7895 
      if fid == 0:
7896 
        if ftype == TType.I64:
7897 
          self.success = iprot.readI64();
7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      elif fid == 1:
7901 
        if ftype == TType.STRUCT:
7902 
          self.cex = CatalogServiceException()
7903 
          self.cex.read(iprot)
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      else:
7907 
        iprot.skip(ftype)
7908 
      iprot.readFieldEnd()
7909 
    iprot.readStructEnd()
7910 
 
7911 
  def write(self, oprot):
7912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7914 
      return
7915 
    oprot.writeStructBegin('getBestSellersCount_result')
7916 
    if self.success is not None:
7917 
      oprot.writeFieldBegin('success', TType.I64, 0)
7918 
      oprot.writeI64(self.success)
7919 
      oprot.writeFieldEnd()
7920 
    if self.cex is not None:
7921 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7922 
      self.cex.write(oprot)
7923 
      oprot.writeFieldEnd()
7924 
    oprot.writeFieldStop()
7925 
    oprot.writeStructEnd()
7926 
 
7927 
  def validate(self):
7928 
    return
7929 
 
7930 
 
7931 
  def __repr__(self):
7932 
    L = ['%s=%r' % (key, value)
7933 
      for key, value in self.__dict__.iteritems()]
7934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7935 
 
7936 
  def __eq__(self, other):
7937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7938 
 
7939 
  def __ne__(self, other):
7940 
    return not (self == other)
7941 
 
7942 
class getBestDeals_args:
7943 
 
7944 
  thrift_spec = (
7945 
  )
7946 
 
7947 
  def read(self, iprot):
7948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7950 
      return
7951 
    iprot.readStructBegin()
7952 
    while True:
7953 
      (fname, ftype, fid) = iprot.readFieldBegin()
7954 
      if ftype == TType.STOP:
7955 
        break
7956 
      else:
7957 
        iprot.skip(ftype)
7958 
      iprot.readFieldEnd()
7959 
    iprot.readStructEnd()
7960 
 
7961 
  def write(self, oprot):
7962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7964 
      return
7965 
    oprot.writeStructBegin('getBestDeals_args')
7966 
    oprot.writeFieldStop()
7967 
    oprot.writeStructEnd()
7968 
 
7969 
  def validate(self):
7970 
    return
7971 
 
7972 
 
7973 
  def __repr__(self):
7974 
    L = ['%s=%r' % (key, value)
7975 
      for key, value in self.__dict__.iteritems()]
7976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7977 
 
7978 
  def __eq__(self, other):
7979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7980 
 
7981 
  def __ne__(self, other):
7982 
    return not (self == other)
7983 
 
7984 
class getBestDeals_result:
7985 
  """
7986 
  Attributes:
7987 
   - success
7988 
   - isex
7989 
  """
7990 
 
7991 
  thrift_spec = (
7992 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7993 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7994 
  )
7995 
 
7996 
  def __init__(self, success=None, isex=None,):
7997 
    self.success = success
7998 
    self.isex = isex
7999 
 
8000 
  def read(self, iprot):
8001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8003 
      return
8004 
    iprot.readStructBegin()
8005 
    while True:
8006 
      (fname, ftype, fid) = iprot.readFieldBegin()
8007 
      if ftype == TType.STOP:
8008 
        break
8009 
      if fid == 0:
8010 
        if ftype == TType.LIST:
8011 
          self.success = []
7438 amit.gupta 8012 
          (_etype91, _size88) = iprot.readListBegin()
8013 
          for _i92 in xrange(_size88):
8014 
            _elem93 = Item()
8015 
            _elem93.read(iprot)
8016 
            self.success.append(_elem93)
5944 mandeep.dh 8017 
          iprot.readListEnd()
8018 
        else:
8019 
          iprot.skip(ftype)
8020 
      elif fid == 1:
8021 
        if ftype == TType.STRUCT:
8022 
          self.isex = CatalogServiceException()
8023 
          self.isex.read(iprot)
8024 
        else:
8025 
          iprot.skip(ftype)
8026 
      else:
8027 
        iprot.skip(ftype)
8028 
      iprot.readFieldEnd()
8029 
    iprot.readStructEnd()
8030 
 
8031 
  def write(self, oprot):
8032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8034 
      return
8035 
    oprot.writeStructBegin('getBestDeals_result')
8036 
    if self.success is not None:
8037 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8038 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8039 
      for iter94 in self.success:
8040 
        iter94.write(oprot)
5944 mandeep.dh 8041 
      oprot.writeListEnd()
8042 
      oprot.writeFieldEnd()
8043 
    if self.isex is not None:
8044 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8045 
      self.isex.write(oprot)
8046 
      oprot.writeFieldEnd()
8047 
    oprot.writeFieldStop()
8048 
    oprot.writeStructEnd()
8049 
 
8050 
  def validate(self):
8051 
    return
8052 
 
8053 
 
8054 
  def __repr__(self):
8055 
    L = ['%s=%r' % (key, value)
8056 
      for key, value in self.__dict__.iteritems()]
8057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8058 
 
8059 
  def __eq__(self, other):
8060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8061 
 
8062 
  def __ne__(self, other):
8063 
    return not (self == other)
8064 
 
8065 
class getBestDealsCatalogIds_args:
8066 
  """
8067 
  Attributes:
8068 
   - beginIndex
8069 
   - totalItems
8070 
   - brand
8071 
   - category
8072 
  """
8073 
 
8074 
  thrift_spec = (
8075 
    None, # 0
8076 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8077 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8078 
    (3, TType.STRING, 'brand', None, None, ), # 3
8079 
    (4, TType.I64, 'category', None, None, ), # 4
8080 
  )
8081 
 
8082 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8083 
    self.beginIndex = beginIndex
8084 
    self.totalItems = totalItems
8085 
    self.brand = brand
8086 
    self.category = category
8087 
 
8088 
  def read(self, iprot):
8089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8091 
      return
8092 
    iprot.readStructBegin()
8093 
    while True:
8094 
      (fname, ftype, fid) = iprot.readFieldBegin()
8095 
      if ftype == TType.STOP:
8096 
        break
8097 
      if fid == 1:
8098 
        if ftype == TType.I64:
8099 
          self.beginIndex = iprot.readI64();
8100 
        else:
8101 
          iprot.skip(ftype)
8102 
      elif fid == 2:
8103 
        if ftype == TType.I64:
8104 
          self.totalItems = iprot.readI64();
8105 
        else:
8106 
          iprot.skip(ftype)
8107 
      elif fid == 3:
8108 
        if ftype == TType.STRING:
8109 
          self.brand = iprot.readString();
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      elif fid == 4:
8113 
        if ftype == TType.I64:
8114 
          self.category = iprot.readI64();
8115 
        else:
8116 
          iprot.skip(ftype)
8117 
      else:
8118 
        iprot.skip(ftype)
8119 
      iprot.readFieldEnd()
8120 
    iprot.readStructEnd()
8121 
 
8122 
  def write(self, oprot):
8123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8125 
      return
8126 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8127 
    if self.beginIndex is not None:
8128 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8129 
      oprot.writeI64(self.beginIndex)
8130 
      oprot.writeFieldEnd()
8131 
    if self.totalItems is not None:
8132 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8133 
      oprot.writeI64(self.totalItems)
8134 
      oprot.writeFieldEnd()
8135 
    if self.brand is not None:
8136 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8137 
      oprot.writeString(self.brand)
8138 
      oprot.writeFieldEnd()
8139 
    if self.category is not None:
8140 
      oprot.writeFieldBegin('category', TType.I64, 4)
8141 
      oprot.writeI64(self.category)
8142 
      oprot.writeFieldEnd()
8143 
    oprot.writeFieldStop()
8144 
    oprot.writeStructEnd()
8145 
 
8146 
  def validate(self):
8147 
    return
8148 
 
8149 
 
8150 
  def __repr__(self):
8151 
    L = ['%s=%r' % (key, value)
8152 
      for key, value in self.__dict__.iteritems()]
8153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8154 
 
8155 
  def __eq__(self, other):
8156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8157 
 
8158 
  def __ne__(self, other):
8159 
    return not (self == other)
8160 
 
8161 
class getBestDealsCatalogIds_result:
8162 
  """
8163 
  Attributes:
8164 
   - success
8165 
   - cex
8166 
  """
8167 
 
8168 
  thrift_spec = (
8169 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8170 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8171 
  )
8172 
 
8173 
  def __init__(self, success=None, cex=None,):
8174 
    self.success = success
8175 
    self.cex = cex
8176 
 
8177 
  def read(self, iprot):
8178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8180 
      return
8181 
    iprot.readStructBegin()
8182 
    while True:
8183 
      (fname, ftype, fid) = iprot.readFieldBegin()
8184 
      if ftype == TType.STOP:
8185 
        break
8186 
      if fid == 0:
8187 
        if ftype == TType.LIST:
8188 
          self.success = []
7438 amit.gupta 8189 
          (_etype98, _size95) = iprot.readListBegin()
8190 
          for _i99 in xrange(_size95):
8191 
            _elem100 = iprot.readI64();
8192 
            self.success.append(_elem100)
5944 mandeep.dh 8193 
          iprot.readListEnd()
8194 
        else:
8195 
          iprot.skip(ftype)
8196 
      elif fid == 1:
8197 
        if ftype == TType.STRUCT:
8198 
          self.cex = CatalogServiceException()
8199 
          self.cex.read(iprot)
8200 
        else:
8201 
          iprot.skip(ftype)
8202 
      else:
8203 
        iprot.skip(ftype)
8204 
      iprot.readFieldEnd()
8205 
    iprot.readStructEnd()
8206 
 
8207 
  def write(self, oprot):
8208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8210 
      return
8211 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8212 
    if self.success is not None:
8213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8214 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8215 
      for iter101 in self.success:
8216 
        oprot.writeI64(iter101)
5944 mandeep.dh 8217 
      oprot.writeListEnd()
8218 
      oprot.writeFieldEnd()
8219 
    if self.cex is not None:
8220 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8221 
      self.cex.write(oprot)
8222 
      oprot.writeFieldEnd()
8223 
    oprot.writeFieldStop()
8224 
    oprot.writeStructEnd()
8225 
 
8226 
  def validate(self):
8227 
    return
8228 
 
8229 
 
8230 
  def __repr__(self):
8231 
    L = ['%s=%r' % (key, value)
8232 
      for key, value in self.__dict__.iteritems()]
8233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8234 
 
8235 
  def __eq__(self, other):
8236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8237 
 
8238 
  def __ne__(self, other):
8239 
    return not (self == other)
8240 
 
8241 
class getBestDealsCount_args:
8242 
 
8243 
  thrift_spec = (
8244 
  )
8245 
 
8246 
  def read(self, iprot):
8247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8249 
      return
8250 
    iprot.readStructBegin()
8251 
    while True:
8252 
      (fname, ftype, fid) = iprot.readFieldBegin()
8253 
      if ftype == TType.STOP:
8254 
        break
8255 
      else:
8256 
        iprot.skip(ftype)
8257 
      iprot.readFieldEnd()
8258 
    iprot.readStructEnd()
8259 
 
8260 
  def write(self, oprot):
8261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8263 
      return
8264 
    oprot.writeStructBegin('getBestDealsCount_args')
8265 
    oprot.writeFieldStop()
8266 
    oprot.writeStructEnd()
8267 
 
8268 
  def validate(self):
8269 
    return
8270 
 
8271 
 
8272 
  def __repr__(self):
8273 
    L = ['%s=%r' % (key, value)
8274 
      for key, value in self.__dict__.iteritems()]
8275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8276 
 
8277 
  def __eq__(self, other):
8278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8279 
 
8280 
  def __ne__(self, other):
8281 
    return not (self == other)
8282 
 
8283 
class getBestDealsCount_result:
8284 
  """
8285 
  Attributes:
8286 
   - success
8287 
   - cex
8288 
  """
8289 
 
8290 
  thrift_spec = (
8291 
    (0, TType.I64, 'success', None, None, ), # 0
8292 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8293 
  )
8294 
 
8295 
  def __init__(self, success=None, cex=None,):
8296 
    self.success = success
8297 
    self.cex = cex
8298 
 
8299 
  def read(self, iprot):
8300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8302 
      return
8303 
    iprot.readStructBegin()
8304 
    while True:
8305 
      (fname, ftype, fid) = iprot.readFieldBegin()
8306 
      if ftype == TType.STOP:
8307 
        break
8308 
      if fid == 0:
8309 
        if ftype == TType.I64:
8310 
          self.success = iprot.readI64();
8311 
        else:
8312 
          iprot.skip(ftype)
8313 
      elif fid == 1:
8314 
        if ftype == TType.STRUCT:
8315 
          self.cex = CatalogServiceException()
8316 
          self.cex.read(iprot)
8317 
        else:
8318 
          iprot.skip(ftype)
8319 
      else:
8320 
        iprot.skip(ftype)
8321 
      iprot.readFieldEnd()
8322 
    iprot.readStructEnd()
8323 
 
8324 
  def write(self, oprot):
8325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8327 
      return
8328 
    oprot.writeStructBegin('getBestDealsCount_result')
8329 
    if self.success is not None:
8330 
      oprot.writeFieldBegin('success', TType.I64, 0)
8331 
      oprot.writeI64(self.success)
8332 
      oprot.writeFieldEnd()
8333 
    if self.cex is not None:
8334 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8335 
      self.cex.write(oprot)
8336 
      oprot.writeFieldEnd()
8337 
    oprot.writeFieldStop()
8338 
    oprot.writeStructEnd()
8339 
 
8340 
  def validate(self):
8341 
    return
8342 
 
8343 
 
8344 
  def __repr__(self):
8345 
    L = ['%s=%r' % (key, value)
8346 
      for key, value in self.__dict__.iteritems()]
8347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8348 
 
8349 
  def __eq__(self, other):
8350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8351 
 
8352 
  def __ne__(self, other):
8353 
    return not (self == other)
8354 
 
8355 
class getComingSoon_args:
8356 
 
8357 
  thrift_spec = (
8358 
  )
8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      else:
8370 
        iprot.skip(ftype)
8371 
      iprot.readFieldEnd()
8372 
    iprot.readStructEnd()
8373 
 
8374 
  def write(self, oprot):
8375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8377 
      return
8378 
    oprot.writeStructBegin('getComingSoon_args')
8379 
    oprot.writeFieldStop()
8380 
    oprot.writeStructEnd()
8381 
 
8382 
  def validate(self):
8383 
    return
8384 
 
8385 
 
8386 
  def __repr__(self):
8387 
    L = ['%s=%r' % (key, value)
8388 
      for key, value in self.__dict__.iteritems()]
8389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8390 
 
8391 
  def __eq__(self, other):
8392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8393 
 
8394 
  def __ne__(self, other):
8395 
    return not (self == other)
8396 
 
8397 
class getComingSoon_result:
8398 
  """
8399 
  Attributes:
8400 
   - success
8401 
   - isex
8402 
  """
8403 
 
8404 
  thrift_spec = (
8405 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8406 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8407 
  )
8408 
 
8409 
  def __init__(self, success=None, isex=None,):
8410 
    self.success = success
8411 
    self.isex = isex
8412 
 
8413 
  def read(self, iprot):
8414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8416 
      return
8417 
    iprot.readStructBegin()
8418 
    while True:
8419 
      (fname, ftype, fid) = iprot.readFieldBegin()
8420 
      if ftype == TType.STOP:
8421 
        break
8422 
      if fid == 0:
8423 
        if ftype == TType.LIST:
8424 
          self.success = []
7438 amit.gupta 8425 
          (_etype105, _size102) = iprot.readListBegin()
8426 
          for _i106 in xrange(_size102):
8427 
            _elem107 = Item()
8428 
            _elem107.read(iprot)
8429 
            self.success.append(_elem107)
5944 mandeep.dh 8430 
          iprot.readListEnd()
8431 
        else:
8432 
          iprot.skip(ftype)
8433 
      elif fid == 1:
8434 
        if ftype == TType.STRUCT:
8435 
          self.isex = CatalogServiceException()
8436 
          self.isex.read(iprot)
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      else:
8440 
        iprot.skip(ftype)
8441 
      iprot.readFieldEnd()
8442 
    iprot.readStructEnd()
8443 
 
8444 
  def write(self, oprot):
8445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8447 
      return
8448 
    oprot.writeStructBegin('getComingSoon_result')
8449 
    if self.success is not None:
8450 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8451 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8452 
      for iter108 in self.success:
8453 
        iter108.write(oprot)
5944 mandeep.dh 8454 
      oprot.writeListEnd()
8455 
      oprot.writeFieldEnd()
8456 
    if self.isex is not None:
8457 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8458 
      self.isex.write(oprot)
8459 
      oprot.writeFieldEnd()
8460 
    oprot.writeFieldStop()
8461 
    oprot.writeStructEnd()
8462 
 
8463 
  def validate(self):
8464 
    return
8465 
 
8466 
 
8467 
  def __repr__(self):
8468 
    L = ['%s=%r' % (key, value)
8469 
      for key, value in self.__dict__.iteritems()]
8470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8471 
 
8472 
  def __eq__(self, other):
8473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8474 
 
8475 
  def __ne__(self, other):
8476 
    return not (self == other)
8477 
 
8478 
class getComingSoonCatalogIds_args:
8479 
  """
8480 
  Attributes:
8481 
   - beginIndex
8482 
   - totalItems
8483 
   - brand
8484 
   - category
8485 
  """
8486 
 
8487 
  thrift_spec = (
8488 
    None, # 0
8489 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8490 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8491 
    (3, TType.STRING, 'brand', None, None, ), # 3
8492 
    (4, TType.I64, 'category', None, None, ), # 4
8493 
  )
8494 
 
8495 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8496 
    self.beginIndex = beginIndex
8497 
    self.totalItems = totalItems
8498 
    self.brand = brand
8499 
    self.category = category
8500 
 
8501 
  def read(self, iprot):
8502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8504 
      return
8505 
    iprot.readStructBegin()
8506 
    while True:
8507 
      (fname, ftype, fid) = iprot.readFieldBegin()
8508 
      if ftype == TType.STOP:
8509 
        break
8510 
      if fid == 1:
8511 
        if ftype == TType.I64:
8512 
          self.beginIndex = iprot.readI64();
8513 
        else:
8514 
          iprot.skip(ftype)
8515 
      elif fid == 2:
8516 
        if ftype == TType.I64:
8517 
          self.totalItems = iprot.readI64();
8518 
        else:
8519 
          iprot.skip(ftype)
8520 
      elif fid == 3:
8521 
        if ftype == TType.STRING:
8522 
          self.brand = iprot.readString();
8523 
        else:
8524 
          iprot.skip(ftype)
8525 
      elif fid == 4:
8526 
        if ftype == TType.I64:
8527 
          self.category = iprot.readI64();
8528 
        else:
8529 
          iprot.skip(ftype)
8530 
      else:
8531 
        iprot.skip(ftype)
8532 
      iprot.readFieldEnd()
8533 
    iprot.readStructEnd()
8534 
 
8535 
  def write(self, oprot):
8536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8538 
      return
8539 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8540 
    if self.beginIndex is not None:
8541 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8542 
      oprot.writeI64(self.beginIndex)
8543 
      oprot.writeFieldEnd()
8544 
    if self.totalItems is not None:
8545 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8546 
      oprot.writeI64(self.totalItems)
8547 
      oprot.writeFieldEnd()
8548 
    if self.brand is not None:
8549 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8550 
      oprot.writeString(self.brand)
8551 
      oprot.writeFieldEnd()
8552 
    if self.category is not None:
8553 
      oprot.writeFieldBegin('category', TType.I64, 4)
8554 
      oprot.writeI64(self.category)
8555 
      oprot.writeFieldEnd()
8556 
    oprot.writeFieldStop()
8557 
    oprot.writeStructEnd()
8558 
 
8559 
  def validate(self):
8560 
    return
8561 
 
8562 
 
8563 
  def __repr__(self):
8564 
    L = ['%s=%r' % (key, value)
8565 
      for key, value in self.__dict__.iteritems()]
8566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8567 
 
8568 
  def __eq__(self, other):
8569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8570 
 
8571 
  def __ne__(self, other):
8572 
    return not (self == other)
8573 
 
8574 
class getComingSoonCatalogIds_result:
8575 
  """
8576 
  Attributes:
8577 
   - success
8578 
   - cex
8579 
  """
8580 
 
8581 
  thrift_spec = (
8582 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8583 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8584 
  )
8585 
 
8586 
  def __init__(self, success=None, cex=None,):
8587 
    self.success = success
8588 
    self.cex = cex
8589 
 
8590 
  def read(self, iprot):
8591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8593 
      return
8594 
    iprot.readStructBegin()
8595 
    while True:
8596 
      (fname, ftype, fid) = iprot.readFieldBegin()
8597 
      if ftype == TType.STOP:
8598 
        break
8599 
      if fid == 0:
8600 
        if ftype == TType.LIST:
8601 
          self.success = []
7438 amit.gupta 8602 
          (_etype112, _size109) = iprot.readListBegin()
8603 
          for _i113 in xrange(_size109):
8604 
            _elem114 = iprot.readI64();
8605 
            self.success.append(_elem114)
5944 mandeep.dh 8606 
          iprot.readListEnd()
8607 
        else:
8608 
          iprot.skip(ftype)
8609 
      elif fid == 1:
8610 
        if ftype == TType.STRUCT:
8611 
          self.cex = CatalogServiceException()
8612 
          self.cex.read(iprot)
8613 
        else:
8614 
          iprot.skip(ftype)
8615 
      else:
8616 
        iprot.skip(ftype)
8617 
      iprot.readFieldEnd()
8618 
    iprot.readStructEnd()
8619 
 
8620 
  def write(self, oprot):
8621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8623 
      return
8624 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8625 
    if self.success is not None:
8626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8627 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8628 
      for iter115 in self.success:
8629 
        oprot.writeI64(iter115)
5944 mandeep.dh 8630 
      oprot.writeListEnd()
8631 
      oprot.writeFieldEnd()
8632 
    if self.cex is not None:
8633 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8634 
      self.cex.write(oprot)
8635 
      oprot.writeFieldEnd()
8636 
    oprot.writeFieldStop()
8637 
    oprot.writeStructEnd()
8638 
 
8639 
  def validate(self):
8640 
    return
8641 
 
8642 
 
8643 
  def __repr__(self):
8644 
    L = ['%s=%r' % (key, value)
8645 
      for key, value in self.__dict__.iteritems()]
8646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8647 
 
8648 
  def __eq__(self, other):
8649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8650 
 
8651 
  def __ne__(self, other):
8652 
    return not (self == other)
8653 
 
8654 
class getComingSoonCount_args:
8655 
 
8656 
  thrift_spec = (
8657 
  )
8658 
 
8659 
  def read(self, iprot):
8660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8662 
      return
8663 
    iprot.readStructBegin()
8664 
    while True:
8665 
      (fname, ftype, fid) = iprot.readFieldBegin()
8666 
      if ftype == TType.STOP:
8667 
        break
8668 
      else:
8669 
        iprot.skip(ftype)
8670 
      iprot.readFieldEnd()
8671 
    iprot.readStructEnd()
8672 
 
8673 
  def write(self, oprot):
8674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8676 
      return
8677 
    oprot.writeStructBegin('getComingSoonCount_args')
8678 
    oprot.writeFieldStop()
8679 
    oprot.writeStructEnd()
8680 
 
8681 
  def validate(self):
8682 
    return
8683 
 
8684 
 
8685 
  def __repr__(self):
8686 
    L = ['%s=%r' % (key, value)
8687 
      for key, value in self.__dict__.iteritems()]
8688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8689 
 
8690 
  def __eq__(self, other):
8691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8692 
 
8693 
  def __ne__(self, other):
8694 
    return not (self == other)
8695 
 
8696 
class getComingSoonCount_result:
8697 
  """
8698 
  Attributes:
8699 
   - success
8700 
   - cex
8701 
  """
8702 
 
8703 
  thrift_spec = (
8704 
    (0, TType.I64, 'success', None, None, ), # 0
8705 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8706 
  )
8707 
 
8708 
  def __init__(self, success=None, cex=None,):
8709 
    self.success = success
8710 
    self.cex = cex
8711 
 
8712 
  def read(self, iprot):
8713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8715 
      return
8716 
    iprot.readStructBegin()
8717 
    while True:
8718 
      (fname, ftype, fid) = iprot.readFieldBegin()
8719 
      if ftype == TType.STOP:
8720 
        break
8721 
      if fid == 0:
8722 
        if ftype == TType.I64:
8723 
          self.success = iprot.readI64();
8724 
        else:
8725 
          iprot.skip(ftype)
8726 
      elif fid == 1:
8727 
        if ftype == TType.STRUCT:
8728 
          self.cex = CatalogServiceException()
8729 
          self.cex.read(iprot)
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      else:
8733 
        iprot.skip(ftype)
8734 
      iprot.readFieldEnd()
8735 
    iprot.readStructEnd()
8736 
 
8737 
  def write(self, oprot):
8738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8740 
      return
8741 
    oprot.writeStructBegin('getComingSoonCount_result')
8742 
    if self.success is not None:
8743 
      oprot.writeFieldBegin('success', TType.I64, 0)
8744 
      oprot.writeI64(self.success)
8745 
      oprot.writeFieldEnd()
8746 
    if self.cex is not None:
8747 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8748 
      self.cex.write(oprot)
8749 
      oprot.writeFieldEnd()
8750 
    oprot.writeFieldStop()
8751 
    oprot.writeStructEnd()
8752 
 
8753 
  def validate(self):
8754 
    return
8755 
 
8756 
 
8757 
  def __repr__(self):
8758 
    L = ['%s=%r' % (key, value)
8759 
      for key, value in self.__dict__.iteritems()]
8760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8761 
 
8762 
  def __eq__(self, other):
8763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8764 
 
8765 
  def __ne__(self, other):
8766 
    return not (self == other)
8767 
 
8768 
class getLatestArrivals_args:
8769 
 
8770 
  thrift_spec = (
8771 
  )
8772 
 
8773 
  def read(self, iprot):
8774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8776 
      return
8777 
    iprot.readStructBegin()
8778 
    while True:
8779 
      (fname, ftype, fid) = iprot.readFieldBegin()
8780 
      if ftype == TType.STOP:
8781 
        break
8782 
      else:
8783 
        iprot.skip(ftype)
8784 
      iprot.readFieldEnd()
8785 
    iprot.readStructEnd()
8786 
 
8787 
  def write(self, oprot):
8788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8790 
      return
8791 
    oprot.writeStructBegin('getLatestArrivals_args')
8792 
    oprot.writeFieldStop()
8793 
    oprot.writeStructEnd()
8794 
 
8795 
  def validate(self):
8796 
    return
8797 
 
8798 
 
8799 
  def __repr__(self):
8800 
    L = ['%s=%r' % (key, value)
8801 
      for key, value in self.__dict__.iteritems()]
8802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8803 
 
8804 
  def __eq__(self, other):
8805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8806 
 
8807 
  def __ne__(self, other):
8808 
    return not (self == other)
8809 
 
8810 
class getLatestArrivals_result:
8811 
  """
8812 
  Attributes:
8813 
   - success
8814 
   - isex
8815 
  """
8816 
 
8817 
  thrift_spec = (
8818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8819 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8820 
  )
8821 
 
8822 
  def __init__(self, success=None, isex=None,):
8823 
    self.success = success
8824 
    self.isex = isex
8825 
 
8826 
  def read(self, iprot):
8827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8829 
      return
8830 
    iprot.readStructBegin()
8831 
    while True:
8832 
      (fname, ftype, fid) = iprot.readFieldBegin()
8833 
      if ftype == TType.STOP:
8834 
        break
8835 
      if fid == 0:
8836 
        if ftype == TType.LIST:
8837 
          self.success = []
7438 amit.gupta 8838 
          (_etype119, _size116) = iprot.readListBegin()
8839 
          for _i120 in xrange(_size116):
8840 
            _elem121 = Item()
8841 
            _elem121.read(iprot)
8842 
            self.success.append(_elem121)
5944 mandeep.dh 8843 
          iprot.readListEnd()
8844 
        else:
8845 
          iprot.skip(ftype)
8846 
      elif fid == 1:
8847 
        if ftype == TType.STRUCT:
8848 
          self.isex = CatalogServiceException()
8849 
          self.isex.read(iprot)
8850 
        else:
8851 
          iprot.skip(ftype)
8852 
      else:
8853 
        iprot.skip(ftype)
8854 
      iprot.readFieldEnd()
8855 
    iprot.readStructEnd()
8856 
 
8857 
  def write(self, oprot):
8858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8860 
      return
8861 
    oprot.writeStructBegin('getLatestArrivals_result')
8862 
    if self.success is not None:
8863 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8864 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8865 
      for iter122 in self.success:
8866 
        iter122.write(oprot)
5944 mandeep.dh 8867 
      oprot.writeListEnd()
8868 
      oprot.writeFieldEnd()
8869 
    if self.isex is not None:
8870 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8871 
      self.isex.write(oprot)
8872 
      oprot.writeFieldEnd()
8873 
    oprot.writeFieldStop()
8874 
    oprot.writeStructEnd()
8875 
 
8876 
  def validate(self):
8877 
    return
8878 
 
8879 
 
8880 
  def __repr__(self):
8881 
    L = ['%s=%r' % (key, value)
8882 
      for key, value in self.__dict__.iteritems()]
8883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8884 
 
8885 
  def __eq__(self, other):
8886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8887 
 
8888 
  def __ne__(self, other):
8889 
    return not (self == other)
8890 
 
8891 
class getLatestArrivalsCatalogIds_args:
8892 
  """
8893 
  Attributes:
8894 
   - beginIndex
8895 
   - totalItems
8896 
   - brand
8897 
   - categories
8898 
  """
8899 
 
8900 
  thrift_spec = (
8901 
    None, # 0
8902 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8903 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8904 
    (3, TType.STRING, 'brand', None, None, ), # 3
8905 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8906 
  )
8907 
 
8908 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8909 
    self.beginIndex = beginIndex
8910 
    self.totalItems = totalItems
8911 
    self.brand = brand
8912 
    self.categories = categories
8913 
 
8914 
  def read(self, iprot):
8915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8917 
      return
8918 
    iprot.readStructBegin()
8919 
    while True:
8920 
      (fname, ftype, fid) = iprot.readFieldBegin()
8921 
      if ftype == TType.STOP:
8922 
        break
8923 
      if fid == 1:
8924 
        if ftype == TType.I64:
8925 
          self.beginIndex = iprot.readI64();
8926 
        else:
8927 
          iprot.skip(ftype)
8928 
      elif fid == 2:
8929 
        if ftype == TType.I64:
8930 
          self.totalItems = iprot.readI64();
8931 
        else:
8932 
          iprot.skip(ftype)
8933 
      elif fid == 3:
8934 
        if ftype == TType.STRING:
8935 
          self.brand = iprot.readString();
8936 
        else:
8937 
          iprot.skip(ftype)
8938 
      elif fid == 4:
8939 
        if ftype == TType.LIST:
8940 
          self.categories = []
7438 amit.gupta 8941 
          (_etype126, _size123) = iprot.readListBegin()
8942 
          for _i127 in xrange(_size123):
8943 
            _elem128 = iprot.readI64();
8944 
            self.categories.append(_elem128)
5944 mandeep.dh 8945 
          iprot.readListEnd()
8946 
        else:
8947 
          iprot.skip(ftype)
8948 
      else:
8949 
        iprot.skip(ftype)
8950 
      iprot.readFieldEnd()
8951 
    iprot.readStructEnd()
8952 
 
8953 
  def write(self, oprot):
8954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8956 
      return
8957 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8958 
    if self.beginIndex is not None:
8959 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8960 
      oprot.writeI64(self.beginIndex)
8961 
      oprot.writeFieldEnd()
8962 
    if self.totalItems is not None:
8963 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8964 
      oprot.writeI64(self.totalItems)
8965 
      oprot.writeFieldEnd()
8966 
    if self.brand is not None:
8967 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8968 
      oprot.writeString(self.brand)
8969 
      oprot.writeFieldEnd()
8970 
    if self.categories is not None:
8971 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8972 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 8973 
      for iter129 in self.categories:
8974 
        oprot.writeI64(iter129)
5944 mandeep.dh 8975 
      oprot.writeListEnd()
8976 
      oprot.writeFieldEnd()
8977 
    oprot.writeFieldStop()
8978 
    oprot.writeStructEnd()
8979 
 
8980 
  def validate(self):
8981 
    return
8982 
 
8983 
 
8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getLatestArrivalsCatalogIds_result:
8996 
  """
8997 
  Attributes:
8998 
   - success
8999 
   - cex
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9004 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, success=None, cex=None,):
9008 
    self.success = success
9009 
    self.cex = cex
9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 0:
9021 
        if ftype == TType.LIST:
9022 
          self.success = []
7438 amit.gupta 9023 
          (_etype133, _size130) = iprot.readListBegin()
9024 
          for _i134 in xrange(_size130):
9025 
            _elem135 = iprot.readI64();
9026 
            self.success.append(_elem135)
5944 mandeep.dh 9027 
          iprot.readListEnd()
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      elif fid == 1:
9031 
        if ftype == TType.STRUCT:
9032 
          self.cex = CatalogServiceException()
9033 
          self.cex.read(iprot)
9034 
        else:
9035 
          iprot.skip(ftype)
9036 
      else:
9037 
        iprot.skip(ftype)
9038 
      iprot.readFieldEnd()
9039 
    iprot.readStructEnd()
9040 
 
9041 
  def write(self, oprot):
9042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9044 
      return
9045 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9046 
    if self.success is not None:
9047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9048 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9049 
      for iter136 in self.success:
9050 
        oprot.writeI64(iter136)
5944 mandeep.dh 9051 
      oprot.writeListEnd()
9052 
      oprot.writeFieldEnd()
9053 
    if self.cex is not None:
9054 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9055 
      self.cex.write(oprot)
9056 
      oprot.writeFieldEnd()
9057 
    oprot.writeFieldStop()
9058 
    oprot.writeStructEnd()
9059 
 
9060 
  def validate(self):
9061 
    return
9062 
 
9063 
 
9064 
  def __repr__(self):
9065 
    L = ['%s=%r' % (key, value)
9066 
      for key, value in self.__dict__.iteritems()]
9067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9068 
 
9069 
  def __eq__(self, other):
9070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9071 
 
9072 
  def __ne__(self, other):
9073 
    return not (self == other)
9074 
 
9075 
class getLatestArrivalsCount_args:
9076 
 
9077 
  thrift_spec = (
9078 
  )
9079 
 
9080 
  def read(self, iprot):
9081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9083 
      return
9084 
    iprot.readStructBegin()
9085 
    while True:
9086 
      (fname, ftype, fid) = iprot.readFieldBegin()
9087 
      if ftype == TType.STOP:
9088 
        break
9089 
      else:
9090 
        iprot.skip(ftype)
9091 
      iprot.readFieldEnd()
9092 
    iprot.readStructEnd()
9093 
 
9094 
  def write(self, oprot):
9095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9097 
      return
9098 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9099 
    oprot.writeFieldStop()
9100 
    oprot.writeStructEnd()
9101 
 
9102 
  def validate(self):
9103 
    return
9104 
 
9105 
 
9106 
  def __repr__(self):
9107 
    L = ['%s=%r' % (key, value)
9108 
      for key, value in self.__dict__.iteritems()]
9109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9110 
 
9111 
  def __eq__(self, other):
9112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9113 
 
9114 
  def __ne__(self, other):
9115 
    return not (self == other)
9116 
 
9117 
class getLatestArrivalsCount_result:
9118 
  """
9119 
  Attributes:
9120 
   - success
9121 
   - cex
9122 
  """
9123 
 
9124 
  thrift_spec = (
9125 
    (0, TType.I64, 'success', None, None, ), # 0
9126 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9127 
  )
9128 
 
9129 
  def __init__(self, success=None, cex=None,):
9130 
    self.success = success
9131 
    self.cex = cex
9132 
 
9133 
  def read(self, iprot):
9134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9136 
      return
9137 
    iprot.readStructBegin()
9138 
    while True:
9139 
      (fname, ftype, fid) = iprot.readFieldBegin()
9140 
      if ftype == TType.STOP:
9141 
        break
9142 
      if fid == 0:
9143 
        if ftype == TType.I64:
9144 
          self.success = iprot.readI64();
9145 
        else:
9146 
          iprot.skip(ftype)
9147 
      elif fid == 1:
9148 
        if ftype == TType.STRUCT:
9149 
          self.cex = CatalogServiceException()
9150 
          self.cex.read(iprot)
9151 
        else:
9152 
          iprot.skip(ftype)
9153 
      else:
9154 
        iprot.skip(ftype)
9155 
      iprot.readFieldEnd()
9156 
    iprot.readStructEnd()
9157 
 
9158 
  def write(self, oprot):
9159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9161 
      return
9162 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9163 
    if self.success is not None:
9164 
      oprot.writeFieldBegin('success', TType.I64, 0)
9165 
      oprot.writeI64(self.success)
9166 
      oprot.writeFieldEnd()
9167 
    if self.cex is not None:
9168 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9169 
      self.cex.write(oprot)
9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
9189 
class generateNewEntityID_args:
9190 
 
9191 
  thrift_spec = (
9192 
  )
9193 
 
9194 
  def read(self, iprot):
9195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9197 
      return
9198 
    iprot.readStructBegin()
9199 
    while True:
9200 
      (fname, ftype, fid) = iprot.readFieldBegin()
9201 
      if ftype == TType.STOP:
9202 
        break
9203 
      else:
9204 
        iprot.skip(ftype)
9205 
      iprot.readFieldEnd()
9206 
    iprot.readStructEnd()
9207 
 
9208 
  def write(self, oprot):
9209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9211 
      return
9212 
    oprot.writeStructBegin('generateNewEntityID_args')
9213 
    oprot.writeFieldStop()
9214 
    oprot.writeStructEnd()
9215 
 
9216 
  def validate(self):
9217 
    return
9218 
 
9219 
 
9220 
  def __repr__(self):
9221 
    L = ['%s=%r' % (key, value)
9222 
      for key, value in self.__dict__.iteritems()]
9223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9224 
 
9225 
  def __eq__(self, other):
9226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9227 
 
9228 
  def __ne__(self, other):
9229 
    return not (self == other)
9230 
 
9231 
class generateNewEntityID_result:
9232 
  """
9233 
  Attributes:
9234 
   - success
9235 
  """
9236 
 
9237 
  thrift_spec = (
9238 
    (0, TType.I64, 'success', None, None, ), # 0
9239 
  )
9240 
 
9241 
  def __init__(self, success=None,):
9242 
    self.success = success
9243 
 
9244 
  def read(self, iprot):
9245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9247 
      return
9248 
    iprot.readStructBegin()
9249 
    while True:
9250 
      (fname, ftype, fid) = iprot.readFieldBegin()
9251 
      if ftype == TType.STOP:
9252 
        break
9253 
      if fid == 0:
9254 
        if ftype == TType.I64:
9255 
          self.success = iprot.readI64();
9256 
        else:
9257 
          iprot.skip(ftype)
9258 
      else:
9259 
        iprot.skip(ftype)
9260 
      iprot.readFieldEnd()
9261 
    iprot.readStructEnd()
9262 
 
9263 
  def write(self, oprot):
9264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9266 
      return
9267 
    oprot.writeStructBegin('generateNewEntityID_result')
9268 
    if self.success is not None:
9269 
      oprot.writeFieldBegin('success', TType.I64, 0)
9270 
      oprot.writeI64(self.success)
9271 
      oprot.writeFieldEnd()
9272 
    oprot.writeFieldStop()
9273 
    oprot.writeStructEnd()
9274 
 
9275 
  def validate(self):
9276 
    return
9277 
 
9278 
 
9279 
  def __repr__(self):
9280 
    L = ['%s=%r' % (key, value)
9281 
      for key, value in self.__dict__.iteritems()]
9282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9283 
 
9284 
  def __eq__(self, other):
9285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9286 
 
9287 
  def __ne__(self, other):
9288 
    return not (self == other)
9289 
 
9290 
class addCategory_args:
9291 
  """
9292 
  Attributes:
9293 
   - category
9294 
  """
9295 
 
9296 
  thrift_spec = (
9297 
    None, # 0
9298 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9299 
  )
9300 
 
9301 
  def __init__(self, category=None,):
9302 
    self.category = category
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 
      if fid == 1:
9314 
        if ftype == TType.STRUCT:
9315 
          self.category = Category()
9316 
          self.category.read(iprot)
9317 
        else:
9318 
          iprot.skip(ftype)
9319 
      else:
9320 
        iprot.skip(ftype)
9321 
      iprot.readFieldEnd()
9322 
    iprot.readStructEnd()
9323 
 
9324 
  def write(self, oprot):
9325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9327 
      return
9328 
    oprot.writeStructBegin('addCategory_args')
9329 
    if self.category is not None:
9330 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9331 
      self.category.write(oprot)
9332 
      oprot.writeFieldEnd()
9333 
    oprot.writeFieldStop()
9334 
    oprot.writeStructEnd()
9335 
 
9336 
  def validate(self):
9337 
    return
9338 
 
9339 
 
9340 
  def __repr__(self):
9341 
    L = ['%s=%r' % (key, value)
9342 
      for key, value in self.__dict__.iteritems()]
9343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9344 
 
9345 
  def __eq__(self, other):
9346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9347 
 
9348 
  def __ne__(self, other):
9349 
    return not (self == other)
9350 
 
9351 
class addCategory_result:
9352 
  """
9353 
  Attributes:
9354 
   - success
9355 
  """
9356 
 
9357 
  thrift_spec = (
9358 
    (0, TType.BOOL, 'success', None, None, ), # 0
9359 
  )
9360 
 
9361 
  def __init__(self, success=None,):
9362 
    self.success = success
9363 
 
9364 
  def read(self, iprot):
9365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9367 
      return
9368 
    iprot.readStructBegin()
9369 
    while True:
9370 
      (fname, ftype, fid) = iprot.readFieldBegin()
9371 
      if ftype == TType.STOP:
9372 
        break
9373 
      if fid == 0:
9374 
        if ftype == TType.BOOL:
9375 
          self.success = iprot.readBool();
9376 
        else:
9377 
          iprot.skip(ftype)
9378 
      else:
9379 
        iprot.skip(ftype)
9380 
      iprot.readFieldEnd()
9381 
    iprot.readStructEnd()
9382 
 
9383 
  def write(self, oprot):
9384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9386 
      return
9387 
    oprot.writeStructBegin('addCategory_result')
9388 
    if self.success is not None:
9389 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9390 
      oprot.writeBool(self.success)
9391 
      oprot.writeFieldEnd()
9392 
    oprot.writeFieldStop()
9393 
    oprot.writeStructEnd()
9394 
 
9395 
  def validate(self):
9396 
    return
9397 
 
9398 
 
9399 
  def __repr__(self):
9400 
    L = ['%s=%r' % (key, value)
9401 
      for key, value in self.__dict__.iteritems()]
9402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9403 
 
9404 
  def __eq__(self, other):
9405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9406 
 
9407 
  def __ne__(self, other):
9408 
    return not (self == other)
9409 
 
9410 
class getCategory_args:
9411 
  """
9412 
  Attributes:
9413 
   - id
9414 
  """
9415 
 
9416 
  thrift_spec = (
9417 
    None, # 0
9418 
    (1, TType.I64, 'id', None, None, ), # 1
9419 
  )
9420 
 
9421 
  def __init__(self, id=None,):
9422 
    self.id = id
9423 
 
9424 
  def read(self, iprot):
9425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9427 
      return
9428 
    iprot.readStructBegin()
9429 
    while True:
9430 
      (fname, ftype, fid) = iprot.readFieldBegin()
9431 
      if ftype == TType.STOP:
9432 
        break
9433 
      if fid == 1:
9434 
        if ftype == TType.I64:
9435 
          self.id = iprot.readI64();
9436 
        else:
9437 
          iprot.skip(ftype)
9438 
      else:
9439 
        iprot.skip(ftype)
9440 
      iprot.readFieldEnd()
9441 
    iprot.readStructEnd()
9442 
 
9443 
  def write(self, oprot):
9444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9446 
      return
9447 
    oprot.writeStructBegin('getCategory_args')
9448 
    if self.id is not None:
9449 
      oprot.writeFieldBegin('id', TType.I64, 1)
9450 
      oprot.writeI64(self.id)
9451 
      oprot.writeFieldEnd()
9452 
    oprot.writeFieldStop()
9453 
    oprot.writeStructEnd()
9454 
 
9455 
  def validate(self):
9456 
    return
9457 
 
9458 
 
9459 
  def __repr__(self):
9460 
    L = ['%s=%r' % (key, value)
9461 
      for key, value in self.__dict__.iteritems()]
9462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9463 
 
9464 
  def __eq__(self, other):
9465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9466 
 
9467 
  def __ne__(self, other):
9468 
    return not (self == other)
9469 
 
9470 
class getCategory_result:
9471 
  """
9472 
  Attributes:
9473 
   - success
9474 
  """
9475 
 
9476 
  thrift_spec = (
9477 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9478 
  )
9479 
 
9480 
  def __init__(self, success=None,):
9481 
    self.success = success
9482 
 
9483 
  def read(self, iprot):
9484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9486 
      return
9487 
    iprot.readStructBegin()
9488 
    while True:
9489 
      (fname, ftype, fid) = iprot.readFieldBegin()
9490 
      if ftype == TType.STOP:
9491 
        break
9492 
      if fid == 0:
9493 
        if ftype == TType.STRUCT:
9494 
          self.success = Category()
9495 
          self.success.read(iprot)
9496 
        else:
9497 
          iprot.skip(ftype)
9498 
      else:
9499 
        iprot.skip(ftype)
9500 
      iprot.readFieldEnd()
9501 
    iprot.readStructEnd()
9502 
 
9503 
  def write(self, oprot):
9504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9506 
      return
9507 
    oprot.writeStructBegin('getCategory_result')
9508 
    if self.success is not None:
9509 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9510 
      self.success.write(oprot)
9511 
      oprot.writeFieldEnd()
9512 
    oprot.writeFieldStop()
9513 
    oprot.writeStructEnd()
9514 
 
9515 
  def validate(self):
9516 
    return
9517 
 
9518 
 
9519 
  def __repr__(self):
9520 
    L = ['%s=%r' % (key, value)
9521 
      for key, value in self.__dict__.iteritems()]
9522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9523 
 
9524 
  def __eq__(self, other):
9525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9526 
 
9527 
  def __ne__(self, other):
9528 
    return not (self == other)
9529 
 
9530 
class getAllCategories_args:
9531 
 
9532 
  thrift_spec = (
9533 
  )
9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      else:
9545 
        iprot.skip(ftype)
9546 
      iprot.readFieldEnd()
9547 
    iprot.readStructEnd()
9548 
 
9549 
  def write(self, oprot):
9550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9552 
      return
9553 
    oprot.writeStructBegin('getAllCategories_args')
9554 
    oprot.writeFieldStop()
9555 
    oprot.writeStructEnd()
9556 
 
9557 
  def validate(self):
9558 
    return
9559 
 
9560 
 
9561 
  def __repr__(self):
9562 
    L = ['%s=%r' % (key, value)
9563 
      for key, value in self.__dict__.iteritems()]
9564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9565 
 
9566 
  def __eq__(self, other):
9567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9568 
 
9569 
  def __ne__(self, other):
9570 
    return not (self == other)
9571 
 
9572 
class getAllCategories_result:
9573 
  """
9574 
  Attributes:
9575 
   - success
9576 
  """
9577 
 
9578 
  thrift_spec = (
9579 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9580 
  )
9581 
 
9582 
  def __init__(self, success=None,):
9583 
    self.success = success
9584 
 
9585 
  def read(self, iprot):
9586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9588 
      return
9589 
    iprot.readStructBegin()
9590 
    while True:
9591 
      (fname, ftype, fid) = iprot.readFieldBegin()
9592 
      if ftype == TType.STOP:
9593 
        break
9594 
      if fid == 0:
9595 
        if ftype == TType.LIST:
9596 
          self.success = []
7438 amit.gupta 9597 
          (_etype140, _size137) = iprot.readListBegin()
9598 
          for _i141 in xrange(_size137):
9599 
            _elem142 = Category()
9600 
            _elem142.read(iprot)
9601 
            self.success.append(_elem142)
5944 mandeep.dh 9602 
          iprot.readListEnd()
9603 
        else:
9604 
          iprot.skip(ftype)
9605 
      else:
9606 
        iprot.skip(ftype)
9607 
      iprot.readFieldEnd()
9608 
    iprot.readStructEnd()
9609 
 
9610 
  def write(self, oprot):
9611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9613 
      return
9614 
    oprot.writeStructBegin('getAllCategories_result')
9615 
    if self.success is not None:
9616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9618 
      for iter143 in self.success:
9619 
        iter143.write(oprot)
5944 mandeep.dh 9620 
      oprot.writeListEnd()
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 getAllSimilarItems_args:
9641 
  """
9642 
  Attributes:
9643 
   - itemId
9644 
  """
9645 
 
9646 
  thrift_spec = (
9647 
    None, # 0
9648 
    (1, TType.I64, 'itemId', None, None, ), # 1
9649 
  )
9650 
 
9651 
  def __init__(self, itemId=None,):
9652 
    self.itemId = itemId
9653 
 
9654 
  def read(self, iprot):
9655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9657 
      return
9658 
    iprot.readStructBegin()
9659 
    while True:
9660 
      (fname, ftype, fid) = iprot.readFieldBegin()
9661 
      if ftype == TType.STOP:
9662 
        break
9663 
      if fid == 1:
9664 
        if ftype == TType.I64:
9665 
          self.itemId = iprot.readI64();
9666 
        else:
9667 
          iprot.skip(ftype)
9668 
      else:
9669 
        iprot.skip(ftype)
9670 
      iprot.readFieldEnd()
9671 
    iprot.readStructEnd()
9672 
 
9673 
  def write(self, oprot):
9674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9676 
      return
9677 
    oprot.writeStructBegin('getAllSimilarItems_args')
9678 
    if self.itemId is not None:
9679 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9680 
      oprot.writeI64(self.itemId)
9681 
      oprot.writeFieldEnd()
9682 
    oprot.writeFieldStop()
9683 
    oprot.writeStructEnd()
9684 
 
9685 
  def validate(self):
9686 
    return
9687 
 
9688 
 
9689 
  def __repr__(self):
9690 
    L = ['%s=%r' % (key, value)
9691 
      for key, value in self.__dict__.iteritems()]
9692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9693 
 
9694 
  def __eq__(self, other):
9695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9696 
 
9697 
  def __ne__(self, other):
9698 
    return not (self == other)
9699 
 
9700 
class getAllSimilarItems_result:
9701 
  """
9702 
  Attributes:
9703 
   - success
9704 
  """
9705 
 
9706 
  thrift_spec = (
9707 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9708 
  )
9709 
 
9710 
  def __init__(self, success=None,):
9711 
    self.success = success
9712 
 
9713 
  def read(self, iprot):
9714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9716 
      return
9717 
    iprot.readStructBegin()
9718 
    while True:
9719 
      (fname, ftype, fid) = iprot.readFieldBegin()
9720 
      if ftype == TType.STOP:
9721 
        break
9722 
      if fid == 0:
9723 
        if ftype == TType.LIST:
9724 
          self.success = []
7438 amit.gupta 9725 
          (_etype147, _size144) = iprot.readListBegin()
9726 
          for _i148 in xrange(_size144):
9727 
            _elem149 = Item()
9728 
            _elem149.read(iprot)
9729 
            self.success.append(_elem149)
5944 mandeep.dh 9730 
          iprot.readListEnd()
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      else:
9734 
        iprot.skip(ftype)
9735 
      iprot.readFieldEnd()
9736 
    iprot.readStructEnd()
9737 
 
9738 
  def write(self, oprot):
9739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9741 
      return
9742 
    oprot.writeStructBegin('getAllSimilarItems_result')
9743 
    if self.success is not None:
9744 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9745 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9746 
      for iter150 in self.success:
9747 
        iter150.write(oprot)
5944 mandeep.dh 9748 
      oprot.writeListEnd()
9749 
      oprot.writeFieldEnd()
9750 
    oprot.writeFieldStop()
9751 
    oprot.writeStructEnd()
9752 
 
9753 
  def validate(self):
9754 
    return
9755 
 
9756 
 
9757 
  def __repr__(self):
9758 
    L = ['%s=%r' % (key, value)
9759 
      for key, value in self.__dict__.iteritems()]
9760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9761 
 
9762 
  def __eq__(self, other):
9763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9764 
 
9765 
  def __ne__(self, other):
9766 
    return not (self == other)
9767 
 
9768 
class addSimilarItem_args:
9769 
  """
9770 
  Attributes:
9771 
   - itemId
9772 
   - catalogItemId
9773 
  """
9774 
 
9775 
  thrift_spec = (
9776 
    None, # 0
9777 
    (1, TType.I64, 'itemId', None, None, ), # 1
9778 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9779 
  )
9780 
 
9781 
  def __init__(self, itemId=None, catalogItemId=None,):
9782 
    self.itemId = itemId
9783 
    self.catalogItemId = catalogItemId
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 1:
9795 
        if ftype == TType.I64:
9796 
          self.itemId = iprot.readI64();
9797 
        else:
9798 
          iprot.skip(ftype)
9799 
      elif fid == 2:
9800 
        if ftype == TType.I64:
9801 
          self.catalogItemId = iprot.readI64();
9802 
        else:
9803 
          iprot.skip(ftype)
9804 
      else:
9805 
        iprot.skip(ftype)
9806 
      iprot.readFieldEnd()
9807 
    iprot.readStructEnd()
9808 
 
9809 
  def write(self, oprot):
9810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9812 
      return
9813 
    oprot.writeStructBegin('addSimilarItem_args')
9814 
    if self.itemId is not None:
9815 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9816 
      oprot.writeI64(self.itemId)
9817 
      oprot.writeFieldEnd()
9818 
    if self.catalogItemId is not None:
9819 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9820 
      oprot.writeI64(self.catalogItemId)
9821 
      oprot.writeFieldEnd()
9822 
    oprot.writeFieldStop()
9823 
    oprot.writeStructEnd()
9824 
 
9825 
  def validate(self):
9826 
    return
9827 
 
9828 
 
9829 
  def __repr__(self):
9830 
    L = ['%s=%r' % (key, value)
9831 
      for key, value in self.__dict__.iteritems()]
9832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9833 
 
9834 
  def __eq__(self, other):
9835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9836 
 
9837 
  def __ne__(self, other):
9838 
    return not (self == other)
9839 
 
9840 
class addSimilarItem_result:
9841 
  """
9842 
  Attributes:
9843 
   - success
9844 
   - cex
9845 
  """
9846 
 
9847 
  thrift_spec = (
9848 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9849 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9850 
  )
9851 
 
9852 
  def __init__(self, success=None, cex=None,):
9853 
    self.success = success
9854 
    self.cex = cex
9855 
 
9856 
  def read(self, iprot):
9857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9859 
      return
9860 
    iprot.readStructBegin()
9861 
    while True:
9862 
      (fname, ftype, fid) = iprot.readFieldBegin()
9863 
      if ftype == TType.STOP:
9864 
        break
9865 
      if fid == 0:
9866 
        if ftype == TType.STRUCT:
9867 
          self.success = Item()
9868 
          self.success.read(iprot)
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      elif fid == 1:
9872 
        if ftype == TType.STRUCT:
9873 
          self.cex = CatalogServiceException()
9874 
          self.cex.read(iprot)
9875 
        else:
9876 
          iprot.skip(ftype)
9877 
      else:
9878 
        iprot.skip(ftype)
9879 
      iprot.readFieldEnd()
9880 
    iprot.readStructEnd()
9881 
 
9882 
  def write(self, oprot):
9883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9885 
      return
9886 
    oprot.writeStructBegin('addSimilarItem_result')
9887 
    if self.success is not None:
9888 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9889 
      self.success.write(oprot)
9890 
      oprot.writeFieldEnd()
9891 
    if self.cex is not None:
9892 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9893 
      self.cex.write(oprot)
9894 
      oprot.writeFieldEnd()
9895 
    oprot.writeFieldStop()
9896 
    oprot.writeStructEnd()
9897 
 
9898 
  def validate(self):
9899 
    return
9900 
 
9901 
 
9902 
  def __repr__(self):
9903 
    L = ['%s=%r' % (key, value)
9904 
      for key, value in self.__dict__.iteritems()]
9905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9906 
 
9907 
  def __eq__(self, other):
9908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9909 
 
9910 
  def __ne__(self, other):
9911 
    return not (self == other)
9912 
 
6512 kshitij.so 9913 
class addTag_args:
9914 
  """
9915 
  Attributes:
9916 
   - displayName
9917 
   - itemId
9918 
  """
9919 
 
9920 
  thrift_spec = (
9921 
    None, # 0
9922 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9923 
    (2, TType.I64, 'itemId', None, None, ), # 2
9924 
  )
9925 
 
9926 
  def __init__(self, displayName=None, itemId=None,):
9927 
    self.displayName = displayName
9928 
    self.itemId = itemId
9929 
 
9930 
  def read(self, iprot):
9931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9933 
      return
9934 
    iprot.readStructBegin()
9935 
    while True:
9936 
      (fname, ftype, fid) = iprot.readFieldBegin()
9937 
      if ftype == TType.STOP:
9938 
        break
9939 
      if fid == 1:
9940 
        if ftype == TType.STRING:
9941 
          self.displayName = iprot.readString();
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      elif fid == 2:
9945 
        if ftype == TType.I64:
9946 
          self.itemId = iprot.readI64();
9947 
        else:
9948 
          iprot.skip(ftype)
9949 
      else:
9950 
        iprot.skip(ftype)
9951 
      iprot.readFieldEnd()
9952 
    iprot.readStructEnd()
9953 
 
9954 
  def write(self, oprot):
9955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9957 
      return
9958 
    oprot.writeStructBegin('addTag_args')
9959 
    if self.displayName is not None:
9960 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9961 
      oprot.writeString(self.displayName)
9962 
      oprot.writeFieldEnd()
9963 
    if self.itemId is not None:
9964 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9965 
      oprot.writeI64(self.itemId)
9966 
      oprot.writeFieldEnd()
9967 
    oprot.writeFieldStop()
9968 
    oprot.writeStructEnd()
9969 
 
9970 
  def validate(self):
9971 
    return
9972 
 
9973 
 
9974 
  def __repr__(self):
9975 
    L = ['%s=%r' % (key, value)
9976 
      for key, value in self.__dict__.iteritems()]
9977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9978 
 
9979 
  def __eq__(self, other):
9980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9981 
 
9982 
  def __ne__(self, other):
9983 
    return not (self == other)
9984 
 
9985 
class addTag_result:
9986 
  """
9987 
  Attributes:
9988 
   - success
9989 
  """
9990 
 
9991 
  thrift_spec = (
9992 
    (0, TType.BOOL, 'success', None, None, ), # 0
9993 
  )
9994 
 
9995 
  def __init__(self, success=None,):
9996 
    self.success = success
9997 
 
9998 
  def read(self, iprot):
9999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10001 
      return
10002 
    iprot.readStructBegin()
10003 
    while True:
10004 
      (fname, ftype, fid) = iprot.readFieldBegin()
10005 
      if ftype == TType.STOP:
10006 
        break
10007 
      if fid == 0:
10008 
        if ftype == TType.BOOL:
10009 
          self.success = iprot.readBool();
10010 
        else:
10011 
          iprot.skip(ftype)
10012 
      else:
10013 
        iprot.skip(ftype)
10014 
      iprot.readFieldEnd()
10015 
    iprot.readStructEnd()
10016 
 
10017 
  def write(self, oprot):
10018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10020 
      return
10021 
    oprot.writeStructBegin('addTag_result')
10022 
    if self.success is not None:
10023 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10024 
      oprot.writeBool(self.success)
10025 
      oprot.writeFieldEnd()
10026 
    oprot.writeFieldStop()
10027 
    oprot.writeStructEnd()
10028 
 
10029 
  def validate(self):
10030 
    return
10031 
 
10032 
 
10033 
  def __repr__(self):
10034 
    L = ['%s=%r' % (key, value)
10035 
      for key, value in self.__dict__.iteritems()]
10036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10037 
 
10038 
  def __eq__(self, other):
10039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10040 
 
10041 
  def __ne__(self, other):
10042 
    return not (self == other)
10043 
 
10044 
class deleteEntityTag_args:
10045 
  """
10046 
  Attributes:
10047 
   - displayName
10048 
   - itemId
10049 
  """
10050 
 
10051 
  thrift_spec = (
10052 
    None, # 0
10053 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10054 
    (2, TType.I64, 'itemId', None, None, ), # 2
10055 
  )
10056 
 
10057 
  def __init__(self, displayName=None, itemId=None,):
10058 
    self.displayName = displayName
10059 
    self.itemId = itemId
10060 
 
10061 
  def read(self, iprot):
10062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10064 
      return
10065 
    iprot.readStructBegin()
10066 
    while True:
10067 
      (fname, ftype, fid) = iprot.readFieldBegin()
10068 
      if ftype == TType.STOP:
10069 
        break
10070 
      if fid == 1:
10071 
        if ftype == TType.STRING:
10072 
          self.displayName = iprot.readString();
10073 
        else:
10074 
          iprot.skip(ftype)
10075 
      elif fid == 2:
10076 
        if ftype == TType.I64:
10077 
          self.itemId = iprot.readI64();
10078 
        else:
10079 
          iprot.skip(ftype)
10080 
      else:
10081 
        iprot.skip(ftype)
10082 
      iprot.readFieldEnd()
10083 
    iprot.readStructEnd()
10084 
 
10085 
  def write(self, oprot):
10086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10088 
      return
10089 
    oprot.writeStructBegin('deleteEntityTag_args')
10090 
    if self.displayName is not None:
10091 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10092 
      oprot.writeString(self.displayName)
10093 
      oprot.writeFieldEnd()
10094 
    if self.itemId is not None:
10095 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10096 
      oprot.writeI64(self.itemId)
10097 
      oprot.writeFieldEnd()
10098 
    oprot.writeFieldStop()
10099 
    oprot.writeStructEnd()
10100 
 
10101 
  def validate(self):
10102 
    return
10103 
 
10104 
 
10105 
  def __repr__(self):
10106 
    L = ['%s=%r' % (key, value)
10107 
      for key, value in self.__dict__.iteritems()]
10108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10109 
 
10110 
  def __eq__(self, other):
10111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10112 
 
10113 
  def __ne__(self, other):
10114 
    return not (self == other)
10115 
 
10116 
class deleteEntityTag_result:
10117 
  """
10118 
  Attributes:
10119 
   - success
10120 
  """
10121 
 
10122 
  thrift_spec = (
10123 
    (0, TType.BOOL, 'success', None, None, ), # 0
10124 
  )
10125 
 
10126 
  def __init__(self, success=None,):
10127 
    self.success = success
10128 
 
10129 
  def read(self, iprot):
10130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10132 
      return
10133 
    iprot.readStructBegin()
10134 
    while True:
10135 
      (fname, ftype, fid) = iprot.readFieldBegin()
10136 
      if ftype == TType.STOP:
10137 
        break
10138 
      if fid == 0:
10139 
        if ftype == TType.BOOL:
10140 
          self.success = iprot.readBool();
10141 
        else:
10142 
          iprot.skip(ftype)
10143 
      else:
10144 
        iprot.skip(ftype)
10145 
      iprot.readFieldEnd()
10146 
    iprot.readStructEnd()
10147 
 
10148 
  def write(self, oprot):
10149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10151 
      return
10152 
    oprot.writeStructBegin('deleteEntityTag_result')
10153 
    if self.success is not None:
10154 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10155 
      oprot.writeBool(self.success)
10156 
      oprot.writeFieldEnd()
10157 
    oprot.writeFieldStop()
10158 
    oprot.writeStructEnd()
10159 
 
10160 
  def validate(self):
10161 
    return
10162 
 
10163 
 
10164 
  def __repr__(self):
10165 
    L = ['%s=%r' % (key, value)
10166 
      for key, value in self.__dict__.iteritems()]
10167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10168 
 
10169 
  def __eq__(self, other):
10170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10171 
 
10172 
  def __ne__(self, other):
10173 
    return not (self == other)
10174 
 
10175 
class deleteTag_args:
10176 
  """
10177 
  Attributes:
10178 
   - displayName
10179 
  """
10180 
 
10181 
  thrift_spec = (
10182 
    None, # 0
10183 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10184 
  )
10185 
 
10186 
  def __init__(self, displayName=None,):
10187 
    self.displayName = displayName
10188 
 
10189 
  def read(self, iprot):
10190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10192 
      return
10193 
    iprot.readStructBegin()
10194 
    while True:
10195 
      (fname, ftype, fid) = iprot.readFieldBegin()
10196 
      if ftype == TType.STOP:
10197 
        break
10198 
      if fid == 1:
10199 
        if ftype == TType.STRING:
10200 
          self.displayName = iprot.readString();
10201 
        else:
10202 
          iprot.skip(ftype)
10203 
      else:
10204 
        iprot.skip(ftype)
10205 
      iprot.readFieldEnd()
10206 
    iprot.readStructEnd()
10207 
 
10208 
  def write(self, oprot):
10209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10211 
      return
10212 
    oprot.writeStructBegin('deleteTag_args')
10213 
    if self.displayName is not None:
10214 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10215 
      oprot.writeString(self.displayName)
10216 
      oprot.writeFieldEnd()
10217 
    oprot.writeFieldStop()
10218 
    oprot.writeStructEnd()
10219 
 
10220 
  def validate(self):
10221 
    return
10222 
 
10223 
 
10224 
  def __repr__(self):
10225 
    L = ['%s=%r' % (key, value)
10226 
      for key, value in self.__dict__.iteritems()]
10227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10228 
 
10229 
  def __eq__(self, other):
10230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10231 
 
10232 
  def __ne__(self, other):
10233 
    return not (self == other)
10234 
 
10235 
class deleteTag_result:
10236 
  """
10237 
  Attributes:
10238 
   - success
10239 
  """
10240 
 
10241 
  thrift_spec = (
10242 
    (0, TType.BOOL, 'success', None, None, ), # 0
10243 
  )
10244 
 
10245 
  def __init__(self, success=None,):
10246 
    self.success = success
10247 
 
10248 
  def read(self, iprot):
10249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10251 
      return
10252 
    iprot.readStructBegin()
10253 
    while True:
10254 
      (fname, ftype, fid) = iprot.readFieldBegin()
10255 
      if ftype == TType.STOP:
10256 
        break
10257 
      if fid == 0:
10258 
        if ftype == TType.BOOL:
10259 
          self.success = iprot.readBool();
10260 
        else:
10261 
          iprot.skip(ftype)
10262 
      else:
10263 
        iprot.skip(ftype)
10264 
      iprot.readFieldEnd()
10265 
    iprot.readStructEnd()
10266 
 
10267 
  def write(self, oprot):
10268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10270 
      return
10271 
    oprot.writeStructBegin('deleteTag_result')
10272 
    if self.success is not None:
10273 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10274 
      oprot.writeBool(self.success)
10275 
      oprot.writeFieldEnd()
10276 
    oprot.writeFieldStop()
10277 
    oprot.writeStructEnd()
10278 
 
10279 
  def validate(self):
10280 
    return
10281 
 
10282 
 
10283 
  def __repr__(self):
10284 
    L = ['%s=%r' % (key, value)
10285 
      for key, value in self.__dict__.iteritems()]
10286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10287 
 
10288 
  def __eq__(self, other):
10289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10290 
 
10291 
  def __ne__(self, other):
10292 
    return not (self == other)
10293 
 
10294 
class getAllTags_args:
10295 
 
10296 
  thrift_spec = (
10297 
  )
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 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('getAllTags_args')
10318 
    oprot.writeFieldStop()
10319 
    oprot.writeStructEnd()
10320 
 
10321 
  def validate(self):
10322 
    return
10323 
 
10324 
 
10325 
  def __repr__(self):
10326 
    L = ['%s=%r' % (key, value)
10327 
      for key, value in self.__dict__.iteritems()]
10328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10329 
 
10330 
  def __eq__(self, other):
10331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10332 
 
10333 
  def __ne__(self, other):
10334 
    return not (self == other)
10335 
 
10336 
class getAllTags_result:
10337 
  """
10338 
  Attributes:
10339 
   - success
10340 
  """
10341 
 
10342 
  thrift_spec = (
10343 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10344 
  )
10345 
 
10346 
  def __init__(self, success=None,):
10347 
    self.success = success
10348 
 
10349 
  def read(self, iprot):
10350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10352 
      return
10353 
    iprot.readStructBegin()
10354 
    while True:
10355 
      (fname, ftype, fid) = iprot.readFieldBegin()
10356 
      if ftype == TType.STOP:
10357 
        break
10358 
      if fid == 0:
10359 
        if ftype == TType.LIST:
10360 
          self.success = []
7438 amit.gupta 10361 
          (_etype154, _size151) = iprot.readListBegin()
10362 
          for _i155 in xrange(_size151):
10363 
            _elem156 = iprot.readString();
10364 
            self.success.append(_elem156)
6512 kshitij.so 10365 
          iprot.readListEnd()
10366 
        else:
10367 
          iprot.skip(ftype)
10368 
      else:
10369 
        iprot.skip(ftype)
10370 
      iprot.readFieldEnd()
10371 
    iprot.readStructEnd()
10372 
 
10373 
  def write(self, oprot):
10374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10376 
      return
10377 
    oprot.writeStructBegin('getAllTags_result')
10378 
    if self.success is not None:
10379 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10380 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10381 
      for iter157 in self.success:
10382 
        oprot.writeString(iter157)
6512 kshitij.so 10383 
      oprot.writeListEnd()
10384 
      oprot.writeFieldEnd()
10385 
    oprot.writeFieldStop()
10386 
    oprot.writeStructEnd()
10387 
 
10388 
  def validate(self):
10389 
    return
10390 
 
10391 
 
10392 
  def __repr__(self):
10393 
    L = ['%s=%r' % (key, value)
10394 
      for key, value in self.__dict__.iteritems()]
10395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10396 
 
10397 
  def __eq__(self, other):
10398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10399 
 
10400 
  def __ne__(self, other):
10401 
    return not (self == other)
10402 
 
10403 
class getAllEntitiesByTagName_args:
10404 
  """
10405 
  Attributes:
10406 
   - displayName
10407 
  """
10408 
 
10409 
  thrift_spec = (
10410 
    None, # 0
10411 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10412 
  )
10413 
 
10414 
  def __init__(self, displayName=None,):
10415 
    self.displayName = displayName
10416 
 
10417 
  def read(self, iprot):
10418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10420 
      return
10421 
    iprot.readStructBegin()
10422 
    while True:
10423 
      (fname, ftype, fid) = iprot.readFieldBegin()
10424 
      if ftype == TType.STOP:
10425 
        break
10426 
      if fid == 1:
10427 
        if ftype == TType.STRING:
10428 
          self.displayName = iprot.readString();
10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      else:
10432 
        iprot.skip(ftype)
10433 
      iprot.readFieldEnd()
10434 
    iprot.readStructEnd()
10435 
 
10436 
  def write(self, oprot):
10437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10439 
      return
10440 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10441 
    if self.displayName is not None:
10442 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10443 
      oprot.writeString(self.displayName)
10444 
      oprot.writeFieldEnd()
10445 
    oprot.writeFieldStop()
10446 
    oprot.writeStructEnd()
10447 
 
10448 
  def validate(self):
10449 
    return
10450 
 
10451 
 
10452 
  def __repr__(self):
10453 
    L = ['%s=%r' % (key, value)
10454 
      for key, value in self.__dict__.iteritems()]
10455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10456 
 
10457 
  def __eq__(self, other):
10458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10459 
 
10460 
  def __ne__(self, other):
10461 
    return not (self == other)
10462 
 
10463 
class getAllEntitiesByTagName_result:
10464 
  """
10465 
  Attributes:
10466 
   - success
10467 
  """
10468 
 
10469 
  thrift_spec = (
10470 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10471 
  )
10472 
 
10473 
  def __init__(self, success=None,):
10474 
    self.success = success
10475 
 
10476 
  def read(self, iprot):
10477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10479 
      return
10480 
    iprot.readStructBegin()
10481 
    while True:
10482 
      (fname, ftype, fid) = iprot.readFieldBegin()
10483 
      if ftype == TType.STOP:
10484 
        break
10485 
      if fid == 0:
10486 
        if ftype == TType.LIST:
10487 
          self.success = []
7438 amit.gupta 10488 
          (_etype161, _size158) = iprot.readListBegin()
10489 
          for _i162 in xrange(_size158):
10490 
            _elem163 = iprot.readI64();
10491 
            self.success.append(_elem163)
6512 kshitij.so 10492 
          iprot.readListEnd()
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      else:
10496 
        iprot.skip(ftype)
10497 
      iprot.readFieldEnd()
10498 
    iprot.readStructEnd()
10499 
 
10500 
  def write(self, oprot):
10501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10503 
      return
10504 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10505 
    if self.success is not None:
10506 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10507 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10508 
      for iter164 in self.success:
10509 
        oprot.writeI64(iter164)
6512 kshitij.so 10510 
      oprot.writeListEnd()
10511 
      oprot.writeFieldEnd()
10512 
    oprot.writeFieldStop()
10513 
    oprot.writeStructEnd()
10514 
 
10515 
  def validate(self):
10516 
    return
10517 
 
10518 
 
10519 
  def __repr__(self):
10520 
    L = ['%s=%r' % (key, value)
10521 
      for key, value in self.__dict__.iteritems()]
10522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10523 
 
10524 
  def __eq__(self, other):
10525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10526 
 
10527 
  def __ne__(self, other):
10528 
    return not (self == other)
10529 
 
6845 amit.gupta 10530 
class getAllEntityTags_args:
10531 
 
10532 
  thrift_spec = (
10533 
  )
10534 
 
10535 
  def read(self, iprot):
10536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10538 
      return
10539 
    iprot.readStructBegin()
10540 
    while True:
10541 
      (fname, ftype, fid) = iprot.readFieldBegin()
10542 
      if ftype == TType.STOP:
10543 
        break
10544 
      else:
10545 
        iprot.skip(ftype)
10546 
      iprot.readFieldEnd()
10547 
    iprot.readStructEnd()
10548 
 
10549 
  def write(self, oprot):
10550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10552 
      return
10553 
    oprot.writeStructBegin('getAllEntityTags_args')
10554 
    oprot.writeFieldStop()
10555 
    oprot.writeStructEnd()
10556 
 
10557 
  def validate(self):
10558 
    return
10559 
 
10560 
 
10561 
  def __repr__(self):
10562 
    L = ['%s=%r' % (key, value)
10563 
      for key, value in self.__dict__.iteritems()]
10564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10565 
 
10566 
  def __eq__(self, other):
10567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10568 
 
10569 
  def __ne__(self, other):
10570 
    return not (self == other)
10571 
 
10572 
class getAllEntityTags_result:
10573 
  """
10574 
  Attributes:
10575 
   - success
10576 
  """
10577 
 
10578 
  thrift_spec = (
10579 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10580 
  )
10581 
 
10582 
  def __init__(self, success=None,):
10583 
    self.success = success
10584 
 
10585 
  def read(self, iprot):
10586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10588 
      return
10589 
    iprot.readStructBegin()
10590 
    while True:
10591 
      (fname, ftype, fid) = iprot.readFieldBegin()
10592 
      if ftype == TType.STOP:
10593 
        break
10594 
      if fid == 0:
10595 
        if ftype == TType.MAP:
10596 
          self.success = {}
7438 amit.gupta 10597 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10598 
          for _i169 in xrange(_size165):
10599 
            _key170 = iprot.readI64();
10600 
            _val171 = []
10601 
            (_etype175, _size172) = iprot.readListBegin()
10602 
            for _i176 in xrange(_size172):
10603 
              _elem177 = iprot.readString();
10604 
              _val171.append(_elem177)
6845 amit.gupta 10605 
            iprot.readListEnd()
7438 amit.gupta 10606 
            self.success[_key170] = _val171
6845 amit.gupta 10607 
          iprot.readMapEnd()
10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      else:
10611 
        iprot.skip(ftype)
10612 
      iprot.readFieldEnd()
10613 
    iprot.readStructEnd()
10614 
 
10615 
  def write(self, oprot):
10616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10618 
      return
10619 
    oprot.writeStructBegin('getAllEntityTags_result')
10620 
    if self.success is not None:
10621 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10622 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10623 
      for kiter178,viter179 in self.success.items():
10624 
        oprot.writeI64(kiter178)
10625 
        oprot.writeListBegin(TType.STRING, len(viter179))
10626 
        for iter180 in viter179:
10627 
          oprot.writeString(iter180)
6845 amit.gupta 10628 
        oprot.writeListEnd()
10629 
      oprot.writeMapEnd()
10630 
      oprot.writeFieldEnd()
10631 
    oprot.writeFieldStop()
10632 
    oprot.writeStructEnd()
10633 
 
10634 
  def validate(self):
10635 
    return
10636 
 
10637 
 
10638 
  def __repr__(self):
10639 
    L = ['%s=%r' % (key, value)
10640 
      for key, value in self.__dict__.iteritems()]
10641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10642 
 
10643 
  def __eq__(self, other):
10644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10645 
 
10646 
  def __ne__(self, other):
10647 
    return not (self == other)
10648 
 
6850 kshitij.so 10649 
class addBanner_args:
10650 
  """
10651 
  Attributes:
10652 
   - bannerName
10653 
   - imageName
10654 
   - link
10655 
   - priority
10656 
   - isActive
10657 
   - hasMap
10658 
  """
10659 
 
10660 
  thrift_spec = (
10661 
    None, # 0
10662 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10663 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10664 
    (3, TType.STRING, 'link', None, None, ), # 3
10665 
    (4, TType.I64, 'priority', None, None, ), # 4
10666 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10667 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10668 
  )
10669 
 
10670 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10671 
    self.bannerName = bannerName
10672 
    self.imageName = imageName
10673 
    self.link = link
10674 
    self.priority = priority
10675 
    self.isActive = isActive
10676 
    self.hasMap = hasMap
10677 
 
10678 
  def read(self, iprot):
10679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10681 
      return
10682 
    iprot.readStructBegin()
10683 
    while True:
10684 
      (fname, ftype, fid) = iprot.readFieldBegin()
10685 
      if ftype == TType.STOP:
10686 
        break
10687 
      if fid == 1:
10688 
        if ftype == TType.STRING:
10689 
          self.bannerName = iprot.readString();
10690 
        else:
10691 
          iprot.skip(ftype)
10692 
      elif fid == 2:
10693 
        if ftype == TType.STRING:
10694 
          self.imageName = iprot.readString();
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      elif fid == 3:
10698 
        if ftype == TType.STRING:
10699 
          self.link = iprot.readString();
10700 
        else:
10701 
          iprot.skip(ftype)
10702 
      elif fid == 4:
10703 
        if ftype == TType.I64:
10704 
          self.priority = iprot.readI64();
10705 
        else:
10706 
          iprot.skip(ftype)
10707 
      elif fid == 5:
10708 
        if ftype == TType.BOOL:
10709 
          self.isActive = iprot.readBool();
10710 
        else:
10711 
          iprot.skip(ftype)
10712 
      elif fid == 6:
10713 
        if ftype == TType.BOOL:
10714 
          self.hasMap = iprot.readBool();
10715 
        else:
10716 
          iprot.skip(ftype)
10717 
      else:
10718 
        iprot.skip(ftype)
10719 
      iprot.readFieldEnd()
10720 
    iprot.readStructEnd()
10721 
 
10722 
  def write(self, oprot):
10723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10725 
      return
10726 
    oprot.writeStructBegin('addBanner_args')
10727 
    if self.bannerName is not None:
10728 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10729 
      oprot.writeString(self.bannerName)
10730 
      oprot.writeFieldEnd()
10731 
    if self.imageName is not None:
10732 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10733 
      oprot.writeString(self.imageName)
10734 
      oprot.writeFieldEnd()
10735 
    if self.link is not None:
10736 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10737 
      oprot.writeString(self.link)
10738 
      oprot.writeFieldEnd()
10739 
    if self.priority is not None:
10740 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10741 
      oprot.writeI64(self.priority)
10742 
      oprot.writeFieldEnd()
10743 
    if self.isActive is not None:
10744 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10745 
      oprot.writeBool(self.isActive)
10746 
      oprot.writeFieldEnd()
10747 
    if self.hasMap is not None:
10748 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10749 
      oprot.writeBool(self.hasMap)
10750 
      oprot.writeFieldEnd()
10751 
    oprot.writeFieldStop()
10752 
    oprot.writeStructEnd()
10753 
 
10754 
  def validate(self):
10755 
    return
10756 
 
10757 
 
10758 
  def __repr__(self):
10759 
    L = ['%s=%r' % (key, value)
10760 
      for key, value in self.__dict__.iteritems()]
10761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10762 
 
10763 
  def __eq__(self, other):
10764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10765 
 
10766 
  def __ne__(self, other):
10767 
    return not (self == other)
10768 
 
10769 
class addBanner_result:
10770 
  """
10771 
  Attributes:
10772 
   - success
10773 
  """
10774 
 
10775 
  thrift_spec = (
10776 
    (0, TType.BOOL, 'success', None, None, ), # 0
10777 
  )
10778 
 
10779 
  def __init__(self, success=None,):
10780 
    self.success = success
10781 
 
10782 
  def read(self, iprot):
10783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10785 
      return
10786 
    iprot.readStructBegin()
10787 
    while True:
10788 
      (fname, ftype, fid) = iprot.readFieldBegin()
10789 
      if ftype == TType.STOP:
10790 
        break
10791 
      if fid == 0:
10792 
        if ftype == TType.BOOL:
10793 
          self.success = iprot.readBool();
10794 
        else:
10795 
          iprot.skip(ftype)
10796 
      else:
10797 
        iprot.skip(ftype)
10798 
      iprot.readFieldEnd()
10799 
    iprot.readStructEnd()
10800 
 
10801 
  def write(self, oprot):
10802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10804 
      return
10805 
    oprot.writeStructBegin('addBanner_result')
10806 
    if self.success is not None:
10807 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10808 
      oprot.writeBool(self.success)
10809 
      oprot.writeFieldEnd()
10810 
    oprot.writeFieldStop()
10811 
    oprot.writeStructEnd()
10812 
 
10813 
  def validate(self):
10814 
    return
10815 
 
10816 
 
10817 
  def __repr__(self):
10818 
    L = ['%s=%r' % (key, value)
10819 
      for key, value in self.__dict__.iteritems()]
10820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10821 
 
10822 
  def __eq__(self, other):
10823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10824 
 
10825 
  def __ne__(self, other):
10826 
    return not (self == other)
10827 
 
10828 
class getAllBanners_args:
10829 
 
10830 
  thrift_spec = (
10831 
  )
10832 
 
10833 
  def read(self, iprot):
10834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10836 
      return
10837 
    iprot.readStructBegin()
10838 
    while True:
10839 
      (fname, ftype, fid) = iprot.readFieldBegin()
10840 
      if ftype == TType.STOP:
10841 
        break
10842 
      else:
10843 
        iprot.skip(ftype)
10844 
      iprot.readFieldEnd()
10845 
    iprot.readStructEnd()
10846 
 
10847 
  def write(self, oprot):
10848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10850 
      return
10851 
    oprot.writeStructBegin('getAllBanners_args')
10852 
    oprot.writeFieldStop()
10853 
    oprot.writeStructEnd()
10854 
 
10855 
  def validate(self):
10856 
    return
10857 
 
10858 
 
10859 
  def __repr__(self):
10860 
    L = ['%s=%r' % (key, value)
10861 
      for key, value in self.__dict__.iteritems()]
10862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10863 
 
10864 
  def __eq__(self, other):
10865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10866 
 
10867 
  def __ne__(self, other):
10868 
    return not (self == other)
10869 
 
10870 
class getAllBanners_result:
10871 
  """
10872 
  Attributes:
10873 
   - success
10874 
  """
10875 
 
10876 
  thrift_spec = (
10877 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10878 
  )
10879 
 
10880 
  def __init__(self, success=None,):
10881 
    self.success = success
10882 
 
10883 
  def read(self, iprot):
10884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10886 
      return
10887 
    iprot.readStructBegin()
10888 
    while True:
10889 
      (fname, ftype, fid) = iprot.readFieldBegin()
10890 
      if ftype == TType.STOP:
10891 
        break
10892 
      if fid == 0:
10893 
        if ftype == TType.LIST:
10894 
          self.success = []
7438 amit.gupta 10895 
          (_etype184, _size181) = iprot.readListBegin()
10896 
          for _i185 in xrange(_size181):
10897 
            _elem186 = iprot.readString();
10898 
            self.success.append(_elem186)
6850 kshitij.so 10899 
          iprot.readListEnd()
10900 
        else:
10901 
          iprot.skip(ftype)
10902 
      else:
10903 
        iprot.skip(ftype)
10904 
      iprot.readFieldEnd()
10905 
    iprot.readStructEnd()
10906 
 
10907 
  def write(self, oprot):
10908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10910 
      return
10911 
    oprot.writeStructBegin('getAllBanners_result')
10912 
    if self.success is not None:
10913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10914 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10915 
      for iter187 in self.success:
10916 
        oprot.writeString(iter187)
6850 kshitij.so 10917 
      oprot.writeListEnd()
10918 
      oprot.writeFieldEnd()
10919 
    oprot.writeFieldStop()
10920 
    oprot.writeStructEnd()
10921 
 
10922 
  def validate(self):
10923 
    return
10924 
 
10925 
 
10926 
  def __repr__(self):
10927 
    L = ['%s=%r' % (key, value)
10928 
      for key, value in self.__dict__.iteritems()]
10929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10930 
 
10931 
  def __eq__(self, other):
10932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10933 
 
10934 
  def __ne__(self, other):
10935 
    return not (self == other)
10936 
 
10937 
class deleteBanner_args:
10938 
  """
10939 
  Attributes:
10940 
   - bannerName
10941 
  """
10942 
 
10943 
  thrift_spec = (
10944 
    None, # 0
10945 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10946 
  )
10947 
 
10948 
  def __init__(self, bannerName=None,):
10949 
    self.bannerName = bannerName
10950 
 
10951 
  def read(self, iprot):
10952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10954 
      return
10955 
    iprot.readStructBegin()
10956 
    while True:
10957 
      (fname, ftype, fid) = iprot.readFieldBegin()
10958 
      if ftype == TType.STOP:
10959 
        break
10960 
      if fid == 1:
10961 
        if ftype == TType.STRING:
10962 
          self.bannerName = iprot.readString();
10963 
        else:
10964 
          iprot.skip(ftype)
10965 
      else:
10966 
        iprot.skip(ftype)
10967 
      iprot.readFieldEnd()
10968 
    iprot.readStructEnd()
10969 
 
10970 
  def write(self, oprot):
10971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10973 
      return
10974 
    oprot.writeStructBegin('deleteBanner_args')
10975 
    if self.bannerName is not None:
10976 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10977 
      oprot.writeString(self.bannerName)
10978 
      oprot.writeFieldEnd()
10979 
    oprot.writeFieldStop()
10980 
    oprot.writeStructEnd()
10981 
 
10982 
  def validate(self):
10983 
    return
10984 
 
10985 
 
10986 
  def __repr__(self):
10987 
    L = ['%s=%r' % (key, value)
10988 
      for key, value in self.__dict__.iteritems()]
10989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10990 
 
10991 
  def __eq__(self, other):
10992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10993 
 
10994 
  def __ne__(self, other):
10995 
    return not (self == other)
10996 
 
10997 
class deleteBanner_result:
10998 
  """
10999 
  Attributes:
11000 
   - success
11001 
  """
11002 
 
11003 
  thrift_spec = (
11004 
    (0, TType.BOOL, 'success', None, None, ), # 0
11005 
  )
11006 
 
11007 
  def __init__(self, success=None,):
11008 
    self.success = success
11009 
 
11010 
  def read(self, iprot):
11011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11013 
      return
11014 
    iprot.readStructBegin()
11015 
    while True:
11016 
      (fname, ftype, fid) = iprot.readFieldBegin()
11017 
      if ftype == TType.STOP:
11018 
        break
11019 
      if fid == 0:
11020 
        if ftype == TType.BOOL:
11021 
          self.success = iprot.readBool();
11022 
        else:
11023 
          iprot.skip(ftype)
11024 
      else:
11025 
        iprot.skip(ftype)
11026 
      iprot.readFieldEnd()
11027 
    iprot.readStructEnd()
11028 
 
11029 
  def write(self, oprot):
11030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11032 
      return
11033 
    oprot.writeStructBegin('deleteBanner_result')
11034 
    if self.success is not None:
11035 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11036 
      oprot.writeBool(self.success)
11037 
      oprot.writeFieldEnd()
11038 
    oprot.writeFieldStop()
11039 
    oprot.writeStructEnd()
11040 
 
11041 
  def validate(self):
11042 
    return
11043 
 
11044 
 
11045 
  def __repr__(self):
11046 
    L = ['%s=%r' % (key, value)
11047 
      for key, value in self.__dict__.iteritems()]
11048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11049 
 
11050 
  def __eq__(self, other):
11051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11052 
 
11053 
  def __ne__(self, other):
11054 
    return not (self == other)
11055 
 
11056 
class getBannerDetails_args:
11057 
  """
11058 
  Attributes:
11059 
   - bannerName
11060 
  """
11061 
 
11062 
  thrift_spec = (
11063 
    None, # 0
11064 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11065 
  )
11066 
 
11067 
  def __init__(self, bannerName=None,):
11068 
    self.bannerName = bannerName
11069 
 
11070 
  def read(self, iprot):
11071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11073 
      return
11074 
    iprot.readStructBegin()
11075 
    while True:
11076 
      (fname, ftype, fid) = iprot.readFieldBegin()
11077 
      if ftype == TType.STOP:
11078 
        break
11079 
      if fid == 1:
11080 
        if ftype == TType.STRING:
11081 
          self.bannerName = iprot.readString();
11082 
        else:
11083 
          iprot.skip(ftype)
11084 
      else:
11085 
        iprot.skip(ftype)
11086 
      iprot.readFieldEnd()
11087 
    iprot.readStructEnd()
11088 
 
11089 
  def write(self, oprot):
11090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11092 
      return
11093 
    oprot.writeStructBegin('getBannerDetails_args')
11094 
    if self.bannerName is not None:
11095 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11096 
      oprot.writeString(self.bannerName)
11097 
      oprot.writeFieldEnd()
11098 
    oprot.writeFieldStop()
11099 
    oprot.writeStructEnd()
11100 
 
11101 
  def validate(self):
11102 
    return
11103 
 
11104 
 
11105 
  def __repr__(self):
11106 
    L = ['%s=%r' % (key, value)
11107 
      for key, value in self.__dict__.iteritems()]
11108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11109 
 
11110 
  def __eq__(self, other):
11111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11112 
 
11113 
  def __ne__(self, other):
11114 
    return not (self == other)
11115 
 
11116 
class getBannerDetails_result:
11117 
  """
11118 
  Attributes:
11119 
   - success
11120 
  """
11121 
 
11122 
  thrift_spec = (
11123 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11124 
  )
11125 
 
11126 
  def __init__(self, success=None,):
11127 
    self.success = success
11128 
 
11129 
  def read(self, iprot):
11130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11132 
      return
11133 
    iprot.readStructBegin()
11134 
    while True:
11135 
      (fname, ftype, fid) = iprot.readFieldBegin()
11136 
      if ftype == TType.STOP:
11137 
        break
11138 
      if fid == 0:
11139 
        if ftype == TType.STRUCT:
11140 
          self.success = Banner()
11141 
          self.success.read(iprot)
11142 
        else:
11143 
          iprot.skip(ftype)
11144 
      else:
11145 
        iprot.skip(ftype)
11146 
      iprot.readFieldEnd()
11147 
    iprot.readStructEnd()
11148 
 
11149 
  def write(self, oprot):
11150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11152 
      return
11153 
    oprot.writeStructBegin('getBannerDetails_result')
11154 
    if self.success is not None:
11155 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11156 
      self.success.write(oprot)
11157 
      oprot.writeFieldEnd()
11158 
    oprot.writeFieldStop()
11159 
    oprot.writeStructEnd()
11160 
 
11161 
  def validate(self):
11162 
    return
11163 
 
11164 
 
11165 
  def __repr__(self):
11166 
    L = ['%s=%r' % (key, value)
11167 
      for key, value in self.__dict__.iteritems()]
11168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11169 
 
11170 
  def __eq__(self, other):
11171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11172 
 
11173 
  def __ne__(self, other):
11174 
    return not (self == other)
11175 
 
11176 
class getActiveBanners_args:
11177 
 
11178 
  thrift_spec = (
11179 
  )
11180 
 
11181 
  def read(self, iprot):
11182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11184 
      return
11185 
    iprot.readStructBegin()
11186 
    while True:
11187 
      (fname, ftype, fid) = iprot.readFieldBegin()
11188 
      if ftype == TType.STOP:
11189 
        break
11190 
      else:
11191 
        iprot.skip(ftype)
11192 
      iprot.readFieldEnd()
11193 
    iprot.readStructEnd()
11194 
 
11195 
  def write(self, oprot):
11196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11198 
      return
11199 
    oprot.writeStructBegin('getActiveBanners_args')
11200 
    oprot.writeFieldStop()
11201 
    oprot.writeStructEnd()
11202 
 
11203 
  def validate(self):
11204 
    return
11205 
 
11206 
 
11207 
  def __repr__(self):
11208 
    L = ['%s=%r' % (key, value)
11209 
      for key, value in self.__dict__.iteritems()]
11210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11211 
 
11212 
  def __eq__(self, other):
11213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11214 
 
11215 
  def __ne__(self, other):
11216 
    return not (self == other)
11217 
 
11218 
class getActiveBanners_result:
11219 
  """
11220 
  Attributes:
11221 
   - success
11222 
  """
11223 
 
11224 
  thrift_spec = (
11225 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11226 
  )
11227 
 
11228 
  def __init__(self, success=None,):
11229 
    self.success = success
11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 0:
11241 
        if ftype == TType.LIST:
11242 
          self.success = []
7438 amit.gupta 11243 
          (_etype191, _size188) = iprot.readListBegin()
11244 
          for _i192 in xrange(_size188):
11245 
            _elem193 = Banner()
11246 
            _elem193.read(iprot)
11247 
            self.success.append(_elem193)
6850 kshitij.so 11248 
          iprot.readListEnd()
11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      else:
11252 
        iprot.skip(ftype)
11253 
      iprot.readFieldEnd()
11254 
    iprot.readStructEnd()
11255 
 
11256 
  def write(self, oprot):
11257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11259 
      return
11260 
    oprot.writeStructBegin('getActiveBanners_result')
11261 
    if self.success is not None:
11262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11264 
      for iter194 in self.success:
11265 
        iter194.write(oprot)
6850 kshitij.so 11266 
      oprot.writeListEnd()
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 
 
6849 kshitij.so 11286 
class addBannerMap_args:
11287 
  """
11288 
  Attributes:
11289 
   - bannerName
11290 
   - mapLink
11291 
   - coordinates
11292 
  """
11293 
 
11294 
  thrift_spec = (
11295 
    None, # 0
11296 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11297 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11298 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11299 
  )
11300 
 
11301 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11302 
    self.bannerName = bannerName
11303 
    self.mapLink = mapLink
11304 
    self.coordinates = coordinates
11305 
 
11306 
  def read(self, iprot):
11307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11309 
      return
11310 
    iprot.readStructBegin()
11311 
    while True:
11312 
      (fname, ftype, fid) = iprot.readFieldBegin()
11313 
      if ftype == TType.STOP:
11314 
        break
11315 
      if fid == 1:
11316 
        if ftype == TType.STRING:
11317 
          self.bannerName = iprot.readString();
11318 
        else:
11319 
          iprot.skip(ftype)
11320 
      elif fid == 2:
11321 
        if ftype == TType.STRING:
11322 
          self.mapLink = iprot.readString();
11323 
        else:
11324 
          iprot.skip(ftype)
11325 
      elif fid == 3:
11326 
        if ftype == TType.STRING:
11327 
          self.coordinates = iprot.readString();
11328 
        else:
11329 
          iprot.skip(ftype)
11330 
      else:
11331 
        iprot.skip(ftype)
11332 
      iprot.readFieldEnd()
11333 
    iprot.readStructEnd()
11334 
 
11335 
  def write(self, oprot):
11336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11338 
      return
11339 
    oprot.writeStructBegin('addBannerMap_args')
11340 
    if self.bannerName is not None:
11341 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11342 
      oprot.writeString(self.bannerName)
11343 
      oprot.writeFieldEnd()
11344 
    if self.mapLink is not None:
11345 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11346 
      oprot.writeString(self.mapLink)
11347 
      oprot.writeFieldEnd()
11348 
    if self.coordinates is not None:
11349 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11350 
      oprot.writeString(self.coordinates)
11351 
      oprot.writeFieldEnd()
11352 
    oprot.writeFieldStop()
11353 
    oprot.writeStructEnd()
11354 
 
11355 
  def validate(self):
11356 
    return
11357 
 
11358 
 
11359 
  def __repr__(self):
11360 
    L = ['%s=%r' % (key, value)
11361 
      for key, value in self.__dict__.iteritems()]
11362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11363 
 
11364 
  def __eq__(self, other):
11365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11366 
 
11367 
  def __ne__(self, other):
11368 
    return not (self == other)
11369 
 
11370 
class addBannerMap_result:
11371 
  """
11372 
  Attributes:
11373 
   - success
11374 
  """
11375 
 
11376 
  thrift_spec = (
11377 
    (0, TType.BOOL, 'success', None, None, ), # 0
11378 
  )
11379 
 
11380 
  def __init__(self, success=None,):
11381 
    self.success = success
11382 
 
11383 
  def read(self, iprot):
11384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11386 
      return
11387 
    iprot.readStructBegin()
11388 
    while True:
11389 
      (fname, ftype, fid) = iprot.readFieldBegin()
11390 
      if ftype == TType.STOP:
11391 
        break
11392 
      if fid == 0:
11393 
        if ftype == TType.BOOL:
11394 
          self.success = iprot.readBool();
11395 
        else:
11396 
          iprot.skip(ftype)
11397 
      else:
11398 
        iprot.skip(ftype)
11399 
      iprot.readFieldEnd()
11400 
    iprot.readStructEnd()
11401 
 
11402 
  def write(self, oprot):
11403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11405 
      return
11406 
    oprot.writeStructBegin('addBannerMap_result')
11407 
    if self.success is not None:
11408 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11409 
      oprot.writeBool(self.success)
11410 
      oprot.writeFieldEnd()
11411 
    oprot.writeFieldStop()
11412 
    oprot.writeStructEnd()
11413 
 
11414 
  def validate(self):
11415 
    return
11416 
 
11417 
 
11418 
  def __repr__(self):
11419 
    L = ['%s=%r' % (key, value)
11420 
      for key, value in self.__dict__.iteritems()]
11421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11422 
 
11423 
  def __eq__(self, other):
11424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11425 
 
11426 
  def __ne__(self, other):
11427 
    return not (self == other)
11428 
 
11429 
class deleteBannerMap_args:
11430 
  """
11431 
  Attributes:
11432 
   - bannerName
11433 
  """
11434 
 
11435 
  thrift_spec = (
11436 
    None, # 0
11437 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11438 
  )
11439 
 
11440 
  def __init__(self, bannerName=None,):
11441 
    self.bannerName = bannerName
11442 
 
11443 
  def read(self, iprot):
11444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11446 
      return
11447 
    iprot.readStructBegin()
11448 
    while True:
11449 
      (fname, ftype, fid) = iprot.readFieldBegin()
11450 
      if ftype == TType.STOP:
11451 
        break
11452 
      if fid == 1:
11453 
        if ftype == TType.STRING:
11454 
          self.bannerName = iprot.readString();
11455 
        else:
11456 
          iprot.skip(ftype)
11457 
      else:
11458 
        iprot.skip(ftype)
11459 
      iprot.readFieldEnd()
11460 
    iprot.readStructEnd()
11461 
 
11462 
  def write(self, oprot):
11463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11465 
      return
11466 
    oprot.writeStructBegin('deleteBannerMap_args')
11467 
    if self.bannerName is not None:
11468 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11469 
      oprot.writeString(self.bannerName)
11470 
      oprot.writeFieldEnd()
11471 
    oprot.writeFieldStop()
11472 
    oprot.writeStructEnd()
11473 
 
11474 
  def validate(self):
11475 
    return
11476 
 
11477 
 
11478 
  def __repr__(self):
11479 
    L = ['%s=%r' % (key, value)
11480 
      for key, value in self.__dict__.iteritems()]
11481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11482 
 
11483 
  def __eq__(self, other):
11484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11485 
 
11486 
  def __ne__(self, other):
11487 
    return not (self == other)
11488 
 
11489 
class deleteBannerMap_result:
11490 
  """
11491 
  Attributes:
11492 
   - success
11493 
  """
11494 
 
11495 
  thrift_spec = (
11496 
    (0, TType.BOOL, 'success', None, None, ), # 0
11497 
  )
11498 
 
11499 
  def __init__(self, success=None,):
11500 
    self.success = success
11501 
 
11502 
  def read(self, iprot):
11503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11505 
      return
11506 
    iprot.readStructBegin()
11507 
    while True:
11508 
      (fname, ftype, fid) = iprot.readFieldBegin()
11509 
      if ftype == TType.STOP:
11510 
        break
11511 
      if fid == 0:
11512 
        if ftype == TType.BOOL:
11513 
          self.success = iprot.readBool();
11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      else:
11517 
        iprot.skip(ftype)
11518 
      iprot.readFieldEnd()
11519 
    iprot.readStructEnd()
11520 
 
11521 
  def write(self, oprot):
11522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11524 
      return
11525 
    oprot.writeStructBegin('deleteBannerMap_result')
11526 
    if self.success is not None:
11527 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11528 
      oprot.writeBool(self.success)
11529 
      oprot.writeFieldEnd()
11530 
    oprot.writeFieldStop()
11531 
    oprot.writeStructEnd()
11532 
 
11533 
  def validate(self):
11534 
    return
11535 
 
11536 
 
11537 
  def __repr__(self):
11538 
    L = ['%s=%r' % (key, value)
11539 
      for key, value in self.__dict__.iteritems()]
11540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11541 
 
11542 
  def __eq__(self, other):
11543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11544 
 
11545 
  def __ne__(self, other):
11546 
    return not (self == other)
11547 
 
11548 
class getBannerMapDetails_args:
11549 
  """
11550 
  Attributes:
11551 
   - bannerName
11552 
  """
11553 
 
11554 
  thrift_spec = (
11555 
    None, # 0
11556 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11557 
  )
11558 
 
11559 
  def __init__(self, bannerName=None,):
11560 
    self.bannerName = bannerName
11561 
 
11562 
  def read(self, iprot):
11563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11565 
      return
11566 
    iprot.readStructBegin()
11567 
    while True:
11568 
      (fname, ftype, fid) = iprot.readFieldBegin()
11569 
      if ftype == TType.STOP:
11570 
        break
11571 
      if fid == 1:
11572 
        if ftype == TType.STRING:
11573 
          self.bannerName = iprot.readString();
11574 
        else:
11575 
          iprot.skip(ftype)
11576 
      else:
11577 
        iprot.skip(ftype)
11578 
      iprot.readFieldEnd()
11579 
    iprot.readStructEnd()
11580 
 
11581 
  def write(self, oprot):
11582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11584 
      return
11585 
    oprot.writeStructBegin('getBannerMapDetails_args')
11586 
    if self.bannerName is not None:
11587 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11588 
      oprot.writeString(self.bannerName)
11589 
      oprot.writeFieldEnd()
11590 
    oprot.writeFieldStop()
11591 
    oprot.writeStructEnd()
11592 
 
11593 
  def validate(self):
11594 
    return
11595 
 
11596 
 
11597 
  def __repr__(self):
11598 
    L = ['%s=%r' % (key, value)
11599 
      for key, value in self.__dict__.iteritems()]
11600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11601 
 
11602 
  def __eq__(self, other):
11603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11604 
 
11605 
  def __ne__(self, other):
11606 
    return not (self == other)
11607 
 
11608 
class getBannerMapDetails_result:
11609 
  """
11610 
  Attributes:
11611 
   - success
11612 
  """
11613 
 
11614 
  thrift_spec = (
11615 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11616 
  )
11617 
 
11618 
  def __init__(self, success=None,):
11619 
    self.success = success
11620 
 
11621 
  def read(self, iprot):
11622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11624 
      return
11625 
    iprot.readStructBegin()
11626 
    while True:
11627 
      (fname, ftype, fid) = iprot.readFieldBegin()
11628 
      if ftype == TType.STOP:
11629 
        break
11630 
      if fid == 0:
11631 
        if ftype == TType.LIST:
11632 
          self.success = []
7438 amit.gupta 11633 
          (_etype198, _size195) = iprot.readListBegin()
11634 
          for _i199 in xrange(_size195):
11635 
            _elem200 = BannerMap()
11636 
            _elem200.read(iprot)
11637 
            self.success.append(_elem200)
6849 kshitij.so 11638 
          iprot.readListEnd()
11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
11650 
    oprot.writeStructBegin('getBannerMapDetails_result')
11651 
    if self.success is not None:
11652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11653 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11654 
      for iter201 in self.success:
11655 
        iter201.write(oprot)
6849 kshitij.so 11656 
      oprot.writeListEnd()
11657 
      oprot.writeFieldEnd()
11658 
    oprot.writeFieldStop()
11659 
    oprot.writeStructEnd()
11660 
 
11661 
  def validate(self):
11662 
    return
11663 
 
11664 
 
11665 
  def __repr__(self):
11666 
    L = ['%s=%r' % (key, value)
11667 
      for key, value in self.__dict__.iteritems()]
11668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11669 
 
11670 
  def __eq__(self, other):
11671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11672 
 
11673 
  def __ne__(self, other):
11674 
    return not (self == other)
11675 
 
5944 mandeep.dh 11676 
class deleteSimilarItem_args:
11677 
  """
11678 
  Attributes:
11679 
   - itemId
11680 
   - catalogItemId
11681 
  """
11682 
 
11683 
  thrift_spec = (
11684 
    None, # 0
11685 
    (1, TType.I64, 'itemId', None, None, ), # 1
11686 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11687 
  )
11688 
 
11689 
  def __init__(self, itemId=None, catalogItemId=None,):
11690 
    self.itemId = itemId
11691 
    self.catalogItemId = catalogItemId
11692 
 
11693 
  def read(self, iprot):
11694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11696 
      return
11697 
    iprot.readStructBegin()
11698 
    while True:
11699 
      (fname, ftype, fid) = iprot.readFieldBegin()
11700 
      if ftype == TType.STOP:
11701 
        break
11702 
      if fid == 1:
11703 
        if ftype == TType.I64:
11704 
          self.itemId = iprot.readI64();
11705 
        else:
11706 
          iprot.skip(ftype)
11707 
      elif fid == 2:
11708 
        if ftype == TType.I64:
11709 
          self.catalogItemId = iprot.readI64();
11710 
        else:
11711 
          iprot.skip(ftype)
11712 
      else:
11713 
        iprot.skip(ftype)
11714 
      iprot.readFieldEnd()
11715 
    iprot.readStructEnd()
11716 
 
11717 
  def write(self, oprot):
11718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11720 
      return
11721 
    oprot.writeStructBegin('deleteSimilarItem_args')
11722 
    if self.itemId is not None:
11723 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11724 
      oprot.writeI64(self.itemId)
11725 
      oprot.writeFieldEnd()
11726 
    if self.catalogItemId is not None:
11727 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11728 
      oprot.writeI64(self.catalogItemId)
11729 
      oprot.writeFieldEnd()
11730 
    oprot.writeFieldStop()
11731 
    oprot.writeStructEnd()
11732 
 
11733 
  def validate(self):
11734 
    return
11735 
 
11736 
 
11737 
  def __repr__(self):
11738 
    L = ['%s=%r' % (key, value)
11739 
      for key, value in self.__dict__.iteritems()]
11740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11741 
 
11742 
  def __eq__(self, other):
11743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11744 
 
11745 
  def __ne__(self, other):
11746 
    return not (self == other)
11747 
 
11748 
class deleteSimilarItem_result:
11749 
  """
11750 
  Attributes:
11751 
   - success
11752 
   - cex
11753 
  """
11754 
 
11755 
  thrift_spec = (
11756 
    (0, TType.BOOL, 'success', None, None, ), # 0
11757 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11758 
  )
11759 
 
11760 
  def __init__(self, success=None, cex=None,):
11761 
    self.success = success
11762 
    self.cex = cex
11763 
 
11764 
  def read(self, iprot):
11765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11767 
      return
11768 
    iprot.readStructBegin()
11769 
    while True:
11770 
      (fname, ftype, fid) = iprot.readFieldBegin()
11771 
      if ftype == TType.STOP:
11772 
        break
11773 
      if fid == 0:
11774 
        if ftype == TType.BOOL:
11775 
          self.success = iprot.readBool();
11776 
        else:
11777 
          iprot.skip(ftype)
11778 
      elif fid == 1:
11779 
        if ftype == TType.STRUCT:
11780 
          self.cex = CatalogServiceException()
11781 
          self.cex.read(iprot)
11782 
        else:
11783 
          iprot.skip(ftype)
11784 
      else:
11785 
        iprot.skip(ftype)
11786 
      iprot.readFieldEnd()
11787 
    iprot.readStructEnd()
11788 
 
11789 
  def write(self, oprot):
11790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11792 
      return
11793 
    oprot.writeStructBegin('deleteSimilarItem_result')
11794 
    if self.success is not None:
11795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11796 
      oprot.writeBool(self.success)
11797 
      oprot.writeFieldEnd()
11798 
    if self.cex is not None:
11799 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11800 
      self.cex.write(oprot)
11801 
      oprot.writeFieldEnd()
11802 
    oprot.writeFieldStop()
11803 
    oprot.writeStructEnd()
11804 
 
11805 
  def validate(self):
11806 
    return
11807 
 
11808 
 
11809 
  def __repr__(self):
11810 
    L = ['%s=%r' % (key, value)
11811 
      for key, value in self.__dict__.iteritems()]
11812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11813 
 
11814 
  def __eq__(self, other):
11815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11816 
 
11817 
  def __ne__(self, other):
11818 
    return not (self == other)
11819 
 
11820 
class checkSimilarItem_args:
11821 
  """
11822 
  Attributes:
11823 
   - brand
11824 
   - modelNumber
11825 
   - modelName
11826 
   - color
11827 
  """
11828 
 
11829 
  thrift_spec = (
11830 
    None, # 0
11831 
    (1, TType.STRING, 'brand', None, None, ), # 1
11832 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11833 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11834 
    (4, TType.STRING, 'color', None, None, ), # 4
11835 
  )
11836 
 
11837 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11838 
    self.brand = brand
11839 
    self.modelNumber = modelNumber
11840 
    self.modelName = modelName
11841 
    self.color = color
11842 
 
11843 
  def read(self, iprot):
11844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11846 
      return
11847 
    iprot.readStructBegin()
11848 
    while True:
11849 
      (fname, ftype, fid) = iprot.readFieldBegin()
11850 
      if ftype == TType.STOP:
11851 
        break
11852 
      if fid == 1:
11853 
        if ftype == TType.STRING:
11854 
          self.brand = iprot.readString();
11855 
        else:
11856 
          iprot.skip(ftype)
11857 
      elif fid == 2:
11858 
        if ftype == TType.STRING:
11859 
          self.modelNumber = iprot.readString();
11860 
        else:
11861 
          iprot.skip(ftype)
11862 
      elif fid == 3:
11863 
        if ftype == TType.STRING:
11864 
          self.modelName = iprot.readString();
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      elif fid == 4:
11868 
        if ftype == TType.STRING:
11869 
          self.color = iprot.readString();
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      else:
11873 
        iprot.skip(ftype)
11874 
      iprot.readFieldEnd()
11875 
    iprot.readStructEnd()
11876 
 
11877 
  def write(self, oprot):
11878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11880 
      return
11881 
    oprot.writeStructBegin('checkSimilarItem_args')
11882 
    if self.brand is not None:
11883 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11884 
      oprot.writeString(self.brand)
11885 
      oprot.writeFieldEnd()
11886 
    if self.modelNumber is not None:
11887 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11888 
      oprot.writeString(self.modelNumber)
11889 
      oprot.writeFieldEnd()
11890 
    if self.modelName is not None:
11891 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11892 
      oprot.writeString(self.modelName)
11893 
      oprot.writeFieldEnd()
11894 
    if self.color is not None:
11895 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11896 
      oprot.writeString(self.color)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
11916 
class checkSimilarItem_result:
11917 
  """
11918 
  Attributes:
11919 
   - success
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    (0, TType.I64, 'success', None, None, ), # 0
11924 
  )
11925 
 
11926 
  def __init__(self, success=None,):
11927 
    self.success = success
11928 
 
11929 
  def read(self, iprot):
11930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11932 
      return
11933 
    iprot.readStructBegin()
11934 
    while True:
11935 
      (fname, ftype, fid) = iprot.readFieldBegin()
11936 
      if ftype == TType.STOP:
11937 
        break
11938 
      if fid == 0:
11939 
        if ftype == TType.I64:
11940 
          self.success = iprot.readI64();
11941 
        else:
11942 
          iprot.skip(ftype)
11943 
      else:
11944 
        iprot.skip(ftype)
11945 
      iprot.readFieldEnd()
11946 
    iprot.readStructEnd()
11947 
 
11948 
  def write(self, oprot):
11949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11951 
      return
11952 
    oprot.writeStructBegin('checkSimilarItem_result')
11953 
    if self.success is not None:
11954 
      oprot.writeFieldBegin('success', TType.I64, 0)
11955 
      oprot.writeI64(self.success)
11956 
      oprot.writeFieldEnd()
11957 
    oprot.writeFieldStop()
11958 
    oprot.writeStructEnd()
11959 
 
11960 
  def validate(self):
11961 
    return
11962 
 
11963 
 
11964 
  def __repr__(self):
11965 
    L = ['%s=%r' % (key, value)
11966 
      for key, value in self.__dict__.iteritems()]
11967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11968 
 
11969 
  def __eq__(self, other):
11970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11971 
 
11972 
  def __ne__(self, other):
11973 
    return not (self == other)
11974 
 
11975 
class validateRiskyStatus_args:
11976 
  """
11977 
  Attributes:
11978 
   - itemId
11979 
  """
11980 
 
11981 
  thrift_spec = (
11982 
    None, # 0
11983 
    (1, TType.I64, 'itemId', None, None, ), # 1
11984 
  )
11985 
 
11986 
  def __init__(self, itemId=None,):
11987 
    self.itemId = itemId
11988 
 
11989 
  def read(self, iprot):
11990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11992 
      return
11993 
    iprot.readStructBegin()
11994 
    while True:
11995 
      (fname, ftype, fid) = iprot.readFieldBegin()
11996 
      if ftype == TType.STOP:
11997 
        break
11998 
      if fid == 1:
11999 
        if ftype == TType.I64:
12000 
          self.itemId = iprot.readI64();
12001 
        else:
12002 
          iprot.skip(ftype)
12003 
      else:
12004 
        iprot.skip(ftype)
12005 
      iprot.readFieldEnd()
12006 
    iprot.readStructEnd()
12007 
 
12008 
  def write(self, oprot):
12009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12011 
      return
12012 
    oprot.writeStructBegin('validateRiskyStatus_args')
12013 
    if self.itemId is not None:
12014 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12015 
      oprot.writeI64(self.itemId)
12016 
      oprot.writeFieldEnd()
12017 
    oprot.writeFieldStop()
12018 
    oprot.writeStructEnd()
12019 
 
12020 
  def validate(self):
12021 
    return
12022 
 
12023 
 
12024 
  def __repr__(self):
12025 
    L = ['%s=%r' % (key, value)
12026 
      for key, value in self.__dict__.iteritems()]
12027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12028 
 
12029 
  def __eq__(self, other):
12030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12031 
 
12032 
  def __ne__(self, other):
12033 
    return not (self == other)
12034 
 
12035 
class validateRiskyStatus_result:
12036 
 
12037 
  thrift_spec = (
12038 
  )
12039 
 
12040 
  def read(self, iprot):
12041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12043 
      return
12044 
    iprot.readStructBegin()
12045 
    while True:
12046 
      (fname, ftype, fid) = iprot.readFieldBegin()
12047 
      if ftype == TType.STOP:
12048 
        break
12049 
      else:
12050 
        iprot.skip(ftype)
12051 
      iprot.readFieldEnd()
12052 
    iprot.readStructEnd()
12053 
 
12054 
  def write(self, oprot):
12055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12057 
      return
12058 
    oprot.writeStructBegin('validateRiskyStatus_result')
12059 
    oprot.writeFieldStop()
12060 
    oprot.writeStructEnd()
12061 
 
12062 
  def validate(self):
12063 
    return
12064 
 
12065 
 
12066 
  def __repr__(self):
12067 
    L = ['%s=%r' % (key, value)
12068 
      for key, value in self.__dict__.iteritems()]
12069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12070 
 
12071 
  def __eq__(self, other):
12072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12073 
 
12074 
  def __ne__(self, other):
12075 
    return not (self == other)
12076 
 
12077 
class changeItemRiskyFlag_args:
12078 
  """
12079 
  Attributes:
12080 
   - itemId
12081 
   - risky
12082 
  """
12083 
 
12084 
  thrift_spec = (
12085 
    None, # 0
12086 
    (1, TType.I64, 'itemId', None, None, ), # 1
12087 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12088 
  )
12089 
 
12090 
  def __init__(self, itemId=None, risky=None,):
12091 
    self.itemId = itemId
12092 
    self.risky = risky
12093 
 
12094 
  def read(self, iprot):
12095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12097 
      return
12098 
    iprot.readStructBegin()
12099 
    while True:
12100 
      (fname, ftype, fid) = iprot.readFieldBegin()
12101 
      if ftype == TType.STOP:
12102 
        break
12103 
      if fid == 1:
12104 
        if ftype == TType.I64:
12105 
          self.itemId = iprot.readI64();
12106 
        else:
12107 
          iprot.skip(ftype)
12108 
      elif fid == 2:
12109 
        if ftype == TType.BOOL:
12110 
          self.risky = iprot.readBool();
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('changeItemRiskyFlag_args')
12123 
    if self.itemId is not None:
12124 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12125 
      oprot.writeI64(self.itemId)
12126 
      oprot.writeFieldEnd()
12127 
    if self.risky is not None:
12128 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12129 
      oprot.writeBool(self.risky)
12130 
      oprot.writeFieldEnd()
12131 
    oprot.writeFieldStop()
12132 
    oprot.writeStructEnd()
12133 
 
12134 
  def validate(self):
12135 
    return
12136 
 
12137 
 
12138 
  def __repr__(self):
12139 
    L = ['%s=%r' % (key, value)
12140 
      for key, value in self.__dict__.iteritems()]
12141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12142 
 
12143 
  def __eq__(self, other):
12144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12145 
 
12146 
  def __ne__(self, other):
12147 
    return not (self == other)
12148 
 
12149 
class changeItemRiskyFlag_result:
12150 
 
12151 
  thrift_spec = (
12152 
  )
12153 
 
12154 
  def read(self, iprot):
12155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12157 
      return
12158 
    iprot.readStructBegin()
12159 
    while True:
12160 
      (fname, ftype, fid) = iprot.readFieldBegin()
12161 
      if ftype == TType.STOP:
12162 
        break
12163 
      else:
12164 
        iprot.skip(ftype)
12165 
      iprot.readFieldEnd()
12166 
    iprot.readStructEnd()
12167 
 
12168 
  def write(self, oprot):
12169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12171 
      return
12172 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12173 
    oprot.writeFieldStop()
12174 
    oprot.writeStructEnd()
12175 
 
12176 
  def validate(self):
12177 
    return
12178 
 
12179 
 
12180 
  def __repr__(self):
12181 
    L = ['%s=%r' % (key, value)
12182 
      for key, value in self.__dict__.iteritems()]
12183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12184 
 
12185 
  def __eq__(self, other):
12186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12187 
 
12188 
  def __ne__(self, other):
12189 
    return not (self == other)
12190 
 
12191 
class getItemsByRiskyFlag_args:
12192 
 
12193 
  thrift_spec = (
12194 
  )
12195 
 
12196 
  def read(self, iprot):
12197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12199 
      return
12200 
    iprot.readStructBegin()
12201 
    while True:
12202 
      (fname, ftype, fid) = iprot.readFieldBegin()
12203 
      if ftype == TType.STOP:
12204 
        break
12205 
      else:
12206 
        iprot.skip(ftype)
12207 
      iprot.readFieldEnd()
12208 
    iprot.readStructEnd()
12209 
 
12210 
  def write(self, oprot):
12211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12213 
      return
12214 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12215 
    oprot.writeFieldStop()
12216 
    oprot.writeStructEnd()
12217 
 
12218 
  def validate(self):
12219 
    return
12220 
 
12221 
 
12222 
  def __repr__(self):
12223 
    L = ['%s=%r' % (key, value)
12224 
      for key, value in self.__dict__.iteritems()]
12225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12226 
 
12227 
  def __eq__(self, other):
12228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12229 
 
12230 
  def __ne__(self, other):
12231 
    return not (self == other)
12232 
 
12233 
class getItemsByRiskyFlag_result:
12234 
  """
12235 
  Attributes:
12236 
   - success
12237 
  """
12238 
 
12239 
  thrift_spec = (
12240 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12241 
  )
12242 
 
12243 
  def __init__(self, success=None,):
12244 
    self.success = success
12245 
 
12246 
  def read(self, iprot):
12247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12249 
      return
12250 
    iprot.readStructBegin()
12251 
    while True:
12252 
      (fname, ftype, fid) = iprot.readFieldBegin()
12253 
      if ftype == TType.STOP:
12254 
        break
12255 
      if fid == 0:
12256 
        if ftype == TType.LIST:
12257 
          self.success = []
7438 amit.gupta 12258 
          (_etype205, _size202) = iprot.readListBegin()
12259 
          for _i206 in xrange(_size202):
12260 
            _elem207 = Item()
12261 
            _elem207.read(iprot)
12262 
            self.success.append(_elem207)
5944 mandeep.dh 12263 
          iprot.readListEnd()
12264 
        else:
12265 
          iprot.skip(ftype)
12266 
      else:
12267 
        iprot.skip(ftype)
12268 
      iprot.readFieldEnd()
12269 
    iprot.readStructEnd()
12270 
 
12271 
  def write(self, oprot):
12272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12274 
      return
12275 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12276 
    if self.success is not None:
12277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12279 
      for iter208 in self.success:
12280 
        iter208.write(oprot)
5944 mandeep.dh 12281 
      oprot.writeListEnd()
12282 
      oprot.writeFieldEnd()
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 getItemsForMasterSheet_args:
12302 
  """
12303 
  Attributes:
12304 
   - category
12305 
   - brand
12306 
  """
12307 
 
12308 
  thrift_spec = (
12309 
    None, # 0
12310 
    (1, TType.STRING, 'category', None, None, ), # 1
12311 
    (2, TType.STRING, 'brand', None, None, ), # 2
12312 
  )
12313 
 
12314 
  def __init__(self, category=None, brand=None,):
12315 
    self.category = category
12316 
    self.brand = brand
12317 
 
12318 
  def read(self, iprot):
12319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12321 
      return
12322 
    iprot.readStructBegin()
12323 
    while True:
12324 
      (fname, ftype, fid) = iprot.readFieldBegin()
12325 
      if ftype == TType.STOP:
12326 
        break
12327 
      if fid == 1:
12328 
        if ftype == TType.STRING:
12329 
          self.category = iprot.readString();
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      elif fid == 2:
12333 
        if ftype == TType.STRING:
12334 
          self.brand = iprot.readString();
12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      else:
12338 
        iprot.skip(ftype)
12339 
      iprot.readFieldEnd()
12340 
    iprot.readStructEnd()
12341 
 
12342 
  def write(self, oprot):
12343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12345 
      return
12346 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12347 
    if self.category is not None:
12348 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12349 
      oprot.writeString(self.category)
12350 
      oprot.writeFieldEnd()
12351 
    if self.brand is not None:
12352 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12353 
      oprot.writeString(self.brand)
12354 
      oprot.writeFieldEnd()
12355 
    oprot.writeFieldStop()
12356 
    oprot.writeStructEnd()
12357 
 
12358 
  def validate(self):
12359 
    return
12360 
 
12361 
 
12362 
  def __repr__(self):
12363 
    L = ['%s=%r' % (key, value)
12364 
      for key, value in self.__dict__.iteritems()]
12365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12366 
 
12367 
  def __eq__(self, other):
12368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12369 
 
12370 
  def __ne__(self, other):
12371 
    return not (self == other)
12372 
 
12373 
class getItemsForMasterSheet_result:
12374 
  """
12375 
  Attributes:
12376 
   - success
12377 
  """
12378 
 
12379 
  thrift_spec = (
12380 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12381 
  )
12382 
 
12383 
  def __init__(self, success=None,):
12384 
    self.success = success
12385 
 
12386 
  def read(self, iprot):
12387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12389 
      return
12390 
    iprot.readStructBegin()
12391 
    while True:
12392 
      (fname, ftype, fid) = iprot.readFieldBegin()
12393 
      if ftype == TType.STOP:
12394 
        break
12395 
      if fid == 0:
12396 
        if ftype == TType.LIST:
12397 
          self.success = []
7438 amit.gupta 12398 
          (_etype212, _size209) = iprot.readListBegin()
12399 
          for _i213 in xrange(_size209):
12400 
            _elem214 = Item()
12401 
            _elem214.read(iprot)
12402 
            self.success.append(_elem214)
5944 mandeep.dh 12403 
          iprot.readListEnd()
12404 
        else:
12405 
          iprot.skip(ftype)
12406 
      else:
12407 
        iprot.skip(ftype)
12408 
      iprot.readFieldEnd()
12409 
    iprot.readStructEnd()
12410 
 
12411 
  def write(self, oprot):
12412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12414 
      return
12415 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12416 
    if self.success is not None:
12417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12419 
      for iter215 in self.success:
12420 
        iter215.write(oprot)
5944 mandeep.dh 12421 
      oprot.writeListEnd()
12422 
      oprot.writeFieldEnd()
12423 
    oprot.writeFieldStop()
12424 
    oprot.writeStructEnd()
12425 
 
12426 
  def validate(self):
12427 
    return
12428 
 
12429 
 
12430 
  def __repr__(self):
12431 
    L = ['%s=%r' % (key, value)
12432 
      for key, value in self.__dict__.iteritems()]
12433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12434 
 
12435 
  def __eq__(self, other):
12436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12437 
 
12438 
  def __ne__(self, other):
12439 
    return not (self == other)
12440 
 
12441 
class getSimilarItemsCatalogIds_args:
12442 
  """
12443 
  Attributes:
12444 
   - beginIndex
12445 
   - totalItems
12446 
   - itemId
12447 
  """
12448 
 
12449 
  thrift_spec = (
12450 
    None, # 0
12451 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12452 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12453 
    (3, TType.I64, 'itemId', None, None, ), # 3
12454 
  )
12455 
 
12456 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12457 
    self.beginIndex = beginIndex
12458 
    self.totalItems = totalItems
12459 
    self.itemId = itemId
12460 
 
12461 
  def read(self, iprot):
12462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12464 
      return
12465 
    iprot.readStructBegin()
12466 
    while True:
12467 
      (fname, ftype, fid) = iprot.readFieldBegin()
12468 
      if ftype == TType.STOP:
12469 
        break
12470 
      if fid == 1:
12471 
        if ftype == TType.I64:
12472 
          self.beginIndex = iprot.readI64();
12473 
        else:
12474 
          iprot.skip(ftype)
12475 
      elif fid == 2:
12476 
        if ftype == TType.I64:
12477 
          self.totalItems = iprot.readI64();
12478 
        else:
12479 
          iprot.skip(ftype)
12480 
      elif fid == 3:
12481 
        if ftype == TType.I64:
12482 
          self.itemId = iprot.readI64();
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      else:
12486 
        iprot.skip(ftype)
12487 
      iprot.readFieldEnd()
12488 
    iprot.readStructEnd()
12489 
 
12490 
  def write(self, oprot):
12491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12493 
      return
12494 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12495 
    if self.beginIndex is not None:
12496 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12497 
      oprot.writeI64(self.beginIndex)
12498 
      oprot.writeFieldEnd()
12499 
    if self.totalItems is not None:
12500 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12501 
      oprot.writeI64(self.totalItems)
12502 
      oprot.writeFieldEnd()
12503 
    if self.itemId is not None:
12504 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12505 
      oprot.writeI64(self.itemId)
12506 
      oprot.writeFieldEnd()
12507 
    oprot.writeFieldStop()
12508 
    oprot.writeStructEnd()
12509 
 
12510 
  def validate(self):
12511 
    return
12512 
 
12513 
 
12514 
  def __repr__(self):
12515 
    L = ['%s=%r' % (key, value)
12516 
      for key, value in self.__dict__.iteritems()]
12517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12518 
 
12519 
  def __eq__(self, other):
12520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12521 
 
12522 
  def __ne__(self, other):
12523 
    return not (self == other)
12524 
 
12525 
class getSimilarItemsCatalogIds_result:
12526 
  """
12527 
  Attributes:
12528 
   - success
12529 
  """
12530 
 
12531 
  thrift_spec = (
12532 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12533 
  )
12534 
 
12535 
  def __init__(self, success=None,):
12536 
    self.success = success
12537 
 
12538 
  def read(self, iprot):
12539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12541 
      return
12542 
    iprot.readStructBegin()
12543 
    while True:
12544 
      (fname, ftype, fid) = iprot.readFieldBegin()
12545 
      if ftype == TType.STOP:
12546 
        break
12547 
      if fid == 0:
12548 
        if ftype == TType.LIST:
12549 
          self.success = []
7438 amit.gupta 12550 
          (_etype219, _size216) = iprot.readListBegin()
12551 
          for _i220 in xrange(_size216):
12552 
            _elem221 = iprot.readI64();
12553 
            self.success.append(_elem221)
5944 mandeep.dh 12554 
          iprot.readListEnd()
12555 
        else:
12556 
          iprot.skip(ftype)
12557 
      else:
12558 
        iprot.skip(ftype)
12559 
      iprot.readFieldEnd()
12560 
    iprot.readStructEnd()
12561 
 
12562 
  def write(self, oprot):
12563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12565 
      return
12566 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12567 
    if self.success is not None:
12568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12569 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12570 
      for iter222 in self.success:
12571 
        oprot.writeI64(iter222)
5944 mandeep.dh 12572 
      oprot.writeListEnd()
12573 
      oprot.writeFieldEnd()
12574 
    oprot.writeFieldStop()
12575 
    oprot.writeStructEnd()
12576 
 
12577 
  def validate(self):
12578 
    return
12579 
 
12580 
 
12581 
  def __repr__(self):
12582 
    L = ['%s=%r' % (key, value)
12583 
      for key, value in self.__dict__.iteritems()]
12584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12585 
 
12586 
  def __eq__(self, other):
12587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12588 
 
12589 
  def __ne__(self, other):
12590 
    return not (self == other)
12591 
 
12592 
class addProductNotification_args:
12593 
  """
12594 
  Attributes:
12595 
   - itemId
12596 
   - email
12597 
  """
12598 
 
12599 
  thrift_spec = None
12600 
  def __init__(self, itemId=None, email=None,):
12601 
    self.itemId = itemId
12602 
    self.email = email
12603 
 
12604 
  def read(self, iprot):
12605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12607 
      return
12608 
    iprot.readStructBegin()
12609 
    while True:
12610 
      (fname, ftype, fid) = iprot.readFieldBegin()
12611 
      if ftype == TType.STOP:
12612 
        break
12613 
      if fid == -1:
12614 
        if ftype == TType.I64:
12615 
          self.itemId = iprot.readI64();
12616 
        else:
12617 
          iprot.skip(ftype)
12618 
      elif fid == -2:
12619 
        if ftype == TType.STRING:
12620 
          self.email = iprot.readString();
12621 
        else:
12622 
          iprot.skip(ftype)
12623 
      else:
12624 
        iprot.skip(ftype)
12625 
      iprot.readFieldEnd()
12626 
    iprot.readStructEnd()
12627 
 
12628 
  def write(self, oprot):
12629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12631 
      return
12632 
    oprot.writeStructBegin('addProductNotification_args')
12633 
    if self.email is not None:
12634 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12635 
      oprot.writeString(self.email)
12636 
      oprot.writeFieldEnd()
12637 
    if self.itemId is not None:
12638 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12639 
      oprot.writeI64(self.itemId)
12640 
      oprot.writeFieldEnd()
12641 
    oprot.writeFieldStop()
12642 
    oprot.writeStructEnd()
12643 
 
12644 
  def validate(self):
12645 
    return
12646 
 
12647 
 
12648 
  def __repr__(self):
12649 
    L = ['%s=%r' % (key, value)
12650 
      for key, value in self.__dict__.iteritems()]
12651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12652 
 
12653 
  def __eq__(self, other):
12654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12655 
 
12656 
  def __ne__(self, other):
12657 
    return not (self == other)
12658 
 
12659 
class addProductNotification_result:
12660 
  """
12661 
  Attributes:
12662 
   - success
12663 
  """
12664 
 
12665 
  thrift_spec = (
12666 
    (0, TType.BOOL, 'success', None, None, ), # 0
12667 
  )
12668 
 
12669 
  def __init__(self, success=None,):
12670 
    self.success = success
12671 
 
12672 
  def read(self, iprot):
12673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12675 
      return
12676 
    iprot.readStructBegin()
12677 
    while True:
12678 
      (fname, ftype, fid) = iprot.readFieldBegin()
12679 
      if ftype == TType.STOP:
12680 
        break
12681 
      if fid == 0:
12682 
        if ftype == TType.BOOL:
12683 
          self.success = iprot.readBool();
12684 
        else:
12685 
          iprot.skip(ftype)
12686 
      else:
12687 
        iprot.skip(ftype)
12688 
      iprot.readFieldEnd()
12689 
    iprot.readStructEnd()
12690 
 
12691 
  def write(self, oprot):
12692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12694 
      return
12695 
    oprot.writeStructBegin('addProductNotification_result')
12696 
    if self.success is not None:
12697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12698 
      oprot.writeBool(self.success)
12699 
      oprot.writeFieldEnd()
12700 
    oprot.writeFieldStop()
12701 
    oprot.writeStructEnd()
12702 
 
12703 
  def validate(self):
12704 
    return
12705 
 
12706 
 
12707 
  def __repr__(self):
12708 
    L = ['%s=%r' % (key, value)
12709 
      for key, value in self.__dict__.iteritems()]
12710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12711 
 
12712 
  def __eq__(self, other):
12713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12714 
 
12715 
  def __ne__(self, other):
12716 
    return not (self == other)
12717 
 
12718 
class sendProductNotifications_args:
12719 
 
12720 
  thrift_spec = (
12721 
  )
12722 
 
12723 
  def read(self, iprot):
12724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12726 
      return
12727 
    iprot.readStructBegin()
12728 
    while True:
12729 
      (fname, ftype, fid) = iprot.readFieldBegin()
12730 
      if ftype == TType.STOP:
12731 
        break
12732 
      else:
12733 
        iprot.skip(ftype)
12734 
      iprot.readFieldEnd()
12735 
    iprot.readStructEnd()
12736 
 
12737 
  def write(self, oprot):
12738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12740 
      return
12741 
    oprot.writeStructBegin('sendProductNotifications_args')
12742 
    oprot.writeFieldStop()
12743 
    oprot.writeStructEnd()
12744 
 
12745 
  def validate(self):
12746 
    return
12747 
 
12748 
 
12749 
  def __repr__(self):
12750 
    L = ['%s=%r' % (key, value)
12751 
      for key, value in self.__dict__.iteritems()]
12752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12753 
 
12754 
  def __eq__(self, other):
12755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12756 
 
12757 
  def __ne__(self, other):
12758 
    return not (self == other)
12759 
 
12760 
class sendProductNotifications_result:
12761 
  """
12762 
  Attributes:
12763 
   - success
12764 
  """
12765 
 
12766 
  thrift_spec = (
12767 
    (0, TType.BOOL, 'success', None, None, ), # 0
12768 
  )
12769 
 
12770 
  def __init__(self, success=None,):
12771 
    self.success = success
12772 
 
12773 
  def read(self, iprot):
12774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12776 
      return
12777 
    iprot.readStructBegin()
12778 
    while True:
12779 
      (fname, ftype, fid) = iprot.readFieldBegin()
12780 
      if ftype == TType.STOP:
12781 
        break
12782 
      if fid == 0:
12783 
        if ftype == TType.BOOL:
12784 
          self.success = iprot.readBool();
12785 
        else:
12786 
          iprot.skip(ftype)
12787 
      else:
12788 
        iprot.skip(ftype)
12789 
      iprot.readFieldEnd()
12790 
    iprot.readStructEnd()
12791 
 
12792 
  def write(self, oprot):
12793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12795 
      return
12796 
    oprot.writeStructBegin('sendProductNotifications_result')
12797 
    if self.success is not None:
12798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12799 
      oprot.writeBool(self.success)
12800 
      oprot.writeFieldEnd()
12801 
    oprot.writeFieldStop()
12802 
    oprot.writeStructEnd()
12803 
 
12804 
  def validate(self):
12805 
    return
12806 
 
12807 
 
12808 
  def __repr__(self):
12809 
    L = ['%s=%r' % (key, value)
12810 
      for key, value in self.__dict__.iteritems()]
12811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12812 
 
12813 
  def __eq__(self, other):
12814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12815 
 
12816 
  def __ne__(self, other):
12817 
    return not (self == other)
12818 
 
12819 
class getAllBrandsByCategory_args:
12820 
  """
12821 
  Attributes:
12822 
   - categoryId
12823 
  """
12824 
 
12825 
  thrift_spec = (
12826 
    None, # 0
12827 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12828 
  )
12829 
 
12830 
  def __init__(self, categoryId=None,):
12831 
    self.categoryId = categoryId
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 
      if fid == 1:
12843 
        if ftype == TType.I64:
12844 
          self.categoryId = iprot.readI64();
12845 
        else:
12846 
          iprot.skip(ftype)
12847 
      else:
12848 
        iprot.skip(ftype)
12849 
      iprot.readFieldEnd()
12850 
    iprot.readStructEnd()
12851 
 
12852 
  def write(self, oprot):
12853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12855 
      return
12856 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12857 
    if self.categoryId is not None:
12858 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12859 
      oprot.writeI64(self.categoryId)
12860 
      oprot.writeFieldEnd()
12861 
    oprot.writeFieldStop()
12862 
    oprot.writeStructEnd()
12863 
 
12864 
  def validate(self):
12865 
    return
12866 
 
12867 
 
12868 
  def __repr__(self):
12869 
    L = ['%s=%r' % (key, value)
12870 
      for key, value in self.__dict__.iteritems()]
12871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12872 
 
12873 
  def __eq__(self, other):
12874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12875 
 
12876 
  def __ne__(self, other):
12877 
    return not (self == other)
12878 
 
12879 
class getAllBrandsByCategory_result:
12880 
  """
12881 
  Attributes:
12882 
   - success
12883 
  """
12884 
 
12885 
  thrift_spec = (
12886 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12887 
  )
12888 
 
12889 
  def __init__(self, success=None,):
12890 
    self.success = success
12891 
 
12892 
  def read(self, iprot):
12893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12895 
      return
12896 
    iprot.readStructBegin()
12897 
    while True:
12898 
      (fname, ftype, fid) = iprot.readFieldBegin()
12899 
      if ftype == TType.STOP:
12900 
        break
12901 
      if fid == 0:
12902 
        if ftype == TType.LIST:
12903 
          self.success = []
7438 amit.gupta 12904 
          (_etype226, _size223) = iprot.readListBegin()
12905 
          for _i227 in xrange(_size223):
12906 
            _elem228 = iprot.readString();
12907 
            self.success.append(_elem228)
5944 mandeep.dh 12908 
          iprot.readListEnd()
12909 
        else:
12910 
          iprot.skip(ftype)
12911 
      else:
12912 
        iprot.skip(ftype)
12913 
      iprot.readFieldEnd()
12914 
    iprot.readStructEnd()
12915 
 
12916 
  def write(self, oprot):
12917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12919 
      return
12920 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12921 
    if self.success is not None:
12922 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12923 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 12924 
      for iter229 in self.success:
12925 
        oprot.writeString(iter229)
5944 mandeep.dh 12926 
      oprot.writeListEnd()
12927 
      oprot.writeFieldEnd()
12928 
    oprot.writeFieldStop()
12929 
    oprot.writeStructEnd()
12930 
 
12931 
  def validate(self):
12932 
    return
12933 
 
12934 
 
12935 
  def __repr__(self):
12936 
    L = ['%s=%r' % (key, value)
12937 
      for key, value in self.__dict__.iteritems()]
12938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12939 
 
12940 
  def __eq__(self, other):
12941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12942 
 
12943 
  def __ne__(self, other):
12944 
    return not (self == other)
12945 
 
12946 
class getAllBrands_args:
12947 
 
12948 
  thrift_spec = (
12949 
  )
12950 
 
12951 
  def read(self, iprot):
12952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12954 
      return
12955 
    iprot.readStructBegin()
12956 
    while True:
12957 
      (fname, ftype, fid) = iprot.readFieldBegin()
12958 
      if ftype == TType.STOP:
12959 
        break
12960 
      else:
12961 
        iprot.skip(ftype)
12962 
      iprot.readFieldEnd()
12963 
    iprot.readStructEnd()
12964 
 
12965 
  def write(self, oprot):
12966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12968 
      return
12969 
    oprot.writeStructBegin('getAllBrands_args')
12970 
    oprot.writeFieldStop()
12971 
    oprot.writeStructEnd()
12972 
 
12973 
  def validate(self):
12974 
    return
12975 
 
12976 
 
12977 
  def __repr__(self):
12978 
    L = ['%s=%r' % (key, value)
12979 
      for key, value in self.__dict__.iteritems()]
12980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12981 
 
12982 
  def __eq__(self, other):
12983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12984 
 
12985 
  def __ne__(self, other):
12986 
    return not (self == other)
12987 
 
12988 
class getAllBrands_result:
12989 
  """
12990 
  Attributes:
12991 
   - success
12992 
  """
12993 
 
12994 
  thrift_spec = (
12995 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12996 
  )
12997 
 
12998 
  def __init__(self, success=None,):
12999 
    self.success = success
13000 
 
13001 
  def read(self, iprot):
13002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13004 
      return
13005 
    iprot.readStructBegin()
13006 
    while True:
13007 
      (fname, ftype, fid) = iprot.readFieldBegin()
13008 
      if ftype == TType.STOP:
13009 
        break
13010 
      if fid == 0:
13011 
        if ftype == TType.LIST:
13012 
          self.success = []
7438 amit.gupta 13013 
          (_etype233, _size230) = iprot.readListBegin()
13014 
          for _i234 in xrange(_size230):
13015 
            _elem235 = iprot.readString();
13016 
            self.success.append(_elem235)
5944 mandeep.dh 13017 
          iprot.readListEnd()
13018 
        else:
13019 
          iprot.skip(ftype)
13020 
      else:
13021 
        iprot.skip(ftype)
13022 
      iprot.readFieldEnd()
13023 
    iprot.readStructEnd()
13024 
 
13025 
  def write(self, oprot):
13026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13028 
      return
13029 
    oprot.writeStructBegin('getAllBrands_result')
13030 
    if self.success is not None:
13031 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13032 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13033 
      for iter236 in self.success:
13034 
        oprot.writeString(iter236)
5944 mandeep.dh 13035 
      oprot.writeListEnd()
13036 
      oprot.writeFieldEnd()
13037 
    oprot.writeFieldStop()
13038 
    oprot.writeStructEnd()
13039 
 
13040 
  def validate(self):
13041 
    return
13042 
 
13043 
 
13044 
  def __repr__(self):
13045 
    L = ['%s=%r' % (key, value)
13046 
      for key, value in self.__dict__.iteritems()]
13047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13048 
 
13049 
  def __eq__(self, other):
13050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13051 
 
13052 
  def __ne__(self, other):
13053 
    return not (self == other)
13054 
 
13055 
class getAllSources_args:
13056 
 
13057 
  thrift_spec = (
13058 
  )
13059 
 
13060 
  def read(self, iprot):
13061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13063 
      return
13064 
    iprot.readStructBegin()
13065 
    while True:
13066 
      (fname, ftype, fid) = iprot.readFieldBegin()
13067 
      if ftype == TType.STOP:
13068 
        break
13069 
      else:
13070 
        iprot.skip(ftype)
13071 
      iprot.readFieldEnd()
13072 
    iprot.readStructEnd()
13073 
 
13074 
  def write(self, oprot):
13075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13077 
      return
13078 
    oprot.writeStructBegin('getAllSources_args')
13079 
    oprot.writeFieldStop()
13080 
    oprot.writeStructEnd()
13081 
 
13082 
  def validate(self):
13083 
    return
13084 
 
13085 
 
13086 
  def __repr__(self):
13087 
    L = ['%s=%r' % (key, value)
13088 
      for key, value in self.__dict__.iteritems()]
13089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13090 
 
13091 
  def __eq__(self, other):
13092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13093 
 
13094 
  def __ne__(self, other):
13095 
    return not (self == other)
13096 
 
13097 
class getAllSources_result:
13098 
  """
13099 
  Attributes:
13100 
   - success
13101 
  """
13102 
 
13103 
  thrift_spec = (
13104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13105 
  )
13106 
 
13107 
  def __init__(self, success=None,):
13108 
    self.success = success
13109 
 
13110 
  def read(self, iprot):
13111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13113 
      return
13114 
    iprot.readStructBegin()
13115 
    while True:
13116 
      (fname, ftype, fid) = iprot.readFieldBegin()
13117 
      if ftype == TType.STOP:
13118 
        break
13119 
      if fid == 0:
13120 
        if ftype == TType.LIST:
13121 
          self.success = []
7438 amit.gupta 13122 
          (_etype240, _size237) = iprot.readListBegin()
13123 
          for _i241 in xrange(_size237):
13124 
            _elem242 = Source()
13125 
            _elem242.read(iprot)
13126 
            self.success.append(_elem242)
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('getAllSources_result')
13140 
    if self.success is not None:
13141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13143 
      for iter243 in self.success:
13144 
        iter243.write(oprot)
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 getItemPricingBySource_args:
13166 
  """
13167 
  Attributes:
13168 
   - itemId
13169 
   - sourceId
13170 
  """
13171 
 
13172 
  thrift_spec = (
13173 
    None, # 0
13174 
    (1, TType.I64, 'itemId', None, None, ), # 1
13175 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13176 
  )
13177 
 
13178 
  def __init__(self, itemId=None, sourceId=None,):
13179 
    self.itemId = itemId
13180 
    self.sourceId = sourceId
13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 1:
13192 
        if ftype == TType.I64:
13193 
          self.itemId = iprot.readI64();
13194 
        else:
13195 
          iprot.skip(ftype)
13196 
      elif fid == 2:
13197 
        if ftype == TType.I64:
13198 
          self.sourceId = iprot.readI64();
13199 
        else:
13200 
          iprot.skip(ftype)
13201 
      else:
13202 
        iprot.skip(ftype)
13203 
      iprot.readFieldEnd()
13204 
    iprot.readStructEnd()
13205 
 
13206 
  def write(self, oprot):
13207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13209 
      return
13210 
    oprot.writeStructBegin('getItemPricingBySource_args')
13211 
    if self.itemId is not None:
13212 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13213 
      oprot.writeI64(self.itemId)
13214 
      oprot.writeFieldEnd()
13215 
    if self.sourceId is not None:
13216 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13217 
      oprot.writeI64(self.sourceId)
13218 
      oprot.writeFieldEnd()
13219 
    oprot.writeFieldStop()
13220 
    oprot.writeStructEnd()
13221 
 
13222 
  def validate(self):
13223 
    return
13224 
 
13225 
 
13226 
  def __repr__(self):
13227 
    L = ['%s=%r' % (key, value)
13228 
      for key, value in self.__dict__.iteritems()]
13229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13230 
 
13231 
  def __eq__(self, other):
13232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13233 
 
13234 
  def __ne__(self, other):
13235 
    return not (self == other)
13236 
 
13237 
class getItemPricingBySource_result:
13238 
  """
13239 
  Attributes:
13240 
   - success
13241 
   - cex
13242 
  """
13243 
 
13244 
  thrift_spec = (
13245 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13246 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13247 
  )
13248 
 
13249 
  def __init__(self, success=None, cex=None,):
13250 
    self.success = success
13251 
    self.cex = cex
13252 
 
13253 
  def read(self, iprot):
13254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13256 
      return
13257 
    iprot.readStructBegin()
13258 
    while True:
13259 
      (fname, ftype, fid) = iprot.readFieldBegin()
13260 
      if ftype == TType.STOP:
13261 
        break
13262 
      if fid == 0:
13263 
        if ftype == TType.STRUCT:
13264 
          self.success = SourceItemPricing()
13265 
          self.success.read(iprot)
13266 
        else:
13267 
          iprot.skip(ftype)
13268 
      elif fid == 1:
13269 
        if ftype == TType.STRUCT:
13270 
          self.cex = CatalogServiceException()
13271 
          self.cex.read(iprot)
13272 
        else:
13273 
          iprot.skip(ftype)
13274 
      else:
13275 
        iprot.skip(ftype)
13276 
      iprot.readFieldEnd()
13277 
    iprot.readStructEnd()
13278 
 
13279 
  def write(self, oprot):
13280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13282 
      return
13283 
    oprot.writeStructBegin('getItemPricingBySource_result')
13284 
    if self.success is not None:
13285 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13286 
      self.success.write(oprot)
13287 
      oprot.writeFieldEnd()
13288 
    if self.cex is not None:
13289 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13290 
      self.cex.write(oprot)
13291 
      oprot.writeFieldEnd()
13292 
    oprot.writeFieldStop()
13293 
    oprot.writeStructEnd()
13294 
 
13295 
  def validate(self):
13296 
    return
13297 
 
13298 
 
13299 
  def __repr__(self):
13300 
    L = ['%s=%r' % (key, value)
13301 
      for key, value in self.__dict__.iteritems()]
13302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13303 
 
13304 
  def __eq__(self, other):
13305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13306 
 
13307 
  def __ne__(self, other):
13308 
    return not (self == other)
13309 
 
13310 
class addSourceItemPricing_args:
13311 
  """
13312 
  Attributes:
13313 
   - sourceItemPricing
13314 
  """
13315 
 
13316 
  thrift_spec = (
13317 
    None, # 0
13318 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13319 
  )
13320 
 
13321 
  def __init__(self, sourceItemPricing=None,):
13322 
    self.sourceItemPricing = sourceItemPricing
13323 
 
13324 
  def read(self, iprot):
13325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13327 
      return
13328 
    iprot.readStructBegin()
13329 
    while True:
13330 
      (fname, ftype, fid) = iprot.readFieldBegin()
13331 
      if ftype == TType.STOP:
13332 
        break
13333 
      if fid == 1:
13334 
        if ftype == TType.STRUCT:
13335 
          self.sourceItemPricing = SourceItemPricing()
13336 
          self.sourceItemPricing.read(iprot)
13337 
        else:
13338 
          iprot.skip(ftype)
13339 
      else:
13340 
        iprot.skip(ftype)
13341 
      iprot.readFieldEnd()
13342 
    iprot.readStructEnd()
13343 
 
13344 
  def write(self, oprot):
13345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13347 
      return
13348 
    oprot.writeStructBegin('addSourceItemPricing_args')
13349 
    if self.sourceItemPricing is not None:
13350 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13351 
      self.sourceItemPricing.write(oprot)
13352 
      oprot.writeFieldEnd()
13353 
    oprot.writeFieldStop()
13354 
    oprot.writeStructEnd()
13355 
 
13356 
  def validate(self):
13357 
    return
13358 
 
13359 
 
13360 
  def __repr__(self):
13361 
    L = ['%s=%r' % (key, value)
13362 
      for key, value in self.__dict__.iteritems()]
13363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13364 
 
13365 
  def __eq__(self, other):
13366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13367 
 
13368 
  def __ne__(self, other):
13369 
    return not (self == other)
13370 
 
13371 
class addSourceItemPricing_result:
13372 
  """
13373 
  Attributes:
13374 
   - cex
13375 
  """
13376 
 
13377 
  thrift_spec = (
13378 
    None, # 0
13379 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13380 
  )
13381 
 
13382 
  def __init__(self, cex=None,):
13383 
    self.cex = cex
13384 
 
13385 
  def read(self, iprot):
13386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13388 
      return
13389 
    iprot.readStructBegin()
13390 
    while True:
13391 
      (fname, ftype, fid) = iprot.readFieldBegin()
13392 
      if ftype == TType.STOP:
13393 
        break
13394 
      if fid == 1:
13395 
        if ftype == TType.STRUCT:
13396 
          self.cex = CatalogServiceException()
13397 
          self.cex.read(iprot)
13398 
        else:
13399 
          iprot.skip(ftype)
13400 
      else:
13401 
        iprot.skip(ftype)
13402 
      iprot.readFieldEnd()
13403 
    iprot.readStructEnd()
13404 
 
13405 
  def write(self, oprot):
13406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13408 
      return
13409 
    oprot.writeStructBegin('addSourceItemPricing_result')
13410 
    if self.cex is not None:
13411 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13412 
      self.cex.write(oprot)
13413 
      oprot.writeFieldEnd()
13414 
    oprot.writeFieldStop()
13415 
    oprot.writeStructEnd()
13416 
 
13417 
  def validate(self):
13418 
    return
13419 
 
13420 
 
13421 
  def __repr__(self):
13422 
    L = ['%s=%r' % (key, value)
13423 
      for key, value in self.__dict__.iteritems()]
13424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13425 
 
13426 
  def __eq__(self, other):
13427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13428 
 
13429 
  def __ne__(self, other):
13430 
    return not (self == other)
13431 
 
13432 
class getAllSourcePricing_args:
13433 
  """
13434 
  Attributes:
13435 
   - itemId
13436 
  """
13437 
 
13438 
  thrift_spec = (
13439 
    None, # 0
13440 
    (1, TType.I64, 'itemId', None, None, ), # 1
13441 
  )
13442 
 
13443 
  def __init__(self, itemId=None,):
13444 
    self.itemId = itemId
13445 
 
13446 
  def read(self, iprot):
13447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13449 
      return
13450 
    iprot.readStructBegin()
13451 
    while True:
13452 
      (fname, ftype, fid) = iprot.readFieldBegin()
13453 
      if ftype == TType.STOP:
13454 
        break
13455 
      if fid == 1:
13456 
        if ftype == TType.I64:
13457 
          self.itemId = iprot.readI64();
13458 
        else:
13459 
          iprot.skip(ftype)
13460 
      else:
13461 
        iprot.skip(ftype)
13462 
      iprot.readFieldEnd()
13463 
    iprot.readStructEnd()
13464 
 
13465 
  def write(self, oprot):
13466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13468 
      return
13469 
    oprot.writeStructBegin('getAllSourcePricing_args')
13470 
    if self.itemId is not None:
13471 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13472 
      oprot.writeI64(self.itemId)
13473 
      oprot.writeFieldEnd()
13474 
    oprot.writeFieldStop()
13475 
    oprot.writeStructEnd()
13476 
 
13477 
  def validate(self):
13478 
    return
13479 
 
13480 
 
13481 
  def __repr__(self):
13482 
    L = ['%s=%r' % (key, value)
13483 
      for key, value in self.__dict__.iteritems()]
13484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13485 
 
13486 
  def __eq__(self, other):
13487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13488 
 
13489 
  def __ne__(self, other):
13490 
    return not (self == other)
13491 
 
13492 
class getAllSourcePricing_result:
13493 
  """
13494 
  Attributes:
13495 
   - success
13496 
   - cex
13497 
  """
13498 
 
13499 
  thrift_spec = (
13500 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13501 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13502 
  )
13503 
 
13504 
  def __init__(self, success=None, cex=None,):
13505 
    self.success = success
13506 
    self.cex = cex
13507 
 
13508 
  def read(self, iprot):
13509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13511 
      return
13512 
    iprot.readStructBegin()
13513 
    while True:
13514 
      (fname, ftype, fid) = iprot.readFieldBegin()
13515 
      if ftype == TType.STOP:
13516 
        break
13517 
      if fid == 0:
13518 
        if ftype == TType.LIST:
13519 
          self.success = []
7438 amit.gupta 13520 
          (_etype247, _size244) = iprot.readListBegin()
13521 
          for _i248 in xrange(_size244):
13522 
            _elem249 = SourceItemPricing()
13523 
            _elem249.read(iprot)
13524 
            self.success.append(_elem249)
5944 mandeep.dh 13525 
          iprot.readListEnd()
13526 
        else:
13527 
          iprot.skip(ftype)
13528 
      elif fid == 1:
13529 
        if ftype == TType.STRUCT:
13530 
          self.cex = CatalogServiceException()
13531 
          self.cex.read(iprot)
13532 
        else:
13533 
          iprot.skip(ftype)
13534 
      else:
13535 
        iprot.skip(ftype)
13536 
      iprot.readFieldEnd()
13537 
    iprot.readStructEnd()
13538 
 
13539 
  def write(self, oprot):
13540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13542 
      return
13543 
    oprot.writeStructBegin('getAllSourcePricing_result')
13544 
    if self.success is not None:
13545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13546 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13547 
      for iter250 in self.success:
13548 
        iter250.write(oprot)
5944 mandeep.dh 13549 
      oprot.writeListEnd()
13550 
      oprot.writeFieldEnd()
13551 
    if self.cex is not None:
13552 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13553 
      self.cex.write(oprot)
13554 
      oprot.writeFieldEnd()
13555 
    oprot.writeFieldStop()
13556 
    oprot.writeStructEnd()
13557 
 
13558 
  def validate(self):
13559 
    return
13560 
 
13561 
 
13562 
  def __repr__(self):
13563 
    L = ['%s=%r' % (key, value)
13564 
      for key, value in self.__dict__.iteritems()]
13565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13566 
 
13567 
  def __eq__(self, other):
13568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13569 
 
13570 
  def __ne__(self, other):
13571 
    return not (self == other)
13572 
 
13573 
class getItemForSource_args:
13574 
  """
13575 
  Attributes:
13576 
   - item_id
13577 
   - sourceId
13578 
  """
13579 
 
13580 
  thrift_spec = (
13581 
    None, # 0
13582 
    (1, TType.I64, 'item_id', None, None, ), # 1
13583 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13584 
  )
13585 
 
13586 
  def __init__(self, item_id=None, sourceId=None,):
13587 
    self.item_id = item_id
13588 
    self.sourceId = sourceId
13589 
 
13590 
  def read(self, iprot):
13591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13593 
      return
13594 
    iprot.readStructBegin()
13595 
    while True:
13596 
      (fname, ftype, fid) = iprot.readFieldBegin()
13597 
      if ftype == TType.STOP:
13598 
        break
13599 
      if fid == 1:
13600 
        if ftype == TType.I64:
13601 
          self.item_id = iprot.readI64();
13602 
        else:
13603 
          iprot.skip(ftype)
13604 
      elif fid == 2:
13605 
        if ftype == TType.I64:
13606 
          self.sourceId = iprot.readI64();
13607 
        else:
13608 
          iprot.skip(ftype)
13609 
      else:
13610 
        iprot.skip(ftype)
13611 
      iprot.readFieldEnd()
13612 
    iprot.readStructEnd()
13613 
 
13614 
  def write(self, oprot):
13615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13617 
      return
13618 
    oprot.writeStructBegin('getItemForSource_args')
13619 
    if self.item_id is not None:
13620 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13621 
      oprot.writeI64(self.item_id)
13622 
      oprot.writeFieldEnd()
13623 
    if self.sourceId is not None:
13624 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13625 
      oprot.writeI64(self.sourceId)
13626 
      oprot.writeFieldEnd()
13627 
    oprot.writeFieldStop()
13628 
    oprot.writeStructEnd()
13629 
 
13630 
  def validate(self):
13631 
    return
13632 
 
13633 
 
13634 
  def __repr__(self):
13635 
    L = ['%s=%r' % (key, value)
13636 
      for key, value in self.__dict__.iteritems()]
13637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13638 
 
13639 
  def __eq__(self, other):
13640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13641 
 
13642 
  def __ne__(self, other):
13643 
    return not (self == other)
13644 
 
13645 
class getItemForSource_result:
13646 
  """
13647 
  Attributes:
13648 
   - success
13649 
   - cex
13650 
  """
13651 
 
13652 
  thrift_spec = (
13653 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13655 
  )
13656 
 
13657 
  def __init__(self, success=None, cex=None,):
13658 
    self.success = success
13659 
    self.cex = cex
13660 
 
13661 
  def read(self, iprot):
13662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13664 
      return
13665 
    iprot.readStructBegin()
13666 
    while True:
13667 
      (fname, ftype, fid) = iprot.readFieldBegin()
13668 
      if ftype == TType.STOP:
13669 
        break
13670 
      if fid == 0:
13671 
        if ftype == TType.STRUCT:
13672 
          self.success = Item()
13673 
          self.success.read(iprot)
13674 
        else:
13675 
          iprot.skip(ftype)
13676 
      elif fid == 1:
13677 
        if ftype == TType.STRUCT:
13678 
          self.cex = CatalogServiceException()
13679 
          self.cex.read(iprot)
13680 
        else:
13681 
          iprot.skip(ftype)
13682 
      else:
13683 
        iprot.skip(ftype)
13684 
      iprot.readFieldEnd()
13685 
    iprot.readStructEnd()
13686 
 
13687 
  def write(self, oprot):
13688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13690 
      return
13691 
    oprot.writeStructBegin('getItemForSource_result')
13692 
    if self.success is not None:
13693 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13694 
      self.success.write(oprot)
13695 
      oprot.writeFieldEnd()
13696 
    if self.cex is not None:
13697 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13698 
      self.cex.write(oprot)
13699 
      oprot.writeFieldEnd()
13700 
    oprot.writeFieldStop()
13701 
    oprot.writeStructEnd()
13702 
 
13703 
  def validate(self):
13704 
    return
13705 
 
13706 
 
13707 
  def __repr__(self):
13708 
    L = ['%s=%r' % (key, value)
13709 
      for key, value in self.__dict__.iteritems()]
13710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13711 
 
13712 
  def __eq__(self, other):
13713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13714 
 
13715 
  def __ne__(self, other):
13716 
    return not (self == other)
13717 
 
13718 
class searchItemsInRange_args:
13719 
  """
13720 
  Attributes:
13721 
   - searchTerms
13722 
   - offset
13723 
   - limit
13724 
  """
13725 
 
13726 
  thrift_spec = (
13727 
    None, # 0
13728 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13729 
    (2, TType.I64, 'offset', None, None, ), # 2
13730 
    (3, TType.I64, 'limit', None, None, ), # 3
13731 
  )
13732 
 
13733 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13734 
    self.searchTerms = searchTerms
13735 
    self.offset = offset
13736 
    self.limit = limit
13737 
 
13738 
  def read(self, iprot):
13739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13741 
      return
13742 
    iprot.readStructBegin()
13743 
    while True:
13744 
      (fname, ftype, fid) = iprot.readFieldBegin()
13745 
      if ftype == TType.STOP:
13746 
        break
13747 
      if fid == 1:
13748 
        if ftype == TType.LIST:
13749 
          self.searchTerms = []
7438 amit.gupta 13750 
          (_etype254, _size251) = iprot.readListBegin()
13751 
          for _i255 in xrange(_size251):
13752 
            _elem256 = iprot.readString();
13753 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 13754 
          iprot.readListEnd()
13755 
        else:
13756 
          iprot.skip(ftype)
13757 
      elif fid == 2:
13758 
        if ftype == TType.I64:
13759 
          self.offset = iprot.readI64();
13760 
        else:
13761 
          iprot.skip(ftype)
13762 
      elif fid == 3:
13763 
        if ftype == TType.I64:
13764 
          self.limit = iprot.readI64();
13765 
        else:
13766 
          iprot.skip(ftype)
13767 
      else:
13768 
        iprot.skip(ftype)
13769 
      iprot.readFieldEnd()
13770 
    iprot.readStructEnd()
13771 
 
13772 
  def write(self, oprot):
13773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13775 
      return
13776 
    oprot.writeStructBegin('searchItemsInRange_args')
13777 
    if self.searchTerms is not None:
13778 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13779 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13780 
      for iter257 in self.searchTerms:
13781 
        oprot.writeString(iter257)
5944 mandeep.dh 13782 
      oprot.writeListEnd()
13783 
      oprot.writeFieldEnd()
13784 
    if self.offset is not None:
13785 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13786 
      oprot.writeI64(self.offset)
13787 
      oprot.writeFieldEnd()
13788 
    if self.limit is not None:
13789 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13790 
      oprot.writeI64(self.limit)
13791 
      oprot.writeFieldEnd()
13792 
    oprot.writeFieldStop()
13793 
    oprot.writeStructEnd()
13794 
 
13795 
  def validate(self):
13796 
    return
13797 
 
13798 
 
13799 
  def __repr__(self):
13800 
    L = ['%s=%r' % (key, value)
13801 
      for key, value in self.__dict__.iteritems()]
13802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13803 
 
13804 
  def __eq__(self, other):
13805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13806 
 
13807 
  def __ne__(self, other):
13808 
    return not (self == other)
13809 
 
13810 
class searchItemsInRange_result:
13811 
  """
13812 
  Attributes:
13813 
   - success
13814 
  """
13815 
 
13816 
  thrift_spec = (
13817 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13818 
  )
13819 
 
13820 
  def __init__(self, success=None,):
13821 
    self.success = success
13822 
 
13823 
  def read(self, iprot):
13824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13826 
      return
13827 
    iprot.readStructBegin()
13828 
    while True:
13829 
      (fname, ftype, fid) = iprot.readFieldBegin()
13830 
      if ftype == TType.STOP:
13831 
        break
13832 
      if fid == 0:
13833 
        if ftype == TType.LIST:
13834 
          self.success = []
7438 amit.gupta 13835 
          (_etype261, _size258) = iprot.readListBegin()
13836 
          for _i262 in xrange(_size258):
13837 
            _elem263 = Item()
13838 
            _elem263.read(iprot)
13839 
            self.success.append(_elem263)
5944 mandeep.dh 13840 
          iprot.readListEnd()
13841 
        else:
13842 
          iprot.skip(ftype)
13843 
      else:
13844 
        iprot.skip(ftype)
13845 
      iprot.readFieldEnd()
13846 
    iprot.readStructEnd()
13847 
 
13848 
  def write(self, oprot):
13849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13851 
      return
13852 
    oprot.writeStructBegin('searchItemsInRange_result')
13853 
    if self.success is not None:
13854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13855 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13856 
      for iter264 in self.success:
13857 
        iter264.write(oprot)
5944 mandeep.dh 13858 
      oprot.writeListEnd()
13859 
      oprot.writeFieldEnd()
13860 
    oprot.writeFieldStop()
13861 
    oprot.writeStructEnd()
13862 
 
13863 
  def validate(self):
13864 
    return
13865 
 
13866 
 
13867 
  def __repr__(self):
13868 
    L = ['%s=%r' % (key, value)
13869 
      for key, value in self.__dict__.iteritems()]
13870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13871 
 
13872 
  def __eq__(self, other):
13873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13874 
 
13875 
  def __ne__(self, other):
13876 
    return not (self == other)
13877 
 
13878 
class getSearchResultCount_args:
13879 
  """
13880 
  Attributes:
13881 
   - searchTerms
13882 
  """
13883 
 
13884 
  thrift_spec = (
13885 
    None, # 0
13886 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13887 
  )
13888 
 
13889 
  def __init__(self, searchTerms=None,):
13890 
    self.searchTerms = searchTerms
13891 
 
13892 
  def read(self, iprot):
13893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13895 
      return
13896 
    iprot.readStructBegin()
13897 
    while True:
13898 
      (fname, ftype, fid) = iprot.readFieldBegin()
13899 
      if ftype == TType.STOP:
13900 
        break
13901 
      if fid == 1:
13902 
        if ftype == TType.LIST:
13903 
          self.searchTerms = []
7438 amit.gupta 13904 
          (_etype268, _size265) = iprot.readListBegin()
13905 
          for _i269 in xrange(_size265):
13906 
            _elem270 = iprot.readString();
13907 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 13908 
          iprot.readListEnd()
13909 
        else:
13910 
          iprot.skip(ftype)
13911 
      else:
13912 
        iprot.skip(ftype)
13913 
      iprot.readFieldEnd()
13914 
    iprot.readStructEnd()
13915 
 
13916 
  def write(self, oprot):
13917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13919 
      return
13920 
    oprot.writeStructBegin('getSearchResultCount_args')
13921 
    if self.searchTerms is not None:
13922 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13923 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13924 
      for iter271 in self.searchTerms:
13925 
        oprot.writeString(iter271)
5944 mandeep.dh 13926 
      oprot.writeListEnd()
13927 
      oprot.writeFieldEnd()
13928 
    oprot.writeFieldStop()
13929 
    oprot.writeStructEnd()
13930 
 
13931 
  def validate(self):
13932 
    return
13933 
 
13934 
 
13935 
  def __repr__(self):
13936 
    L = ['%s=%r' % (key, value)
13937 
      for key, value in self.__dict__.iteritems()]
13938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13939 
 
13940 
  def __eq__(self, other):
13941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13942 
 
13943 
  def __ne__(self, other):
13944 
    return not (self == other)
13945 
 
13946 
class getSearchResultCount_result:
13947 
  """
13948 
  Attributes:
13949 
   - success
13950 
  """
13951 
 
13952 
  thrift_spec = (
13953 
    (0, TType.I32, 'success', None, None, ), # 0
13954 
  )
13955 
 
13956 
  def __init__(self, success=None,):
13957 
    self.success = success
13958 
 
13959 
  def read(self, iprot):
13960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13962 
      return
13963 
    iprot.readStructBegin()
13964 
    while True:
13965 
      (fname, ftype, fid) = iprot.readFieldBegin()
13966 
      if ftype == TType.STOP:
13967 
        break
13968 
      if fid == 0:
13969 
        if ftype == TType.I32:
13970 
          self.success = iprot.readI32();
13971 
        else:
13972 
          iprot.skip(ftype)
13973 
      else:
13974 
        iprot.skip(ftype)
13975 
      iprot.readFieldEnd()
13976 
    iprot.readStructEnd()
13977 
 
13978 
  def write(self, oprot):
13979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13981 
      return
13982 
    oprot.writeStructBegin('getSearchResultCount_result')
13983 
    if self.success is not None:
13984 
      oprot.writeFieldBegin('success', TType.I32, 0)
13985 
      oprot.writeI32(self.success)
13986 
      oprot.writeFieldEnd()
13987 
    oprot.writeFieldStop()
13988 
    oprot.writeStructEnd()
13989 
 
13990 
  def validate(self):
13991 
    return
13992 
 
13993 
 
13994 
  def __repr__(self):
13995 
    L = ['%s=%r' % (key, value)
13996 
      for key, value in self.__dict__.iteritems()]
13997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13998 
 
13999 
  def __eq__(self, other):
14000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14001 
 
14002 
  def __ne__(self, other):
14003 
    return not (self == other)
14004 
 
14005 
class getProductNotifications_args:
14006 
  """
14007 
  Attributes:
14008 
   - startDateTime
14009 
  """
14010 
 
14011 
  thrift_spec = (
14012 
    None, # 0
14013 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14014 
  )
14015 
 
14016 
  def __init__(self, startDateTime=None,):
14017 
    self.startDateTime = startDateTime
14018 
 
14019 
  def read(self, iprot):
14020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14022 
      return
14023 
    iprot.readStructBegin()
14024 
    while True:
14025 
      (fname, ftype, fid) = iprot.readFieldBegin()
14026 
      if ftype == TType.STOP:
14027 
        break
14028 
      if fid == 1:
14029 
        if ftype == TType.I64:
14030 
          self.startDateTime = iprot.readI64();
14031 
        else:
14032 
          iprot.skip(ftype)
14033 
      else:
14034 
        iprot.skip(ftype)
14035 
      iprot.readFieldEnd()
14036 
    iprot.readStructEnd()
14037 
 
14038 
  def write(self, oprot):
14039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14041 
      return
14042 
    oprot.writeStructBegin('getProductNotifications_args')
14043 
    if self.startDateTime is not None:
14044 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14045 
      oprot.writeI64(self.startDateTime)
14046 
      oprot.writeFieldEnd()
14047 
    oprot.writeFieldStop()
14048 
    oprot.writeStructEnd()
14049 
 
14050 
  def validate(self):
14051 
    return
14052 
 
14053 
 
14054 
  def __repr__(self):
14055 
    L = ['%s=%r' % (key, value)
14056 
      for key, value in self.__dict__.iteritems()]
14057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14058 
 
14059 
  def __eq__(self, other):
14060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14061 
 
14062 
  def __ne__(self, other):
14063 
    return not (self == other)
14064 
 
14065 
class getProductNotifications_result:
14066 
  """
14067 
  Attributes:
14068 
   - success
14069 
  """
14070 
 
14071 
  thrift_spec = (
14072 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14073 
  )
14074 
 
14075 
  def __init__(self, success=None,):
14076 
    self.success = success
14077 
 
14078 
  def read(self, iprot):
14079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14081 
      return
14082 
    iprot.readStructBegin()
14083 
    while True:
14084 
      (fname, ftype, fid) = iprot.readFieldBegin()
14085 
      if ftype == TType.STOP:
14086 
        break
14087 
      if fid == 0:
14088 
        if ftype == TType.LIST:
14089 
          self.success = []
7438 amit.gupta 14090 
          (_etype275, _size272) = iprot.readListBegin()
14091 
          for _i276 in xrange(_size272):
14092 
            _elem277 = ProductNotificationRequest()
14093 
            _elem277.read(iprot)
14094 
            self.success.append(_elem277)
5944 mandeep.dh 14095 
          iprot.readListEnd()
14096 
        else:
14097 
          iprot.skip(ftype)
14098 
      else:
14099 
        iprot.skip(ftype)
14100 
      iprot.readFieldEnd()
14101 
    iprot.readStructEnd()
14102 
 
14103 
  def write(self, oprot):
14104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14106 
      return
14107 
    oprot.writeStructBegin('getProductNotifications_result')
14108 
    if self.success is not None:
14109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14110 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14111 
      for iter278 in self.success:
14112 
        iter278.write(oprot)
5944 mandeep.dh 14113 
      oprot.writeListEnd()
14114 
      oprot.writeFieldEnd()
14115 
    oprot.writeFieldStop()
14116 
    oprot.writeStructEnd()
14117 
 
14118 
  def validate(self):
14119 
    return
14120 
 
14121 
 
14122 
  def __repr__(self):
14123 
    L = ['%s=%r' % (key, value)
14124 
      for key, value in self.__dict__.iteritems()]
14125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14126 
 
14127 
  def __eq__(self, other):
14128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14129 
 
14130 
  def __ne__(self, other):
14131 
    return not (self == other)
14132 
 
14133 
class getProductNotificationRequestCount_args:
14134 
  """
14135 
  Attributes:
14136 
   - startDateTime
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    None, # 0
14141 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14142 
  )
14143 
 
14144 
  def __init__(self, startDateTime=None,):
14145 
    self.startDateTime = startDateTime
14146 
 
14147 
  def read(self, iprot):
14148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14150 
      return
14151 
    iprot.readStructBegin()
14152 
    while True:
14153 
      (fname, ftype, fid) = iprot.readFieldBegin()
14154 
      if ftype == TType.STOP:
14155 
        break
14156 
      if fid == 1:
14157 
        if ftype == TType.I64:
14158 
          self.startDateTime = iprot.readI64();
14159 
        else:
14160 
          iprot.skip(ftype)
14161 
      else:
14162 
        iprot.skip(ftype)
14163 
      iprot.readFieldEnd()
14164 
    iprot.readStructEnd()
14165 
 
14166 
  def write(self, oprot):
14167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14169 
      return
14170 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14171 
    if self.startDateTime is not None:
14172 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14173 
      oprot.writeI64(self.startDateTime)
14174 
      oprot.writeFieldEnd()
14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
14193 
class getProductNotificationRequestCount_result:
14194 
  """
14195 
  Attributes:
14196 
   - success
14197 
  """
14198 
 
14199 
  thrift_spec = (
14200 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14201 
  )
14202 
 
14203 
  def __init__(self, success=None,):
14204 
    self.success = success
14205 
 
14206 
  def read(self, iprot):
14207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14209 
      return
14210 
    iprot.readStructBegin()
14211 
    while True:
14212 
      (fname, ftype, fid) = iprot.readFieldBegin()
14213 
      if ftype == TType.STOP:
14214 
        break
14215 
      if fid == 0:
14216 
        if ftype == TType.LIST:
14217 
          self.success = []
7438 amit.gupta 14218 
          (_etype282, _size279) = iprot.readListBegin()
14219 
          for _i283 in xrange(_size279):
14220 
            _elem284 = ProductNotificationRequestCount()
14221 
            _elem284.read(iprot)
14222 
            self.success.append(_elem284)
5944 mandeep.dh 14223 
          iprot.readListEnd()
14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      else:
14227 
        iprot.skip(ftype)
14228 
      iprot.readFieldEnd()
14229 
    iprot.readStructEnd()
14230 
 
14231 
  def write(self, oprot):
14232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14234 
      return
14235 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14236 
    if self.success is not None:
14237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14238 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14239 
      for iter285 in self.success:
14240 
        iter285.write(oprot)
5944 mandeep.dh 14241 
      oprot.writeListEnd()
14242 
      oprot.writeFieldEnd()
14243 
    oprot.writeFieldStop()
14244 
    oprot.writeStructEnd()
14245 
 
14246 
  def validate(self):
14247 
    return
14248 
 
14249 
 
14250 
  def __repr__(self):
14251 
    L = ['%s=%r' % (key, value)
14252 
      for key, value in self.__dict__.iteritems()]
14253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14254 
 
14255 
  def __eq__(self, other):
14256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14257 
 
14258 
  def __ne__(self, other):
14259 
    return not (self == other)
14260 
 
14261 
class addAuthorizationLog_args:
14262 
  """
14263 
  Attributes:
14264 
   - itemId
14265 
   - username
14266 
   - reason
14267 
  """
14268 
 
14269 
  thrift_spec = (
14270 
    None, # 0
14271 
    (1, TType.I64, 'itemId', None, None, ), # 1
14272 
    (2, TType.STRING, 'username', None, None, ), # 2
14273 
    (3, TType.STRING, 'reason', None, None, ), # 3
14274 
  )
14275 
 
14276 
  def __init__(self, itemId=None, username=None, reason=None,):
14277 
    self.itemId = itemId
14278 
    self.username = username
14279 
    self.reason = reason
14280 
 
14281 
  def read(self, iprot):
14282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14284 
      return
14285 
    iprot.readStructBegin()
14286 
    while True:
14287 
      (fname, ftype, fid) = iprot.readFieldBegin()
14288 
      if ftype == TType.STOP:
14289 
        break
14290 
      if fid == 1:
14291 
        if ftype == TType.I64:
14292 
          self.itemId = iprot.readI64();
14293 
        else:
14294 
          iprot.skip(ftype)
14295 
      elif fid == 2:
14296 
        if ftype == TType.STRING:
14297 
          self.username = iprot.readString();
14298 
        else:
14299 
          iprot.skip(ftype)
14300 
      elif fid == 3:
14301 
        if ftype == TType.STRING:
14302 
          self.reason = iprot.readString();
14303 
        else:
14304 
          iprot.skip(ftype)
14305 
      else:
14306 
        iprot.skip(ftype)
14307 
      iprot.readFieldEnd()
14308 
    iprot.readStructEnd()
14309 
 
14310 
  def write(self, oprot):
14311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14313 
      return
14314 
    oprot.writeStructBegin('addAuthorizationLog_args')
14315 
    if self.itemId is not None:
14316 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14317 
      oprot.writeI64(self.itemId)
14318 
      oprot.writeFieldEnd()
14319 
    if self.username is not None:
14320 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14321 
      oprot.writeString(self.username)
14322 
      oprot.writeFieldEnd()
14323 
    if self.reason is not None:
14324 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14325 
      oprot.writeString(self.reason)
14326 
      oprot.writeFieldEnd()
14327 
    oprot.writeFieldStop()
14328 
    oprot.writeStructEnd()
14329 
 
14330 
  def validate(self):
14331 
    return
14332 
 
14333 
 
14334 
  def __repr__(self):
14335 
    L = ['%s=%r' % (key, value)
14336 
      for key, value in self.__dict__.iteritems()]
14337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14338 
 
14339 
  def __eq__(self, other):
14340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14341 
 
14342 
  def __ne__(self, other):
14343 
    return not (self == other)
14344 
 
14345 
class addAuthorizationLog_result:
14346 
  """
14347 
  Attributes:
14348 
   - success
14349 
   - cex
14350 
  """
14351 
 
14352 
  thrift_spec = (
14353 
    (0, TType.BOOL, 'success', None, None, ), # 0
14354 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14355 
  )
14356 
 
14357 
  def __init__(self, success=None, cex=None,):
14358 
    self.success = success
14359 
    self.cex = cex
14360 
 
14361 
  def read(self, iprot):
14362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14364 
      return
14365 
    iprot.readStructBegin()
14366 
    while True:
14367 
      (fname, ftype, fid) = iprot.readFieldBegin()
14368 
      if ftype == TType.STOP:
14369 
        break
14370 
      if fid == 0:
14371 
        if ftype == TType.BOOL:
14372 
          self.success = iprot.readBool();
14373 
        else:
14374 
          iprot.skip(ftype)
14375 
      elif fid == 1:
14376 
        if ftype == TType.STRUCT:
14377 
          self.cex = CatalogServiceException()
14378 
          self.cex.read(iprot)
14379 
        else:
14380 
          iprot.skip(ftype)
14381 
      else:
14382 
        iprot.skip(ftype)
14383 
      iprot.readFieldEnd()
14384 
    iprot.readStructEnd()
14385 
 
14386 
  def write(self, oprot):
14387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14389 
      return
14390 
    oprot.writeStructBegin('addAuthorizationLog_result')
14391 
    if self.success is not None:
14392 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14393 
      oprot.writeBool(self.success)
14394 
      oprot.writeFieldEnd()
14395 
    if self.cex is not None:
14396 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14397 
      self.cex.write(oprot)
14398 
      oprot.writeFieldEnd()
14399 
    oprot.writeFieldStop()
14400 
    oprot.writeStructEnd()
14401 
 
14402 
  def validate(self):
14403 
    return
14404 
 
14405 
 
14406 
  def __repr__(self):
14407 
    L = ['%s=%r' % (key, value)
14408 
      for key, value in self.__dict__.iteritems()]
14409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14410 
 
14411 
  def __eq__(self, other):
14412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14413 
 
14414 
  def __ne__(self, other):
14415 
    return not (self == other)
14416 
 
14417 
class addupdateVoucherForItem_args:
14418 
  """
14419 
  Attributes:
14420 
   - catalog_item_id
14421 
   - voucherType
14422 
   - voucherAmount
14423 
  """
14424 
 
14425 
  thrift_spec = (
14426 
    None, # 0
14427 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14428 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14429 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14430 
  )
14431 
 
14432 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14433 
    self.catalog_item_id = catalog_item_id
14434 
    self.voucherType = voucherType
14435 
    self.voucherAmount = voucherAmount
14436 
 
14437 
  def read(self, iprot):
14438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14440 
      return
14441 
    iprot.readStructBegin()
14442 
    while True:
14443 
      (fname, ftype, fid) = iprot.readFieldBegin()
14444 
      if ftype == TType.STOP:
14445 
        break
14446 
      if fid == 1:
14447 
        if ftype == TType.I64:
14448 
          self.catalog_item_id = iprot.readI64();
14449 
        else:
14450 
          iprot.skip(ftype)
14451 
      elif fid == 2:
14452 
        if ftype == TType.I64:
14453 
          self.voucherType = iprot.readI64();
14454 
        else:
14455 
          iprot.skip(ftype)
14456 
      elif fid == 3:
14457 
        if ftype == TType.I64:
14458 
          self.voucherAmount = iprot.readI64();
14459 
        else:
14460 
          iprot.skip(ftype)
14461 
      else:
14462 
        iprot.skip(ftype)
14463 
      iprot.readFieldEnd()
14464 
    iprot.readStructEnd()
14465 
 
14466 
  def write(self, oprot):
14467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14469 
      return
14470 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14471 
    if self.catalog_item_id is not None:
14472 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14473 
      oprot.writeI64(self.catalog_item_id)
14474 
      oprot.writeFieldEnd()
14475 
    if self.voucherType is not None:
14476 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14477 
      oprot.writeI64(self.voucherType)
14478 
      oprot.writeFieldEnd()
14479 
    if self.voucherAmount is not None:
14480 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14481 
      oprot.writeI64(self.voucherAmount)
14482 
      oprot.writeFieldEnd()
14483 
    oprot.writeFieldStop()
14484 
    oprot.writeStructEnd()
14485 
 
14486 
  def validate(self):
14487 
    return
14488 
 
14489 
 
14490 
  def __repr__(self):
14491 
    L = ['%s=%r' % (key, value)
14492 
      for key, value in self.__dict__.iteritems()]
14493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14494 
 
14495 
  def __eq__(self, other):
14496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14497 
 
14498 
  def __ne__(self, other):
14499 
    return not (self == other)
14500 
 
14501 
class addupdateVoucherForItem_result:
14502 
  """
14503 
  Attributes:
14504 
   - success
14505 
   - cex
14506 
  """
14507 
 
14508 
  thrift_spec = (
14509 
    (0, TType.BOOL, 'success', None, None, ), # 0
14510 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14511 
  )
14512 
 
14513 
  def __init__(self, success=None, cex=None,):
14514 
    self.success = success
14515 
    self.cex = cex
14516 
 
14517 
  def read(self, iprot):
14518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14520 
      return
14521 
    iprot.readStructBegin()
14522 
    while True:
14523 
      (fname, ftype, fid) = iprot.readFieldBegin()
14524 
      if ftype == TType.STOP:
14525 
        break
14526 
      if fid == 0:
14527 
        if ftype == TType.BOOL:
14528 
          self.success = iprot.readBool();
14529 
        else:
14530 
          iprot.skip(ftype)
14531 
      elif fid == 1:
14532 
        if ftype == TType.STRUCT:
14533 
          self.cex = CatalogServiceException()
14534 
          self.cex.read(iprot)
14535 
        else:
14536 
          iprot.skip(ftype)
14537 
      else:
14538 
        iprot.skip(ftype)
14539 
      iprot.readFieldEnd()
14540 
    iprot.readStructEnd()
14541 
 
14542 
  def write(self, oprot):
14543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14545 
      return
14546 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14547 
    if self.success is not None:
14548 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14549 
      oprot.writeBool(self.success)
14550 
      oprot.writeFieldEnd()
14551 
    if self.cex is not None:
14552 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14553 
      self.cex.write(oprot)
14554 
      oprot.writeFieldEnd()
14555 
    oprot.writeFieldStop()
14556 
    oprot.writeStructEnd()
14557 
 
14558 
  def validate(self):
14559 
    return
14560 
 
14561 
 
14562 
  def __repr__(self):
14563 
    L = ['%s=%r' % (key, value)
14564 
      for key, value in self.__dict__.iteritems()]
14565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14566 
 
14567 
  def __eq__(self, other):
14568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14569 
 
14570 
  def __ne__(self, other):
14571 
    return not (self == other)
14572 
 
14573 
class deleteVoucherForItem_args:
14574 
  """
14575 
  Attributes:
14576 
   - catalog_item_id
14577 
   - voucherType
14578 
  """
14579 
 
14580 
  thrift_spec = (
14581 
    None, # 0
14582 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14583 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14584 
  )
14585 
 
14586 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14587 
    self.catalog_item_id = catalog_item_id
14588 
    self.voucherType = voucherType
14589 
 
14590 
  def read(self, iprot):
14591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14593 
      return
14594 
    iprot.readStructBegin()
14595 
    while True:
14596 
      (fname, ftype, fid) = iprot.readFieldBegin()
14597 
      if ftype == TType.STOP:
14598 
        break
14599 
      if fid == 1:
14600 
        if ftype == TType.I64:
14601 
          self.catalog_item_id = iprot.readI64();
14602 
        else:
14603 
          iprot.skip(ftype)
14604 
      elif fid == 2:
14605 
        if ftype == TType.I64:
14606 
          self.voucherType = iprot.readI64();
14607 
        else:
14608 
          iprot.skip(ftype)
14609 
      else:
14610 
        iprot.skip(ftype)
14611 
      iprot.readFieldEnd()
14612 
    iprot.readStructEnd()
14613 
 
14614 
  def write(self, oprot):
14615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14617 
      return
14618 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14619 
    if self.catalog_item_id is not None:
14620 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14621 
      oprot.writeI64(self.catalog_item_id)
14622 
      oprot.writeFieldEnd()
14623 
    if self.voucherType is not None:
14624 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14625 
      oprot.writeI64(self.voucherType)
14626 
      oprot.writeFieldEnd()
14627 
    oprot.writeFieldStop()
14628 
    oprot.writeStructEnd()
14629 
 
14630 
  def validate(self):
14631 
    return
14632 
 
14633 
 
14634 
  def __repr__(self):
14635 
    L = ['%s=%r' % (key, value)
14636 
      for key, value in self.__dict__.iteritems()]
14637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14638 
 
14639 
  def __eq__(self, other):
14640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14641 
 
14642 
  def __ne__(self, other):
14643 
    return not (self == other)
14644 
 
14645 
class deleteVoucherForItem_result:
14646 
  """
14647 
  Attributes:
14648 
   - success
14649 
   - cex
14650 
  """
14651 
 
14652 
  thrift_spec = (
14653 
    (0, TType.BOOL, 'success', None, None, ), # 0
14654 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14655 
  )
14656 
 
14657 
  def __init__(self, success=None, cex=None,):
14658 
    self.success = success
14659 
    self.cex = cex
14660 
 
14661 
  def read(self, iprot):
14662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14664 
      return
14665 
    iprot.readStructBegin()
14666 
    while True:
14667 
      (fname, ftype, fid) = iprot.readFieldBegin()
14668 
      if ftype == TType.STOP:
14669 
        break
14670 
      if fid == 0:
14671 
        if ftype == TType.BOOL:
14672 
          self.success = iprot.readBool();
14673 
        else:
14674 
          iprot.skip(ftype)
14675 
      elif fid == 1:
14676 
        if ftype == TType.STRUCT:
14677 
          self.cex = CatalogServiceException()
14678 
          self.cex.read(iprot)
14679 
        else:
14680 
          iprot.skip(ftype)
14681 
      else:
14682 
        iprot.skip(ftype)
14683 
      iprot.readFieldEnd()
14684 
    iprot.readStructEnd()
14685 
 
14686 
  def write(self, oprot):
14687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14689 
      return
14690 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14691 
    if self.success is not None:
14692 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14693 
      oprot.writeBool(self.success)
14694 
      oprot.writeFieldEnd()
14695 
    if self.cex is not None:
14696 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14697 
      self.cex.write(oprot)
14698 
      oprot.writeFieldEnd()
14699 
    oprot.writeFieldStop()
14700 
    oprot.writeStructEnd()
14701 
 
14702 
  def validate(self):
14703 
    return
14704 
 
14705 
 
14706 
  def __repr__(self):
14707 
    L = ['%s=%r' % (key, value)
14708 
      for key, value in self.__dict__.iteritems()]
14709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14710 
 
14711 
  def __eq__(self, other):
14712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14713 
 
14714 
  def __ne__(self, other):
14715 
    return not (self == other)
14716 
 
14717 
class getVoucherAmount_args:
14718 
  """
14719 
  Attributes:
14720 
   - itemId
14721 
   - voucherType
14722 
  """
14723 
 
14724 
  thrift_spec = (
14725 
    None, # 0
14726 
    (1, TType.I64, 'itemId', None, None, ), # 1
14727 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14728 
  )
14729 
 
14730 
  def __init__(self, itemId=None, voucherType=None,):
14731 
    self.itemId = itemId
14732 
    self.voucherType = voucherType
14733 
 
14734 
  def read(self, iprot):
14735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14737 
      return
14738 
    iprot.readStructBegin()
14739 
    while True:
14740 
      (fname, ftype, fid) = iprot.readFieldBegin()
14741 
      if ftype == TType.STOP:
14742 
        break
14743 
      if fid == 1:
14744 
        if ftype == TType.I64:
14745 
          self.itemId = iprot.readI64();
14746 
        else:
14747 
          iprot.skip(ftype)
14748 
      elif fid == 2:
14749 
        if ftype == TType.I64:
14750 
          self.voucherType = iprot.readI64();
14751 
        else:
14752 
          iprot.skip(ftype)
14753 
      else:
14754 
        iprot.skip(ftype)
14755 
      iprot.readFieldEnd()
14756 
    iprot.readStructEnd()
14757 
 
14758 
  def write(self, oprot):
14759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14761 
      return
14762 
    oprot.writeStructBegin('getVoucherAmount_args')
14763 
    if self.itemId is not None:
14764 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14765 
      oprot.writeI64(self.itemId)
14766 
      oprot.writeFieldEnd()
14767 
    if self.voucherType is not None:
14768 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14769 
      oprot.writeI64(self.voucherType)
14770 
      oprot.writeFieldEnd()
14771 
    oprot.writeFieldStop()
14772 
    oprot.writeStructEnd()
14773 
 
14774 
  def validate(self):
14775 
    return
14776 
 
14777 
 
14778 
  def __repr__(self):
14779 
    L = ['%s=%r' % (key, value)
14780 
      for key, value in self.__dict__.iteritems()]
14781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14782 
 
14783 
  def __eq__(self, other):
14784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14785 
 
14786 
  def __ne__(self, other):
14787 
    return not (self == other)
14788 
 
14789 
class getVoucherAmount_result:
14790 
  """
14791 
  Attributes:
14792 
   - success
14793 
  """
14794 
 
14795 
  thrift_spec = (
14796 
    (0, TType.I64, 'success', None, None, ), # 0
14797 
  )
14798 
 
14799 
  def __init__(self, success=None,):
14800 
    self.success = success
14801 
 
14802 
  def read(self, iprot):
14803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14805 
      return
14806 
    iprot.readStructBegin()
14807 
    while True:
14808 
      (fname, ftype, fid) = iprot.readFieldBegin()
14809 
      if ftype == TType.STOP:
14810 
        break
14811 
      if fid == 0:
14812 
        if ftype == TType.I64:
14813 
          self.success = iprot.readI64();
14814 
        else:
14815 
          iprot.skip(ftype)
14816 
      else:
14817 
        iprot.skip(ftype)
14818 
      iprot.readFieldEnd()
14819 
    iprot.readStructEnd()
14820 
 
14821 
  def write(self, oprot):
14822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14824 
      return
14825 
    oprot.writeStructBegin('getVoucherAmount_result')
14826 
    if self.success is not None:
14827 
      oprot.writeFieldBegin('success', TType.I64, 0)
14828 
      oprot.writeI64(self.success)
14829 
      oprot.writeFieldEnd()
14830 
    oprot.writeFieldStop()
14831 
    oprot.writeStructEnd()
14832 
 
14833 
  def validate(self):
14834 
    return
14835 
 
14836 
 
14837 
  def __repr__(self):
14838 
    L = ['%s=%r' % (key, value)
14839 
      for key, value in self.__dict__.iteritems()]
14840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14841 
 
14842 
  def __eq__(self, other):
14843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14844 
 
14845 
  def __ne__(self, other):
14846 
    return not (self == other)
14847 
 
14848 
class getAllItemVouchers_args:
14849 
  """
14850 
  Attributes:
14851 
   - itemId
14852 
  """
14853 
 
14854 
  thrift_spec = (
14855 
    None, # 0
14856 
    (1, TType.I64, 'itemId', None, None, ), # 1
14857 
  )
14858 
 
14859 
  def __init__(self, itemId=None,):
14860 
    self.itemId = itemId
14861 
 
14862 
  def read(self, iprot):
14863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14865 
      return
14866 
    iprot.readStructBegin()
14867 
    while True:
14868 
      (fname, ftype, fid) = iprot.readFieldBegin()
14869 
      if ftype == TType.STOP:
14870 
        break
14871 
      if fid == 1:
14872 
        if ftype == TType.I64:
14873 
          self.itemId = iprot.readI64();
14874 
        else:
14875 
          iprot.skip(ftype)
14876 
      else:
14877 
        iprot.skip(ftype)
14878 
      iprot.readFieldEnd()
14879 
    iprot.readStructEnd()
14880 
 
14881 
  def write(self, oprot):
14882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14884 
      return
14885 
    oprot.writeStructBegin('getAllItemVouchers_args')
14886 
    if self.itemId is not None:
14887 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14888 
      oprot.writeI64(self.itemId)
14889 
      oprot.writeFieldEnd()
14890 
    oprot.writeFieldStop()
14891 
    oprot.writeStructEnd()
14892 
 
14893 
  def validate(self):
14894 
    return
14895 
 
14896 
 
14897 
  def __repr__(self):
14898 
    L = ['%s=%r' % (key, value)
14899 
      for key, value in self.__dict__.iteritems()]
14900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14901 
 
14902 
  def __eq__(self, other):
14903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14904 
 
14905 
  def __ne__(self, other):
14906 
    return not (self == other)
14907 
 
14908 
class getAllItemVouchers_result:
14909 
  """
14910 
  Attributes:
14911 
   - success
14912 
  """
14913 
 
14914 
  thrift_spec = (
14915 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14916 
  )
14917 
 
14918 
  def __init__(self, success=None,):
14919 
    self.success = success
14920 
 
14921 
  def read(self, iprot):
14922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14924 
      return
14925 
    iprot.readStructBegin()
14926 
    while True:
14927 
      (fname, ftype, fid) = iprot.readFieldBegin()
14928 
      if ftype == TType.STOP:
14929 
        break
14930 
      if fid == 0:
14931 
        if ftype == TType.LIST:
14932 
          self.success = []
7438 amit.gupta 14933 
          (_etype289, _size286) = iprot.readListBegin()
14934 
          for _i290 in xrange(_size286):
14935 
            _elem291 = VoucherItemMapping()
14936 
            _elem291.read(iprot)
14937 
            self.success.append(_elem291)
5944 mandeep.dh 14938 
          iprot.readListEnd()
14939 
        else:
14940 
          iprot.skip(ftype)
14941 
      else:
14942 
        iprot.skip(ftype)
14943 
      iprot.readFieldEnd()
14944 
    iprot.readStructEnd()
14945 
 
14946 
  def write(self, oprot):
14947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14949 
      return
14950 
    oprot.writeStructBegin('getAllItemVouchers_result')
14951 
    if self.success is not None:
14952 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14953 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14954 
      for iter292 in self.success:
14955 
        iter292.write(oprot)
5944 mandeep.dh 14956 
      oprot.writeListEnd()
14957 
      oprot.writeFieldEnd()
14958 
    oprot.writeFieldStop()
14959 
    oprot.writeStructEnd()
14960 
 
14961 
  def validate(self):
14962 
    return
14963 
 
14964 
 
14965 
  def __repr__(self):
14966 
    L = ['%s=%r' % (key, value)
14967 
      for key, value in self.__dict__.iteritems()]
14968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14969 
 
14970 
  def __eq__(self, other):
14971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14972 
 
14973 
  def __ne__(self, other):
14974 
    return not (self == other)
14975 
 
14976 
class isValidCatalogItemId_args:
14977 
  """
14978 
  Attributes:
14979 
   - catalog_item_id
14980 
  """
14981 
 
14982 
  thrift_spec = (
14983 
    None, # 0
14984 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14985 
  )
14986 
 
14987 
  def __init__(self, catalog_item_id=None,):
14988 
    self.catalog_item_id = catalog_item_id
14989 
 
14990 
  def read(self, iprot):
14991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14993 
      return
14994 
    iprot.readStructBegin()
14995 
    while True:
14996 
      (fname, ftype, fid) = iprot.readFieldBegin()
14997 
      if ftype == TType.STOP:
14998 
        break
14999 
      if fid == 1:
15000 
        if ftype == TType.I64:
15001 
          self.catalog_item_id = iprot.readI64();
15002 
        else:
15003 
          iprot.skip(ftype)
15004 
      else:
15005 
        iprot.skip(ftype)
15006 
      iprot.readFieldEnd()
15007 
    iprot.readStructEnd()
15008 
 
15009 
  def write(self, oprot):
15010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15012 
      return
15013 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15014 
    if self.catalog_item_id is not None:
15015 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15016 
      oprot.writeI64(self.catalog_item_id)
15017 
      oprot.writeFieldEnd()
15018 
    oprot.writeFieldStop()
15019 
    oprot.writeStructEnd()
15020 
 
15021 
  def validate(self):
15022 
    return
15023 
 
15024 
 
15025 
  def __repr__(self):
15026 
    L = ['%s=%r' % (key, value)
15027 
      for key, value in self.__dict__.iteritems()]
15028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15029 
 
15030 
  def __eq__(self, other):
15031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15032 
 
15033 
  def __ne__(self, other):
15034 
    return not (self == other)
15035 
 
15036 
class isValidCatalogItemId_result:
15037 
  """
15038 
  Attributes:
15039 
   - success
15040 
  """
15041 
 
15042 
  thrift_spec = (
15043 
    (0, TType.BOOL, 'success', None, None, ), # 0
15044 
  )
15045 
 
15046 
  def __init__(self, success=None,):
15047 
    self.success = success
15048 
 
15049 
  def read(self, iprot):
15050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15052 
      return
15053 
    iprot.readStructBegin()
15054 
    while True:
15055 
      (fname, ftype, fid) = iprot.readFieldBegin()
15056 
      if ftype == TType.STOP:
15057 
        break
15058 
      if fid == 0:
15059 
        if ftype == TType.BOOL:
15060 
          self.success = iprot.readBool();
15061 
        else:
15062 
          iprot.skip(ftype)
15063 
      else:
15064 
        iprot.skip(ftype)
15065 
      iprot.readFieldEnd()
15066 
    iprot.readStructEnd()
15067 
 
15068 
  def write(self, oprot):
15069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15071 
      return
15072 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15073 
    if self.success is not None:
15074 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15075 
      oprot.writeBool(self.success)
15076 
      oprot.writeFieldEnd()
15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
6039 amit.gupta 15094 
 
15095 
class getVatPercentageForItem_args:
15096 
  """
15097 
  Attributes:
15098 
   - itemId
7330 amit.gupta 15099 
   - stateId
6039 amit.gupta 15100 
   - price
15101 
  """
15102 
 
15103 
  thrift_spec = (
15104 
    None, # 0
15105 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15106 
    (2, TType.I64, 'stateId', None, None, ), # 2
15107 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15108 
  )
15109 
 
7330 amit.gupta 15110 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15111 
    self.itemId = itemId
7330 amit.gupta 15112 
    self.stateId = stateId
6039 amit.gupta 15113 
    self.price = price
15114 
 
15115 
  def read(self, iprot):
15116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15118 
      return
15119 
    iprot.readStructBegin()
15120 
    while True:
15121 
      (fname, ftype, fid) = iprot.readFieldBegin()
15122 
      if ftype == TType.STOP:
15123 
        break
15124 
      if fid == 1:
15125 
        if ftype == TType.I64:
15126 
          self.itemId = iprot.readI64();
15127 
        else:
15128 
          iprot.skip(ftype)
15129 
      elif fid == 2:
7330 amit.gupta 15130 
        if ftype == TType.I64:
15131 
          self.stateId = iprot.readI64();
15132 
        else:
15133 
          iprot.skip(ftype)
15134 
      elif fid == 3:
6039 amit.gupta 15135 
        if ftype == TType.DOUBLE:
15136 
          self.price = iprot.readDouble();
15137 
        else:
15138 
          iprot.skip(ftype)
15139 
      else:
15140 
        iprot.skip(ftype)
15141 
      iprot.readFieldEnd()
15142 
    iprot.readStructEnd()
15143 
 
15144 
  def write(self, oprot):
15145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15147 
      return
15148 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15149 
    if self.itemId is not None:
15150 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15151 
      oprot.writeI64(self.itemId)
15152 
      oprot.writeFieldEnd()
7330 amit.gupta 15153 
    if self.stateId is not None:
15154 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15155 
      oprot.writeI64(self.stateId)
15156 
      oprot.writeFieldEnd()
6039 amit.gupta 15157 
    if self.price is not None:
7330 amit.gupta 15158 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15159 
      oprot.writeDouble(self.price)
15160 
      oprot.writeFieldEnd()
15161 
    oprot.writeFieldStop()
15162 
    oprot.writeStructEnd()
15163 
 
15164 
  def validate(self):
15165 
    return
15166 
 
15167 
 
15168 
  def __repr__(self):
15169 
    L = ['%s=%r' % (key, value)
15170 
      for key, value in self.__dict__.iteritems()]
15171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15172 
 
15173 
  def __eq__(self, other):
15174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15175 
 
15176 
  def __ne__(self, other):
15177 
    return not (self == other)
15178 
 
15179 
class getVatPercentageForItem_result:
15180 
  """
15181 
  Attributes:
15182 
   - success
7340 amit.gupta 15183 
   - cex
6039 amit.gupta 15184 
  """
15185 
 
15186 
  thrift_spec = (
15187 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15188 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15189 
  )
15190 
 
7340 amit.gupta 15191 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15192 
    self.success = success
7340 amit.gupta 15193 
    self.cex = cex
6039 amit.gupta 15194 
 
15195 
  def read(self, iprot):
15196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15198 
      return
15199 
    iprot.readStructBegin()
15200 
    while True:
15201 
      (fname, ftype, fid) = iprot.readFieldBegin()
15202 
      if ftype == TType.STOP:
15203 
        break
15204 
      if fid == 0:
15205 
        if ftype == TType.DOUBLE:
15206 
          self.success = iprot.readDouble();
15207 
        else:
15208 
          iprot.skip(ftype)
7340 amit.gupta 15209 
      elif fid == 1:
15210 
        if ftype == TType.STRUCT:
15211 
          self.cex = CatalogServiceException()
15212 
          self.cex.read(iprot)
15213 
        else:
15214 
          iprot.skip(ftype)
6039 amit.gupta 15215 
      else:
15216 
        iprot.skip(ftype)
15217 
      iprot.readFieldEnd()
15218 
    iprot.readStructEnd()
15219 
 
15220 
  def write(self, oprot):
15221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15223 
      return
15224 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15225 
    if self.success is not None:
15226 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15227 
      oprot.writeDouble(self.success)
15228 
      oprot.writeFieldEnd()
7340 amit.gupta 15229 
    if self.cex is not None:
15230 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15231 
      self.cex.write(oprot)
15232 
      oprot.writeFieldEnd()
6039 amit.gupta 15233 
    oprot.writeFieldStop()
15234 
    oprot.writeStructEnd()
15235 
 
15236 
  def validate(self):
15237 
    return
15238 
 
15239 
 
15240 
  def __repr__(self):
15241 
    L = ['%s=%r' % (key, value)
15242 
      for key, value in self.__dict__.iteritems()]
15243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15244 
 
15245 
  def __eq__(self, other):
15246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15247 
 
15248 
  def __ne__(self, other):
15249 
    return not (self == other)
15250 
 
15251 
class getVatAmountForItem_args:
15252 
  """
15253 
  Attributes:
15254 
   - itemId
15255 
   - price
15256 
  """
15257 
 
15258 
  thrift_spec = (
15259 
    None, # 0
15260 
    (1, TType.I64, 'itemId', None, None, ), # 1
15261 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15262 
  )
15263 
 
15264 
  def __init__(self, itemId=None, price=None,):
15265 
    self.itemId = itemId
15266 
    self.price = price
15267 
 
15268 
  def read(self, iprot):
15269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15271 
      return
15272 
    iprot.readStructBegin()
15273 
    while True:
15274 
      (fname, ftype, fid) = iprot.readFieldBegin()
15275 
      if ftype == TType.STOP:
15276 
        break
15277 
      if fid == 1:
15278 
        if ftype == TType.I64:
15279 
          self.itemId = iprot.readI64();
15280 
        else:
15281 
          iprot.skip(ftype)
15282 
      elif fid == 2:
15283 
        if ftype == TType.DOUBLE:
15284 
          self.price = iprot.readDouble();
15285 
        else:
15286 
          iprot.skip(ftype)
15287 
      else:
15288 
        iprot.skip(ftype)
15289 
      iprot.readFieldEnd()
15290 
    iprot.readStructEnd()
15291 
 
15292 
  def write(self, oprot):
15293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15295 
      return
15296 
    oprot.writeStructBegin('getVatAmountForItem_args')
15297 
    if self.itemId is not None:
15298 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15299 
      oprot.writeI64(self.itemId)
15300 
      oprot.writeFieldEnd()
15301 
    if self.price is not None:
15302 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15303 
      oprot.writeDouble(self.price)
15304 
      oprot.writeFieldEnd()
15305 
    oprot.writeFieldStop()
15306 
    oprot.writeStructEnd()
15307 
 
15308 
  def validate(self):
15309 
    return
15310 
 
15311 
 
15312 
  def __repr__(self):
15313 
    L = ['%s=%r' % (key, value)
15314 
      for key, value in self.__dict__.iteritems()]
15315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15316 
 
15317 
  def __eq__(self, other):
15318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15319 
 
15320 
  def __ne__(self, other):
15321 
    return not (self == other)
15322 
 
15323 
class getVatAmountForItem_result:
15324 
  """
15325 
  Attributes:
15326 
   - success
15327 
  """
15328 
 
15329 
  thrift_spec = (
15330 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15331 
  )
15332 
 
15333 
  def __init__(self, success=None,):
15334 
    self.success = success
15335 
 
15336 
  def read(self, iprot):
15337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15339 
      return
15340 
    iprot.readStructBegin()
15341 
    while True:
15342 
      (fname, ftype, fid) = iprot.readFieldBegin()
15343 
      if ftype == TType.STOP:
15344 
        break
15345 
      if fid == 0:
15346 
        if ftype == TType.DOUBLE:
15347 
          self.success = iprot.readDouble();
15348 
        else:
15349 
          iprot.skip(ftype)
15350 
      else:
15351 
        iprot.skip(ftype)
15352 
      iprot.readFieldEnd()
15353 
    iprot.readStructEnd()
15354 
 
15355 
  def write(self, oprot):
15356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15358 
      return
15359 
    oprot.writeStructBegin('getVatAmountForItem_result')
15360 
    if self.success is not None:
15361 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15362 
      oprot.writeDouble(self.success)
15363 
      oprot.writeFieldEnd()
15364 
    oprot.writeFieldStop()
15365 
    oprot.writeStructEnd()
15366 
 
15367 
  def validate(self):
15368 
    return
15369 
 
15370 
 
15371 
  def __repr__(self):
15372 
    L = ['%s=%r' % (key, value)
15373 
      for key, value in self.__dict__.iteritems()]
15374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15375 
 
15376 
  def __eq__(self, other):
15377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15378 
 
15379 
  def __ne__(self, other):
15380 
    return not (self == other)
6531 vikram.rag 15381 
 
15382 
class getAllIgnoredInventoryUpdateItemsList_args:
15383 
  """
15384 
  Attributes:
15385 
   - offset
15386 
   - limit
15387 
  """
15388 
 
15389 
  thrift_spec = (
15390 
    None, # 0
15391 
    (1, TType.I32, 'offset', None, None, ), # 1
15392 
    (2, TType.I32, 'limit', None, None, ), # 2
15393 
  )
15394 
 
15395 
  def __init__(self, offset=None, limit=None,):
15396 
    self.offset = offset
15397 
    self.limit = limit
15398 
 
15399 
  def read(self, iprot):
15400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15402 
      return
15403 
    iprot.readStructBegin()
15404 
    while True:
15405 
      (fname, ftype, fid) = iprot.readFieldBegin()
15406 
      if ftype == TType.STOP:
15407 
        break
15408 
      if fid == 1:
15409 
        if ftype == TType.I32:
15410 
          self.offset = iprot.readI32();
15411 
        else:
15412 
          iprot.skip(ftype)
15413 
      elif fid == 2:
15414 
        if ftype == TType.I32:
15415 
          self.limit = iprot.readI32();
15416 
        else:
15417 
          iprot.skip(ftype)
15418 
      else:
15419 
        iprot.skip(ftype)
15420 
      iprot.readFieldEnd()
15421 
    iprot.readStructEnd()
15422 
 
15423 
  def write(self, oprot):
15424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15426 
      return
15427 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15428 
    if self.offset is not None:
15429 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15430 
      oprot.writeI32(self.offset)
15431 
      oprot.writeFieldEnd()
15432 
    if self.limit is not None:
15433 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15434 
      oprot.writeI32(self.limit)
15435 
      oprot.writeFieldEnd()
15436 
    oprot.writeFieldStop()
15437 
    oprot.writeStructEnd()
15438 
 
15439 
  def validate(self):
15440 
    return
15441 
 
15442 
 
15443 
  def __repr__(self):
15444 
    L = ['%s=%r' % (key, value)
15445 
      for key, value in self.__dict__.iteritems()]
15446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15447 
 
15448 
  def __eq__(self, other):
15449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15450 
 
15451 
  def __ne__(self, other):
15452 
    return not (self == other)
15453 
 
15454 
class getAllIgnoredInventoryUpdateItemsList_result:
15455 
  """
15456 
  Attributes:
15457 
   - success
15458 
  """
15459 
 
15460 
  thrift_spec = (
15461 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15462 
  )
15463 
 
15464 
  def __init__(self, success=None,):
15465 
    self.success = success
15466 
 
15467 
  def read(self, iprot):
15468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15470 
      return
15471 
    iprot.readStructBegin()
15472 
    while True:
15473 
      (fname, ftype, fid) = iprot.readFieldBegin()
15474 
      if ftype == TType.STOP:
15475 
        break
15476 
      if fid == 0:
15477 
        if ftype == TType.LIST:
15478 
          self.success = []
7438 amit.gupta 15479 
          (_etype296, _size293) = iprot.readListBegin()
15480 
          for _i297 in xrange(_size293):
15481 
            _elem298 = Item()
15482 
            _elem298.read(iprot)
15483 
            self.success.append(_elem298)
6531 vikram.rag 15484 
          iprot.readListEnd()
15485 
        else:
15486 
          iprot.skip(ftype)
15487 
      else:
15488 
        iprot.skip(ftype)
15489 
      iprot.readFieldEnd()
15490 
    iprot.readStructEnd()
15491 
 
15492 
  def write(self, oprot):
15493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15495 
      return
15496 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15497 
    if self.success is not None:
15498 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15499 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15500 
      for iter299 in self.success:
15501 
        iter299.write(oprot)
6531 vikram.rag 15502 
      oprot.writeListEnd()
15503 
      oprot.writeFieldEnd()
15504 
    oprot.writeFieldStop()
15505 
    oprot.writeStructEnd()
15506 
 
15507 
  def validate(self):
15508 
    return
15509 
 
15510 
 
15511 
  def __repr__(self):
15512 
    L = ['%s=%r' % (key, value)
15513 
      for key, value in self.__dict__.iteritems()]
15514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15515 
 
15516 
  def __eq__(self, other):
15517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15518 
 
15519 
  def __ne__(self, other):
15520 
    return not (self == other)
6805 anupam.sin 15521 
 
6821 amar.kumar 15522 
class getAllAliveItems_args:
15523 
 
15524 
  thrift_spec = (
15525 
  )
15526 
 
15527 
  def read(self, iprot):
15528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15530 
      return
15531 
    iprot.readStructBegin()
15532 
    while True:
15533 
      (fname, ftype, fid) = iprot.readFieldBegin()
15534 
      if ftype == TType.STOP:
15535 
        break
15536 
      else:
15537 
        iprot.skip(ftype)
15538 
      iprot.readFieldEnd()
15539 
    iprot.readStructEnd()
15540 
 
15541 
  def write(self, oprot):
15542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15544 
      return
15545 
    oprot.writeStructBegin('getAllAliveItems_args')
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 getAllAliveItems_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 
          (_etype303, _size300) = iprot.readListBegin()
15590 
          for _i304 in xrange(_size300):
15591 
            _elem305 = Item()
15592 
            _elem305.read(iprot)
15593 
            self.success.append(_elem305)
6821 amar.kumar 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('getAllAliveItems_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 iter306 in self.success:
15611 
        iter306.write(oprot)
6821 amar.kumar 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)
15631 
 
6805 anupam.sin 15632 
class getInsuranceAmount_args:
15633 
  """
15634 
  Attributes:
15635 
   - itemId
6921 anupam.sin 15636 
   - price
6805 anupam.sin 15637 
   - insurerId
15638 
   - quantity
15639 
  """
15640 
 
15641 
  thrift_spec = (
15642 
    None, # 0
15643 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15644 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15645 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15646 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15647 
  )
15648 
 
6921 anupam.sin 15649 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15650 
    self.itemId = itemId
6921 anupam.sin 15651 
    self.price = price
6805 anupam.sin 15652 
    self.insurerId = insurerId
15653 
    self.quantity = quantity
15654 
 
15655 
  def read(self, iprot):
15656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15658 
      return
15659 
    iprot.readStructBegin()
15660 
    while True:
15661 
      (fname, ftype, fid) = iprot.readFieldBegin()
15662 
      if ftype == TType.STOP:
15663 
        break
15664 
      if fid == 1:
15665 
        if ftype == TType.I64:
15666 
          self.itemId = iprot.readI64();
15667 
        else:
15668 
          iprot.skip(ftype)
15669 
      elif fid == 2:
6921 anupam.sin 15670 
        if ftype == TType.DOUBLE:
15671 
          self.price = iprot.readDouble();
15672 
        else:
15673 
          iprot.skip(ftype)
15674 
      elif fid == 3:
6805 anupam.sin 15675 
        if ftype == TType.I64:
15676 
          self.insurerId = iprot.readI64();
15677 
        else:
15678 
          iprot.skip(ftype)
6921 anupam.sin 15679 
      elif fid == 4:
6805 anupam.sin 15680 
        if ftype == TType.I64:
15681 
          self.quantity = iprot.readI64();
15682 
        else:
15683 
          iprot.skip(ftype)
15684 
      else:
15685 
        iprot.skip(ftype)
15686 
      iprot.readFieldEnd()
15687 
    iprot.readStructEnd()
15688 
 
15689 
  def write(self, oprot):
15690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15692 
      return
15693 
    oprot.writeStructBegin('getInsuranceAmount_args')
15694 
    if self.itemId is not None:
15695 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15696 
      oprot.writeI64(self.itemId)
15697 
      oprot.writeFieldEnd()
6921 anupam.sin 15698 
    if self.price is not None:
15699 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15700 
      oprot.writeDouble(self.price)
15701 
      oprot.writeFieldEnd()
6805 anupam.sin 15702 
    if self.insurerId is not None:
6921 anupam.sin 15703 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15704 
      oprot.writeI64(self.insurerId)
15705 
      oprot.writeFieldEnd()
15706 
    if self.quantity is not None:
6921 anupam.sin 15707 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15708 
      oprot.writeI64(self.quantity)
15709 
      oprot.writeFieldEnd()
15710 
    oprot.writeFieldStop()
15711 
    oprot.writeStructEnd()
15712 
 
15713 
  def validate(self):
15714 
    return
15715 
 
15716 
 
15717 
  def __repr__(self):
15718 
    L = ['%s=%r' % (key, value)
15719 
      for key, value in self.__dict__.iteritems()]
15720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15721 
 
15722 
  def __eq__(self, other):
15723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15724 
 
15725 
  def __ne__(self, other):
15726 
    return not (self == other)
15727 
 
15728 
class getInsuranceAmount_result:
15729 
  """
15730 
  Attributes:
15731 
   - success
15732 
  """
15733 
 
15734 
  thrift_spec = (
15735 
    (0, TType.I64, 'success', None, None, ), # 0
15736 
  )
15737 
 
15738 
  def __init__(self, success=None,):
15739 
    self.success = success
15740 
 
15741 
  def read(self, iprot):
15742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15744 
      return
15745 
    iprot.readStructBegin()
15746 
    while True:
15747 
      (fname, ftype, fid) = iprot.readFieldBegin()
15748 
      if ftype == TType.STOP:
15749 
        break
15750 
      if fid == 0:
15751 
        if ftype == TType.I64:
15752 
          self.success = iprot.readI64();
15753 
        else:
15754 
          iprot.skip(ftype)
15755 
      else:
15756 
        iprot.skip(ftype)
15757 
      iprot.readFieldEnd()
15758 
    iprot.readStructEnd()
15759 
 
15760 
  def write(self, oprot):
15761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15763 
      return
15764 
    oprot.writeStructBegin('getInsuranceAmount_result')
15765 
    if self.success is not None:
15766 
      oprot.writeFieldBegin('success', TType.I64, 0)
15767 
      oprot.writeI64(self.success)
15768 
      oprot.writeFieldEnd()
15769 
    oprot.writeFieldStop()
15770 
    oprot.writeStructEnd()
15771 
 
15772 
  def validate(self):
15773 
    return
15774 
 
15775 
 
15776 
  def __repr__(self):
15777 
    L = ['%s=%r' % (key, value)
15778 
      for key, value in self.__dict__.iteritems()]
15779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15780 
 
15781 
  def __eq__(self, other):
15782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15783 
 
15784 
  def __ne__(self, other):
15785 
    return not (self == other)
15786 
 
15787 
class getInsurer_args:
15788 
  """
15789 
  Attributes:
15790 
   - insurerId
15791 
  """
15792 
 
15793 
  thrift_spec = (
15794 
    None, # 0
15795 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15796 
  )
15797 
 
15798 
  def __init__(self, insurerId=None,):
15799 
    self.insurerId = insurerId
15800 
 
15801 
  def read(self, iprot):
15802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15804 
      return
15805 
    iprot.readStructBegin()
15806 
    while True:
15807 
      (fname, ftype, fid) = iprot.readFieldBegin()
15808 
      if ftype == TType.STOP:
15809 
        break
15810 
      if fid == 1:
15811 
        if ftype == TType.I64:
15812 
          self.insurerId = iprot.readI64();
15813 
        else:
15814 
          iprot.skip(ftype)
15815 
      else:
15816 
        iprot.skip(ftype)
15817 
      iprot.readFieldEnd()
15818 
    iprot.readStructEnd()
15819 
 
15820 
  def write(self, oprot):
15821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15823 
      return
15824 
    oprot.writeStructBegin('getInsurer_args')
15825 
    if self.insurerId is not None:
15826 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15827 
      oprot.writeI64(self.insurerId)
15828 
      oprot.writeFieldEnd()
15829 
    oprot.writeFieldStop()
15830 
    oprot.writeStructEnd()
15831 
 
15832 
  def validate(self):
15833 
    return
15834 
 
15835 
 
15836 
  def __repr__(self):
15837 
    L = ['%s=%r' % (key, value)
15838 
      for key, value in self.__dict__.iteritems()]
15839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15840 
 
15841 
  def __eq__(self, other):
15842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15843 
 
15844 
  def __ne__(self, other):
15845 
    return not (self == other)
15846 
 
15847 
class getInsurer_result:
15848 
  """
15849 
  Attributes:
15850 
   - success
15851 
  """
15852 
 
15853 
  thrift_spec = (
15854 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15855 
  )
15856 
 
15857 
  def __init__(self, success=None,):
15858 
    self.success = success
15859 
 
15860 
  def read(self, iprot):
15861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15863 
      return
15864 
    iprot.readStructBegin()
15865 
    while True:
15866 
      (fname, ftype, fid) = iprot.readFieldBegin()
15867 
      if ftype == TType.STOP:
15868 
        break
15869 
      if fid == 0:
15870 
        if ftype == TType.STRUCT:
15871 
          self.success = Insurer()
15872 
          self.success.read(iprot)
15873 
        else:
15874 
          iprot.skip(ftype)
15875 
      else:
15876 
        iprot.skip(ftype)
15877 
      iprot.readFieldEnd()
15878 
    iprot.readStructEnd()
15879 
 
15880 
  def write(self, oprot):
15881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15883 
      return
15884 
    oprot.writeStructBegin('getInsurer_result')
15885 
    if self.success is not None:
15886 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15887 
      self.success.write(oprot)
15888 
      oprot.writeFieldEnd()
15889 
    oprot.writeFieldStop()
15890 
    oprot.writeStructEnd()
15891 
 
15892 
  def validate(self):
15893 
    return
15894 
 
15895 
 
15896 
  def __repr__(self):
15897 
    L = ['%s=%r' % (key, value)
15898 
      for key, value in self.__dict__.iteritems()]
15899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15900 
 
15901 
  def __eq__(self, other):
15902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15903 
 
15904 
  def __ne__(self, other):
15905 
    return not (self == other)
6838 vikram.rag 15906 
 
15907 
class getAllInsurers_args:
15908 
 
15909 
  thrift_spec = (
15910 
  )
15911 
 
15912 
  def read(self, iprot):
15913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15915 
      return
15916 
    iprot.readStructBegin()
15917 
    while True:
15918 
      (fname, ftype, fid) = iprot.readFieldBegin()
15919 
      if ftype == TType.STOP:
15920 
        break
15921 
      else:
15922 
        iprot.skip(ftype)
15923 
      iprot.readFieldEnd()
15924 
    iprot.readStructEnd()
15925 
 
15926 
  def write(self, oprot):
15927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15929 
      return
15930 
    oprot.writeStructBegin('getAllInsurers_args')
15931 
    oprot.writeFieldStop()
15932 
    oprot.writeStructEnd()
15933 
 
15934 
  def validate(self):
15935 
    return
15936 
 
15937 
 
15938 
  def __repr__(self):
15939 
    L = ['%s=%r' % (key, value)
15940 
      for key, value in self.__dict__.iteritems()]
15941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15942 
 
15943 
  def __eq__(self, other):
15944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15945 
 
15946 
  def __ne__(self, other):
15947 
    return not (self == other)
15948 
 
15949 
class getAllInsurers_result:
15950 
  """
15951 
  Attributes:
15952 
   - success
15953 
  """
15954 
 
15955 
  thrift_spec = (
15956 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15957 
  )
15958 
 
15959 
  def __init__(self, success=None,):
15960 
    self.success = success
15961 
 
15962 
  def read(self, iprot):
15963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15965 
      return
15966 
    iprot.readStructBegin()
15967 
    while True:
15968 
      (fname, ftype, fid) = iprot.readFieldBegin()
15969 
      if ftype == TType.STOP:
15970 
        break
15971 
      if fid == 0:
15972 
        if ftype == TType.LIST:
15973 
          self.success = []
7438 amit.gupta 15974 
          (_etype310, _size307) = iprot.readListBegin()
15975 
          for _i311 in xrange(_size307):
15976 
            _elem312 = Insurer()
15977 
            _elem312.read(iprot)
15978 
            self.success.append(_elem312)
6838 vikram.rag 15979 
          iprot.readListEnd()
15980 
        else:
15981 
          iprot.skip(ftype)
15982 
      else:
15983 
        iprot.skip(ftype)
15984 
      iprot.readFieldEnd()
15985 
    iprot.readStructEnd()
15986 
 
15987 
  def write(self, oprot):
15988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15990 
      return
15991 
    oprot.writeStructBegin('getAllInsurers_result')
15992 
    if self.success is not None:
15993 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15994 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15995 
      for iter313 in self.success:
15996 
        iter313.write(oprot)
6838 vikram.rag 15997 
      oprot.writeListEnd()
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)
6962 rajveer 16016 
 
16017 
class updateInsuranceDeclaredAmount_args:
16018 
  """
16019 
  Attributes:
16020 
   - insurerId
16021 
   - amount
16022 
  """
16023 
 
16024 
  thrift_spec = (
16025 
    None, # 0
16026 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16027 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16028 
  )
16029 
 
16030 
  def __init__(self, insurerId=None, amount=None,):
16031 
    self.insurerId = insurerId
16032 
    self.amount = amount
16033 
 
16034 
  def read(self, iprot):
16035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16037 
      return
16038 
    iprot.readStructBegin()
16039 
    while True:
16040 
      (fname, ftype, fid) = iprot.readFieldBegin()
16041 
      if ftype == TType.STOP:
16042 
        break
16043 
      if fid == 1:
16044 
        if ftype == TType.I64:
16045 
          self.insurerId = iprot.readI64();
16046 
        else:
16047 
          iprot.skip(ftype)
16048 
      elif fid == 2:
16049 
        if ftype == TType.DOUBLE:
16050 
          self.amount = iprot.readDouble();
16051 
        else:
16052 
          iprot.skip(ftype)
16053 
      else:
16054 
        iprot.skip(ftype)
16055 
      iprot.readFieldEnd()
16056 
    iprot.readStructEnd()
16057 
 
16058 
  def write(self, oprot):
16059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16061 
      return
16062 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16063 
    if self.insurerId is not None:
16064 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16065 
      oprot.writeI64(self.insurerId)
16066 
      oprot.writeFieldEnd()
16067 
    if self.amount is not None:
16068 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16069 
      oprot.writeDouble(self.amount)
16070 
      oprot.writeFieldEnd()
16071 
    oprot.writeFieldStop()
16072 
    oprot.writeStructEnd()
16073 
 
16074 
  def validate(self):
16075 
    return
16076 
 
16077 
 
16078 
  def __repr__(self):
16079 
    L = ['%s=%r' % (key, value)
16080 
      for key, value in self.__dict__.iteritems()]
16081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16082 
 
16083 
  def __eq__(self, other):
16084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16085 
 
16086 
  def __ne__(self, other):
16087 
    return not (self == other)
16088 
 
16089 
class updateInsuranceDeclaredAmount_result:
16090 
 
16091 
  thrift_spec = (
16092 
  )
16093 
 
16094 
  def read(self, iprot):
16095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16097 
      return
16098 
    iprot.readStructBegin()
16099 
    while True:
16100 
      (fname, ftype, fid) = iprot.readFieldBegin()
16101 
      if ftype == TType.STOP:
16102 
        break
16103 
      else:
16104 
        iprot.skip(ftype)
16105 
      iprot.readFieldEnd()
16106 
    iprot.readStructEnd()
16107 
 
16108 
  def write(self, oprot):
16109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16111 
      return
16112 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16113 
    oprot.writeFieldStop()
16114 
    oprot.writeStructEnd()
16115 
 
16116 
  def validate(self):
16117 
    return
16118 
 
16119 
 
16120 
  def __repr__(self):
16121 
    L = ['%s=%r' % (key, value)
16122 
      for key, value in self.__dict__.iteritems()]
16123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16124 
 
16125 
  def __eq__(self, other):
16126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16127 
 
16128 
  def __ne__(self, other):
16129 
    return not (self == other)
7190 amar.kumar 16130 
 
16131 
class getFreebieForItem_args:
16132 
  """
16133 
  Attributes:
16134 
   - itemId
16135 
  """
16136 
 
16137 
  thrift_spec = (
16138 
    None, # 0
16139 
    (1, TType.I64, 'itemId', None, None, ), # 1
16140 
  )
16141 
 
16142 
  def __init__(self, itemId=None,):
16143 
    self.itemId = itemId
16144 
 
16145 
  def read(self, iprot):
16146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16148 
      return
16149 
    iprot.readStructBegin()
16150 
    while True:
16151 
      (fname, ftype, fid) = iprot.readFieldBegin()
16152 
      if ftype == TType.STOP:
16153 
        break
16154 
      if fid == 1:
16155 
        if ftype == TType.I64:
16156 
          self.itemId = iprot.readI64();
16157 
        else:
16158 
          iprot.skip(ftype)
16159 
      else:
16160 
        iprot.skip(ftype)
16161 
      iprot.readFieldEnd()
16162 
    iprot.readStructEnd()
16163 
 
16164 
  def write(self, oprot):
16165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16167 
      return
16168 
    oprot.writeStructBegin('getFreebieForItem_args')
16169 
    if self.itemId is not None:
16170 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16171 
      oprot.writeI64(self.itemId)
16172 
      oprot.writeFieldEnd()
16173 
    oprot.writeFieldStop()
16174 
    oprot.writeStructEnd()
16175 
 
16176 
  def validate(self):
16177 
    return
16178 
 
16179 
 
16180 
  def __repr__(self):
16181 
    L = ['%s=%r' % (key, value)
16182 
      for key, value in self.__dict__.iteritems()]
16183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16184 
 
16185 
  def __eq__(self, other):
16186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16187 
 
16188 
  def __ne__(self, other):
16189 
    return not (self == other)
16190 
 
16191 
class getFreebieForItem_result:
16192 
  """
16193 
  Attributes:
16194 
   - success
16195 
  """
16196 
 
16197 
  thrift_spec = (
16198 
    (0, TType.I64, 'success', None, None, ), # 0
16199 
  )
16200 
 
16201 
  def __init__(self, success=None,):
16202 
    self.success = success
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 
      if fid == 0:
16214 
        if ftype == TType.I64:
16215 
          self.success = iprot.readI64();
16216 
        else:
16217 
          iprot.skip(ftype)
16218 
      else:
16219 
        iprot.skip(ftype)
16220 
      iprot.readFieldEnd()
16221 
    iprot.readStructEnd()
16222 
 
16223 
  def write(self, oprot):
16224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16226 
      return
16227 
    oprot.writeStructBegin('getFreebieForItem_result')
16228 
    if self.success is not None:
16229 
      oprot.writeFieldBegin('success', TType.I64, 0)
16230 
      oprot.writeI64(self.success)
16231 
      oprot.writeFieldEnd()
16232 
    oprot.writeFieldStop()
16233 
    oprot.writeStructEnd()
16234 
 
16235 
  def validate(self):
16236 
    return
16237 
 
16238 
 
16239 
  def __repr__(self):
16240 
    L = ['%s=%r' % (key, value)
16241 
      for key, value in self.__dict__.iteritems()]
16242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16243 
 
16244 
  def __eq__(self, other):
16245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16246 
 
16247 
  def __ne__(self, other):
16248 
    return not (self == other)
16249 
 
16250 
class addOrUpdateFreebieForItem_args:
16251 
  """
16252 
  Attributes:
16253 
   - freebieItem
16254 
  """
16255 
 
16256 
  thrift_spec = (
16257 
    None, # 0
16258 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16259 
  )
16260 
 
16261 
  def __init__(self, freebieItem=None,):
16262 
    self.freebieItem = freebieItem
16263 
 
16264 
  def read(self, iprot):
16265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16267 
      return
16268 
    iprot.readStructBegin()
16269 
    while True:
16270 
      (fname, ftype, fid) = iprot.readFieldBegin()
16271 
      if ftype == TType.STOP:
16272 
        break
16273 
      if fid == 1:
16274 
        if ftype == TType.STRUCT:
16275 
          self.freebieItem = FreebieItem()
16276 
          self.freebieItem.read(iprot)
16277 
        else:
16278 
          iprot.skip(ftype)
16279 
      else:
16280 
        iprot.skip(ftype)
16281 
      iprot.readFieldEnd()
16282 
    iprot.readStructEnd()
16283 
 
16284 
  def write(self, oprot):
16285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16287 
      return
16288 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16289 
    if self.freebieItem is not None:
16290 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16291 
      self.freebieItem.write(oprot)
16292 
      oprot.writeFieldEnd()
16293 
    oprot.writeFieldStop()
16294 
    oprot.writeStructEnd()
16295 
 
16296 
  def validate(self):
16297 
    return
16298 
 
16299 
 
16300 
  def __repr__(self):
16301 
    L = ['%s=%r' % (key, value)
16302 
      for key, value in self.__dict__.iteritems()]
16303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16304 
 
16305 
  def __eq__(self, other):
16306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16307 
 
16308 
  def __ne__(self, other):
16309 
    return not (self == other)
16310 
 
16311 
class addOrUpdateFreebieForItem_result:
16312 
 
16313 
  thrift_spec = (
16314 
  )
16315 
 
16316 
  def read(self, iprot):
16317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16319 
      return
16320 
    iprot.readStructBegin()
16321 
    while True:
16322 
      (fname, ftype, fid) = iprot.readFieldBegin()
16323 
      if ftype == TType.STOP:
16324 
        break
16325 
      else:
16326 
        iprot.skip(ftype)
16327 
      iprot.readFieldEnd()
16328 
    iprot.readStructEnd()
16329 
 
16330 
  def write(self, oprot):
16331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16333 
      return
16334 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16335 
    oprot.writeFieldStop()
16336 
    oprot.writeStructEnd()
16337 
 
16338 
  def validate(self):
16339 
    return
16340 
 
16341 
 
16342 
  def __repr__(self):
16343 
    L = ['%s=%r' % (key, value)
16344 
      for key, value in self.__dict__.iteritems()]
16345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16346 
 
16347 
  def __eq__(self, other):
16348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16349 
 
16350 
  def __ne__(self, other):
16351 
    return not (self == other)
7256 rajveer 16352 
 
7272 amit.gupta 16353 
class addOrUpdateBrandInfo_args:
16354 
  """
16355 
  Attributes:
16356 
   - brandInfo
16357 
  """
16358 
 
16359 
  thrift_spec = (
16360 
    None, # 0
16361 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16362 
  )
16363 
 
16364 
  def __init__(self, brandInfo=None,):
16365 
    self.brandInfo = brandInfo
16366 
 
16367 
  def read(self, iprot):
16368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16370 
      return
16371 
    iprot.readStructBegin()
16372 
    while True:
16373 
      (fname, ftype, fid) = iprot.readFieldBegin()
16374 
      if ftype == TType.STOP:
16375 
        break
16376 
      if fid == 1:
16377 
        if ftype == TType.STRUCT:
16378 
          self.brandInfo = BrandInfo()
16379 
          self.brandInfo.read(iprot)
16380 
        else:
16381 
          iprot.skip(ftype)
16382 
      else:
16383 
        iprot.skip(ftype)
16384 
      iprot.readFieldEnd()
16385 
    iprot.readStructEnd()
16386 
 
16387 
  def write(self, oprot):
16388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16390 
      return
16391 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16392 
    if self.brandInfo is not None:
16393 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16394 
      self.brandInfo.write(oprot)
16395 
      oprot.writeFieldEnd()
16396 
    oprot.writeFieldStop()
16397 
    oprot.writeStructEnd()
16398 
 
16399 
  def validate(self):
16400 
    return
16401 
 
16402 
 
16403 
  def __repr__(self):
16404 
    L = ['%s=%r' % (key, value)
16405 
      for key, value in self.__dict__.iteritems()]
16406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16407 
 
16408 
  def __eq__(self, other):
16409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16410 
 
16411 
  def __ne__(self, other):
16412 
    return not (self == other)
16413 
 
16414 
class addOrUpdateBrandInfo_result:
16415 
 
16416 
  thrift_spec = (
16417 
  )
16418 
 
16419 
  def read(self, iprot):
16420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16422 
      return
16423 
    iprot.readStructBegin()
16424 
    while True:
16425 
      (fname, ftype, fid) = iprot.readFieldBegin()
16426 
      if ftype == TType.STOP:
16427 
        break
16428 
      else:
16429 
        iprot.skip(ftype)
16430 
      iprot.readFieldEnd()
16431 
    iprot.readStructEnd()
16432 
 
16433 
  def write(self, oprot):
16434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16436 
      return
16437 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16438 
    oprot.writeFieldStop()
16439 
    oprot.writeStructEnd()
16440 
 
16441 
  def validate(self):
16442 
    return
16443 
 
16444 
 
16445 
  def __repr__(self):
16446 
    L = ['%s=%r' % (key, value)
16447 
      for key, value in self.__dict__.iteritems()]
16448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16449 
 
16450 
  def __eq__(self, other):
16451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16452 
 
16453 
  def __ne__(self, other):
16454 
    return not (self == other)
16455 
 
16456 
class getBrandInfo_args:
16457 
 
16458 
  thrift_spec = (
16459 
  )
16460 
 
16461 
  def read(self, iprot):
16462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16464 
      return
16465 
    iprot.readStructBegin()
16466 
    while True:
16467 
      (fname, ftype, fid) = iprot.readFieldBegin()
16468 
      if ftype == TType.STOP:
16469 
        break
16470 
      else:
16471 
        iprot.skip(ftype)
16472 
      iprot.readFieldEnd()
16473 
    iprot.readStructEnd()
16474 
 
16475 
  def write(self, oprot):
16476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16478 
      return
16479 
    oprot.writeStructBegin('getBrandInfo_args')
16480 
    oprot.writeFieldStop()
16481 
    oprot.writeStructEnd()
16482 
 
16483 
  def validate(self):
16484 
    return
16485 
 
16486 
 
16487 
  def __repr__(self):
16488 
    L = ['%s=%r' % (key, value)
16489 
      for key, value in self.__dict__.iteritems()]
16490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16491 
 
16492 
  def __eq__(self, other):
16493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16494 
 
16495 
  def __ne__(self, other):
16496 
    return not (self == other)
16497 
 
16498 
class getBrandInfo_result:
16499 
  """
16500 
  Attributes:
16501 
   - success
16502 
  """
16503 
 
16504 
  thrift_spec = (
16505 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16506 
  )
16507 
 
16508 
  def __init__(self, success=None,):
16509 
    self.success = success
16510 
 
16511 
  def read(self, iprot):
16512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16514 
      return
16515 
    iprot.readStructBegin()
16516 
    while True:
16517 
      (fname, ftype, fid) = iprot.readFieldBegin()
16518 
      if ftype == TType.STOP:
16519 
        break
16520 
      if fid == 0:
16521 
        if ftype == TType.MAP:
16522 
          self.success = {}
7438 amit.gupta 16523 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16524 
          for _i318 in xrange(_size314):
16525 
            _key319 = iprot.readString();
16526 
            _val320 = BrandInfo()
16527 
            _val320.read(iprot)
16528 
            self.success[_key319] = _val320
7272 amit.gupta 16529 
          iprot.readMapEnd()
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('getBrandInfo_result')
16542 
    if self.success is not None:
16543 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16544 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16545 
      for kiter321,viter322 in self.success.items():
16546 
        oprot.writeString(kiter321)
16547 
        viter322.write(oprot)
7272 amit.gupta 16548 
      oprot.writeMapEnd()
16549 
      oprot.writeFieldEnd()
16550 
    oprot.writeFieldStop()
16551 
    oprot.writeStructEnd()
16552 
 
16553 
  def validate(self):
16554 
    return
16555 
 
16556 
 
16557 
  def __repr__(self):
16558 
    L = ['%s=%r' % (key, value)
16559 
      for key, value in self.__dict__.iteritems()]
16560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16561 
 
16562 
  def __eq__(self, other):
16563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16564 
 
16565 
  def __ne__(self, other):
16566 
    return not (self == other)
16567 
 
7256 rajveer 16568 
class getStorePricing_args:
16569 
  """
16570 
  Attributes:
16571 
   - itemId
16572 
  """
16573 
 
16574 
  thrift_spec = (
16575 
    None, # 0
16576 
    (1, TType.I64, 'itemId', None, None, ), # 1
16577 
  )
16578 
 
16579 
  def __init__(self, itemId=None,):
16580 
    self.itemId = itemId
16581 
 
16582 
  def read(self, iprot):
16583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16585 
      return
16586 
    iprot.readStructBegin()
16587 
    while True:
16588 
      (fname, ftype, fid) = iprot.readFieldBegin()
16589 
      if ftype == TType.STOP:
16590 
        break
16591 
      if fid == 1:
16592 
        if ftype == TType.I64:
16593 
          self.itemId = iprot.readI64();
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      else:
16597 
        iprot.skip(ftype)
16598 
      iprot.readFieldEnd()
16599 
    iprot.readStructEnd()
16600 
 
16601 
  def write(self, oprot):
16602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16604 
      return
16605 
    oprot.writeStructBegin('getStorePricing_args')
16606 
    if self.itemId is not None:
16607 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16608 
      oprot.writeI64(self.itemId)
16609 
      oprot.writeFieldEnd()
16610 
    oprot.writeFieldStop()
16611 
    oprot.writeStructEnd()
16612 
 
16613 
  def validate(self):
16614 
    return
16615 
 
16616 
 
16617 
  def __repr__(self):
16618 
    L = ['%s=%r' % (key, value)
16619 
      for key, value in self.__dict__.iteritems()]
16620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16621 
 
16622 
  def __eq__(self, other):
16623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16624 
 
16625 
  def __ne__(self, other):
16626 
    return not (self == other)
16627 
 
16628 
class getStorePricing_result:
16629 
  """
16630 
  Attributes:
16631 
   - success
16632 
  """
16633 
 
16634 
  thrift_spec = (
16635 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16636 
  )
16637 
 
16638 
  def __init__(self, success=None,):
16639 
    self.success = success
16640 
 
16641 
  def read(self, iprot):
16642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16644 
      return
16645 
    iprot.readStructBegin()
16646 
    while True:
16647 
      (fname, ftype, fid) = iprot.readFieldBegin()
16648 
      if ftype == TType.STOP:
16649 
        break
16650 
      if fid == 0:
16651 
        if ftype == TType.STRUCT:
16652 
          self.success = StorePricing()
16653 
          self.success.read(iprot)
16654 
        else:
16655 
          iprot.skip(ftype)
16656 
      else:
16657 
        iprot.skip(ftype)
16658 
      iprot.readFieldEnd()
16659 
    iprot.readStructEnd()
16660 
 
16661 
  def write(self, oprot):
16662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16664 
      return
16665 
    oprot.writeStructBegin('getStorePricing_result')
16666 
    if self.success is not None:
16667 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16668 
      self.success.write(oprot)
16669 
      oprot.writeFieldEnd()
16670 
    oprot.writeFieldStop()
16671 
    oprot.writeStructEnd()
16672 
 
16673 
  def validate(self):
16674 
    return
16675 
 
16676 
 
16677 
  def __repr__(self):
16678 
    L = ['%s=%r' % (key, value)
16679 
      for key, value in self.__dict__.iteritems()]
16680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16681 
 
16682 
  def __eq__(self, other):
16683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16684 
 
16685 
  def __ne__(self, other):
16686 
    return not (self == other)
7265 rajveer 16687 
 
7306 rajveer 16688 
class getStorePricings_args:
16689 
  """
16690 
  Attributes:
16691 
   - itemIds
16692 
  """
16693 
 
16694 
  thrift_spec = (
16695 
    None, # 0
16696 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16697 
  )
16698 
 
16699 
  def __init__(self, itemIds=None,):
16700 
    self.itemIds = itemIds
16701 
 
16702 
  def read(self, iprot):
16703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16705 
      return
16706 
    iprot.readStructBegin()
16707 
    while True:
16708 
      (fname, ftype, fid) = iprot.readFieldBegin()
16709 
      if ftype == TType.STOP:
16710 
        break
16711 
      if fid == 1:
16712 
        if ftype == TType.LIST:
16713 
          self.itemIds = []
7438 amit.gupta 16714 
          (_etype326, _size323) = iprot.readListBegin()
16715 
          for _i327 in xrange(_size323):
16716 
            _elem328 = iprot.readI64();
16717 
            self.itemIds.append(_elem328)
7306 rajveer 16718 
          iprot.readListEnd()
16719 
        else:
16720 
          iprot.skip(ftype)
16721 
      else:
16722 
        iprot.skip(ftype)
16723 
      iprot.readFieldEnd()
16724 
    iprot.readStructEnd()
16725 
 
16726 
  def write(self, oprot):
16727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16729 
      return
16730 
    oprot.writeStructBegin('getStorePricings_args')
16731 
    if self.itemIds is not None:
16732 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16733 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 16734 
      for iter329 in self.itemIds:
16735 
        oprot.writeI64(iter329)
7306 rajveer 16736 
      oprot.writeListEnd()
16737 
      oprot.writeFieldEnd()
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
16756 
class getStorePricings_result:
16757 
  """
16758 
  Attributes:
16759 
   - success
16760 
  """
16761 
 
16762 
  thrift_spec = (
16763 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16764 
  )
16765 
 
16766 
  def __init__(self, success=None,):
16767 
    self.success = success
16768 
 
16769 
  def read(self, iprot):
16770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16772 
      return
16773 
    iprot.readStructBegin()
16774 
    while True:
16775 
      (fname, ftype, fid) = iprot.readFieldBegin()
16776 
      if ftype == TType.STOP:
16777 
        break
16778 
      if fid == 0:
16779 
        if ftype == TType.LIST:
16780 
          self.success = []
7438 amit.gupta 16781 
          (_etype333, _size330) = iprot.readListBegin()
16782 
          for _i334 in xrange(_size330):
16783 
            _elem335 = StorePricing()
16784 
            _elem335.read(iprot)
16785 
            self.success.append(_elem335)
7306 rajveer 16786 
          iprot.readListEnd()
16787 
        else:
16788 
          iprot.skip(ftype)
16789 
      else:
16790 
        iprot.skip(ftype)
16791 
      iprot.readFieldEnd()
16792 
    iprot.readStructEnd()
16793 
 
16794 
  def write(self, oprot):
16795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16797 
      return
16798 
    oprot.writeStructBegin('getStorePricings_result')
16799 
    if self.success is not None:
16800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16802 
      for iter336 in self.success:
16803 
        iter336.write(oprot)
7306 rajveer 16804 
      oprot.writeListEnd()
16805 
      oprot.writeFieldEnd()
16806 
    oprot.writeFieldStop()
16807 
    oprot.writeStructEnd()
16808 
 
16809 
  def validate(self):
16810 
    return
16811 
 
16812 
 
16813 
  def __repr__(self):
16814 
    L = ['%s=%r' % (key, value)
16815 
      for key, value in self.__dict__.iteritems()]
16816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16817 
 
16818 
  def __eq__(self, other):
16819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16820 
 
16821 
  def __ne__(self, other):
16822 
    return not (self == other)
16823 
 
7265 rajveer 16824 
class updateStorePricing_args:
16825 
  """
16826 
  Attributes:
16827 
   - sp
7382 rajveer 16828 
   - allColors
7265 rajveer 16829 
  """
16830 
 
16831 
  thrift_spec = (
16832 
    None, # 0
16833 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 16834 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 16835 
  )
16836 
 
7382 rajveer 16837 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 16838 
    self.sp = sp
7382 rajveer 16839 
    self.allColors = allColors
7265 rajveer 16840 
 
16841 
  def read(self, iprot):
16842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16844 
      return
16845 
    iprot.readStructBegin()
16846 
    while True:
16847 
      (fname, ftype, fid) = iprot.readFieldBegin()
16848 
      if ftype == TType.STOP:
16849 
        break
16850 
      if fid == 1:
16851 
        if ftype == TType.STRUCT:
16852 
          self.sp = StorePricing()
16853 
          self.sp.read(iprot)
16854 
        else:
16855 
          iprot.skip(ftype)
7382 rajveer 16856 
      elif fid == 2:
16857 
        if ftype == TType.BOOL:
16858 
          self.allColors = iprot.readBool();
16859 
        else:
16860 
          iprot.skip(ftype)
7265 rajveer 16861 
      else:
16862 
        iprot.skip(ftype)
16863 
      iprot.readFieldEnd()
16864 
    iprot.readStructEnd()
16865 
 
16866 
  def write(self, oprot):
16867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16869 
      return
16870 
    oprot.writeStructBegin('updateStorePricing_args')
16871 
    if self.sp is not None:
16872 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16873 
      self.sp.write(oprot)
16874 
      oprot.writeFieldEnd()
7382 rajveer 16875 
    if self.allColors is not None:
16876 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
16877 
      oprot.writeBool(self.allColors)
16878 
      oprot.writeFieldEnd()
7265 rajveer 16879 
    oprot.writeFieldStop()
16880 
    oprot.writeStructEnd()
16881 
 
16882 
  def validate(self):
16883 
    return
16884 
 
16885 
 
16886 
  def __repr__(self):
16887 
    L = ['%s=%r' % (key, value)
16888 
      for key, value in self.__dict__.iteritems()]
16889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16890 
 
16891 
  def __eq__(self, other):
16892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16893 
 
16894 
  def __ne__(self, other):
16895 
    return not (self == other)
16896 
 
16897 
class updateStorePricing_result:
16898 
 
16899 
  thrift_spec = (
16900 
  )
16901 
 
16902 
  def read(self, iprot):
16903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16905 
      return
16906 
    iprot.readStructBegin()
16907 
    while True:
16908 
      (fname, ftype, fid) = iprot.readFieldBegin()
16909 
      if ftype == TType.STOP:
16910 
        break
16911 
      else:
16912 
        iprot.skip(ftype)
16913 
      iprot.readFieldEnd()
16914 
    iprot.readStructEnd()
16915 
 
16916 
  def write(self, oprot):
16917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16919 
      return
16920 
    oprot.writeStructBegin('updateStorePricing_result')
16921 
    oprot.writeFieldStop()
16922 
    oprot.writeStructEnd()
16923 
 
16924 
  def validate(self):
16925 
    return
16926 
 
16927 
 
16928 
  def __repr__(self):
16929 
    L = ['%s=%r' % (key, value)
16930 
      for key, value in self.__dict__.iteritems()]
16931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16932 
 
16933 
  def __eq__(self, other):
16934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16935 
 
16936 
  def __ne__(self, other):
16937 
    return not (self == other)
7281 kshitij.so 16938 
 
16939 
class getAllAmazonListedItems_args:
16940 
 
16941 
  thrift_spec = (
16942 
  )
16943 
 
16944 
  def read(self, iprot):
16945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16947 
      return
16948 
    iprot.readStructBegin()
16949 
    while True:
16950 
      (fname, ftype, fid) = iprot.readFieldBegin()
16951 
      if ftype == TType.STOP:
16952 
        break
16953 
      else:
16954 
        iprot.skip(ftype)
16955 
      iprot.readFieldEnd()
16956 
    iprot.readStructEnd()
16957 
 
16958 
  def write(self, oprot):
16959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16961 
      return
16962 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16963 
    oprot.writeFieldStop()
16964 
    oprot.writeStructEnd()
16965 
 
16966 
  def validate(self):
16967 
    return
16968 
 
16969 
 
16970 
  def __repr__(self):
16971 
    L = ['%s=%r' % (key, value)
16972 
      for key, value in self.__dict__.iteritems()]
16973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16974 
 
16975 
  def __eq__(self, other):
16976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16977 
 
16978 
  def __ne__(self, other):
16979 
    return not (self == other)
16980 
 
16981 
class getAllAmazonListedItems_result:
16982 
  """
16983 
  Attributes:
16984 
   - success
16985 
  """
16986 
 
16987 
  thrift_spec = (
16988 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16989 
  )
16990 
 
16991 
  def __init__(self, success=None,):
16992 
    self.success = success
16993 
 
16994 
  def read(self, iprot):
16995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16997 
      return
16998 
    iprot.readStructBegin()
16999 
    while True:
17000 
      (fname, ftype, fid) = iprot.readFieldBegin()
17001 
      if ftype == TType.STOP:
17002 
        break
17003 
      if fid == 0:
17004 
        if ftype == TType.LIST:
17005 
          self.success = []
7438 amit.gupta 17006 
          (_etype340, _size337) = iprot.readListBegin()
17007 
          for _i341 in xrange(_size337):
17008 
            _elem342 = Amazonlisted()
17009 
            _elem342.read(iprot)
17010 
            self.success.append(_elem342)
7281 kshitij.so 17011 
          iprot.readListEnd()
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17024 
    if self.success is not None:
17025 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17026 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17027 
      for iter343 in self.success:
17028 
        iter343.write(oprot)
7281 kshitij.so 17029 
      oprot.writeListEnd()
17030 
      oprot.writeFieldEnd()
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)
17048 
 
17049 
class getAmazonItemDetails_args:
17050 
  """
17051 
  Attributes:
17052 
   - itemId
17053 
  """
17054 
 
17055 
  thrift_spec = (
17056 
    None, # 0
17057 
    (1, TType.I64, 'itemId', None, None, ), # 1
17058 
  )
17059 
 
17060 
  def __init__(self, itemId=None,):
17061 
    self.itemId = itemId
17062 
 
17063 
  def read(self, iprot):
17064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17066 
      return
17067 
    iprot.readStructBegin()
17068 
    while True:
17069 
      (fname, ftype, fid) = iprot.readFieldBegin()
17070 
      if ftype == TType.STOP:
17071 
        break
17072 
      if fid == 1:
17073 
        if ftype == TType.I64:
17074 
          self.itemId = iprot.readI64();
17075 
        else:
17076 
          iprot.skip(ftype)
17077 
      else:
17078 
        iprot.skip(ftype)
17079 
      iprot.readFieldEnd()
17080 
    iprot.readStructEnd()
17081 
 
17082 
  def write(self, oprot):
17083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17085 
      return
17086 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17087 
    if self.itemId is not None:
17088 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17089 
      oprot.writeI64(self.itemId)
17090 
      oprot.writeFieldEnd()
17091 
    oprot.writeFieldStop()
17092 
    oprot.writeStructEnd()
17093 
 
17094 
  def validate(self):
17095 
    return
17096 
 
17097 
 
17098 
  def __repr__(self):
17099 
    L = ['%s=%r' % (key, value)
17100 
      for key, value in self.__dict__.iteritems()]
17101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17102 
 
17103 
  def __eq__(self, other):
17104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17105 
 
17106 
  def __ne__(self, other):
17107 
    return not (self == other)
17108 
 
17109 
class getAmazonItemDetails_result:
17110 
  """
17111 
  Attributes:
17112 
   - success
17113 
  """
17114 
 
17115 
  thrift_spec = (
17116 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17117 
  )
17118 
 
17119 
  def __init__(self, success=None,):
17120 
    self.success = success
17121 
 
17122 
  def read(self, iprot):
17123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17125 
      return
17126 
    iprot.readStructBegin()
17127 
    while True:
17128 
      (fname, ftype, fid) = iprot.readFieldBegin()
17129 
      if ftype == TType.STOP:
17130 
        break
17131 
      if fid == 0:
17132 
        if ftype == TType.STRUCT:
17133 
          self.success = Amazonlisted()
17134 
          self.success.read(iprot)
17135 
        else:
17136 
          iprot.skip(ftype)
17137 
      else:
17138 
        iprot.skip(ftype)
17139 
      iprot.readFieldEnd()
17140 
    iprot.readStructEnd()
17141 
 
17142 
  def write(self, oprot):
17143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17145 
      return
17146 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17147 
    if self.success is not None:
17148 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17149 
      self.success.write(oprot)
17150 
      oprot.writeFieldEnd()
17151 
    oprot.writeFieldStop()
17152 
    oprot.writeStructEnd()
17153 
 
17154 
  def validate(self):
17155 
    return
17156 
 
17157 
 
17158 
  def __repr__(self):
17159 
    L = ['%s=%r' % (key, value)
17160 
      for key, value in self.__dict__.iteritems()]
17161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17162 
 
17163 
  def __eq__(self, other):
17164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17165 
 
17166 
  def __ne__(self, other):
17167 
    return not (self == other)
17168 
 
17169 
class updateAmazonItemDetails_args:
17170 
  """
17171 
  Attributes:
17172 
   - itemId
17173 
   - fbaPrice
17174 
   - sellingPrice
17175 
   - isFba
17176 
   - isNonFba
17177 
   - isInventoryOverride
7367 kshitij.so 17178 
   - handlingTime
17179 
   - isCustomTime
7281 kshitij.so 17180 
  """
17181 
 
17182 
  thrift_spec = (
17183 
    None, # 0
17184 
    (1, TType.I64, 'itemId', None, None, ), # 1
17185 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17186 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17187 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17188 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17189 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17190 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17191 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17192 
  )
17193 
 
7367 kshitij.so 17194 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17195 
    self.itemId = itemId
17196 
    self.fbaPrice = fbaPrice
17197 
    self.sellingPrice = sellingPrice
17198 
    self.isFba = isFba
17199 
    self.isNonFba = isNonFba
17200 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17201 
    self.handlingTime = handlingTime
17202 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17203 
 
17204 
  def read(self, iprot):
17205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17207 
      return
17208 
    iprot.readStructBegin()
17209 
    while True:
17210 
      (fname, ftype, fid) = iprot.readFieldBegin()
17211 
      if ftype == TType.STOP:
17212 
        break
17213 
      if fid == 1:
17214 
        if ftype == TType.I64:
17215 
          self.itemId = iprot.readI64();
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      elif fid == 2:
17219 
        if ftype == TType.DOUBLE:
17220 
          self.fbaPrice = iprot.readDouble();
17221 
        else:
17222 
          iprot.skip(ftype)
17223 
      elif fid == 3:
17224 
        if ftype == TType.DOUBLE:
17225 
          self.sellingPrice = iprot.readDouble();
17226 
        else:
17227 
          iprot.skip(ftype)
17228 
      elif fid == 4:
17229 
        if ftype == TType.BOOL:
17230 
          self.isFba = iprot.readBool();
17231 
        else:
17232 
          iprot.skip(ftype)
17233 
      elif fid == 5:
17234 
        if ftype == TType.BOOL:
17235 
          self.isNonFba = iprot.readBool();
17236 
        else:
17237 
          iprot.skip(ftype)
17238 
      elif fid == 6:
17239 
        if ftype == TType.BOOL:
17240 
          self.isInventoryOverride = iprot.readBool();
17241 
        else:
17242 
          iprot.skip(ftype)
7367 kshitij.so 17243 
      elif fid == 7:
17244 
        if ftype == TType.I64:
17245 
          self.handlingTime = iprot.readI64();
17246 
        else:
17247 
          iprot.skip(ftype)
17248 
      elif fid == 8:
17249 
        if ftype == TType.BOOL:
17250 
          self.isCustomTime = iprot.readBool();
17251 
        else:
17252 
          iprot.skip(ftype)
7281 kshitij.so 17253 
      else:
17254 
        iprot.skip(ftype)
17255 
      iprot.readFieldEnd()
17256 
    iprot.readStructEnd()
17257 
 
17258 
  def write(self, oprot):
17259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17261 
      return
17262 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17263 
    if self.itemId is not None:
17264 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17265 
      oprot.writeI64(self.itemId)
17266 
      oprot.writeFieldEnd()
17267 
    if self.fbaPrice is not None:
17268 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17269 
      oprot.writeDouble(self.fbaPrice)
17270 
      oprot.writeFieldEnd()
17271 
    if self.sellingPrice is not None:
17272 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17273 
      oprot.writeDouble(self.sellingPrice)
17274 
      oprot.writeFieldEnd()
17275 
    if self.isFba is not None:
17276 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17277 
      oprot.writeBool(self.isFba)
17278 
      oprot.writeFieldEnd()
17279 
    if self.isNonFba is not None:
17280 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17281 
      oprot.writeBool(self.isNonFba)
17282 
      oprot.writeFieldEnd()
17283 
    if self.isInventoryOverride is not None:
17284 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17285 
      oprot.writeBool(self.isInventoryOverride)
17286 
      oprot.writeFieldEnd()
7367 kshitij.so 17287 
    if self.handlingTime is not None:
17288 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17289 
      oprot.writeI64(self.handlingTime)
17290 
      oprot.writeFieldEnd()
17291 
    if self.isCustomTime is not None:
17292 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17293 
      oprot.writeBool(self.isCustomTime)
17294 
      oprot.writeFieldEnd()
7281 kshitij.so 17295 
    oprot.writeFieldStop()
17296 
    oprot.writeStructEnd()
17297 
 
17298 
  def validate(self):
17299 
    return
17300 
 
17301 
 
17302 
  def __repr__(self):
17303 
    L = ['%s=%r' % (key, value)
17304 
      for key, value in self.__dict__.iteritems()]
17305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17306 
 
17307 
  def __eq__(self, other):
17308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17309 
 
17310 
  def __ne__(self, other):
17311 
    return not (self == other)
17312 
 
17313 
class updateAmazonItemDetails_result:
17314 
 
17315 
  thrift_spec = (
17316 
  )
17317 
 
17318 
  def read(self, iprot):
17319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17321 
      return
17322 
    iprot.readStructBegin()
17323 
    while True:
17324 
      (fname, ftype, fid) = iprot.readFieldBegin()
17325 
      if ftype == TType.STOP:
17326 
        break
17327 
      else:
17328 
        iprot.skip(ftype)
17329 
      iprot.readFieldEnd()
17330 
    iprot.readStructEnd()
17331 
 
17332 
  def write(self, oprot):
17333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17335 
      return
17336 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17337 
    oprot.writeFieldStop()
17338 
    oprot.writeStructEnd()
17339 
 
17340 
  def validate(self):
17341 
    return
17342 
 
17343 
 
17344 
  def __repr__(self):
17345 
    L = ['%s=%r' % (key, value)
17346 
      for key, value in self.__dict__.iteritems()]
17347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17348 
 
17349 
  def __eq__(self, other):
17350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17351 
 
17352 
  def __ne__(self, other):
17353 
    return not (self == other)
17354 
 
17355 
class addAmazonItem_args:
17356 
  """
17357 
  Attributes:
17358 
   - amazonlisted
17359 
  """
17360 
 
17361 
  thrift_spec = (
17362 
    None, # 0
17363 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17364 
  )
17365 
 
17366 
  def __init__(self, amazonlisted=None,):
17367 
    self.amazonlisted = amazonlisted
17368 
 
17369 
  def read(self, iprot):
17370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17372 
      return
17373 
    iprot.readStructBegin()
17374 
    while True:
17375 
      (fname, ftype, fid) = iprot.readFieldBegin()
17376 
      if ftype == TType.STOP:
17377 
        break
17378 
      if fid == 1:
17379 
        if ftype == TType.STRUCT:
17380 
          self.amazonlisted = Amazonlisted()
17381 
          self.amazonlisted.read(iprot)
17382 
        else:
17383 
          iprot.skip(ftype)
17384 
      else:
17385 
        iprot.skip(ftype)
17386 
      iprot.readFieldEnd()
17387 
    iprot.readStructEnd()
17388 
 
17389 
  def write(self, oprot):
17390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17392 
      return
17393 
    oprot.writeStructBegin('addAmazonItem_args')
17394 
    if self.amazonlisted is not None:
17395 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17396 
      self.amazonlisted.write(oprot)
17397 
      oprot.writeFieldEnd()
17398 
    oprot.writeFieldStop()
17399 
    oprot.writeStructEnd()
17400 
 
17401 
  def validate(self):
17402 
    return
17403 
 
17404 
 
17405 
  def __repr__(self):
17406 
    L = ['%s=%r' % (key, value)
17407 
      for key, value in self.__dict__.iteritems()]
17408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17409 
 
17410 
  def __eq__(self, other):
17411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17412 
 
17413 
  def __ne__(self, other):
17414 
    return not (self == other)
17415 
 
17416 
class addAmazonItem_result:
17417 
 
17418 
  thrift_spec = (
17419 
  )
17420 
 
17421 
  def read(self, iprot):
17422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17424 
      return
17425 
    iprot.readStructBegin()
17426 
    while True:
17427 
      (fname, ftype, fid) = iprot.readFieldBegin()
17428 
      if ftype == TType.STOP:
17429 
        break
17430 
      else:
17431 
        iprot.skip(ftype)
17432 
      iprot.readFieldEnd()
17433 
    iprot.readStructEnd()
17434 
 
17435 
  def write(self, oprot):
17436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17438 
      return
17439 
    oprot.writeStructBegin('addAmazonItem_result')
17440 
    oprot.writeFieldStop()
17441 
    oprot.writeStructEnd()
17442 
 
17443 
  def validate(self):
17444 
    return
17445 
 
17446 
 
17447 
  def __repr__(self):
17448 
    L = ['%s=%r' % (key, value)
17449 
      for key, value in self.__dict__.iteritems()]
17450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17451 
 
17452 
  def __eq__(self, other):
17453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17454 
 
17455 
  def __ne__(self, other):
17456 
    return not (self == other)
7291 vikram.rag 17457 
 
17458 
class getAsinItems_args:
17459 
 
17460 
  thrift_spec = (
17461 
  )
17462 
 
17463 
  def read(self, iprot):
17464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17466 
      return
17467 
    iprot.readStructBegin()
17468 
    while True:
17469 
      (fname, ftype, fid) = iprot.readFieldBegin()
17470 
      if ftype == TType.STOP:
17471 
        break
17472 
      else:
17473 
        iprot.skip(ftype)
17474 
      iprot.readFieldEnd()
17475 
    iprot.readStructEnd()
17476 
 
17477 
  def write(self, oprot):
17478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17480 
      return
17481 
    oprot.writeStructBegin('getAsinItems_args')
17482 
    oprot.writeFieldStop()
17483 
    oprot.writeStructEnd()
17484 
 
17485 
  def validate(self):
17486 
    return
17487 
 
17488 
 
17489 
  def __repr__(self):
17490 
    L = ['%s=%r' % (key, value)
17491 
      for key, value in self.__dict__.iteritems()]
17492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17493 
 
17494 
  def __eq__(self, other):
17495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17496 
 
17497 
  def __ne__(self, other):
17498 
    return not (self == other)
17499 
 
17500 
class getAsinItems_result:
17501 
  """
17502 
  Attributes:
17503 
   - success
17504 
  """
17505 
 
17506 
  thrift_spec = (
17507 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17508 
  )
17509 
 
17510 
  def __init__(self, success=None,):
17511 
    self.success = success
17512 
 
17513 
  def read(self, iprot):
17514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17516 
      return
17517 
    iprot.readStructBegin()
17518 
    while True:
17519 
      (fname, ftype, fid) = iprot.readFieldBegin()
17520 
      if ftype == TType.STOP:
17521 
        break
17522 
      if fid == 0:
17523 
        if ftype == TType.LIST:
17524 
          self.success = []
7438 amit.gupta 17525 
          (_etype347, _size344) = iprot.readListBegin()
17526 
          for _i348 in xrange(_size344):
17527 
            _elem349 = Item()
17528 
            _elem349.read(iprot)
17529 
            self.success.append(_elem349)
7291 vikram.rag 17530 
          iprot.readListEnd()
17531 
        else:
17532 
          iprot.skip(ftype)
17533 
      else:
17534 
        iprot.skip(ftype)
17535 
      iprot.readFieldEnd()
17536 
    iprot.readStructEnd()
17537 
 
17538 
  def write(self, oprot):
17539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17541 
      return
17542 
    oprot.writeStructBegin('getAsinItems_result')
17543 
    if self.success is not None:
17544 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17545 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17546 
      for iter350 in self.success:
17547 
        iter350.write(oprot)
7291 vikram.rag 17548 
      oprot.writeListEnd()
17549 
      oprot.writeFieldEnd()
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)
17567 
 
17568 
class getAllFbaListedItems_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('getAllFbaListedItems_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 getAllFbaListedItems_result:
17611 
  """
17612 
  Attributes:
17613 
   - success
17614 
  """
17615 
 
17616 
  thrift_spec = (
17617 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.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 
          (_etype354, _size351) = iprot.readListBegin()
17636 
          for _i355 in xrange(_size351):
17637 
            _elem356 = Amazonlisted()
17638 
            _elem356.read(iprot)
17639 
            self.success.append(_elem356)
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('getAllFbaListedItems_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 iter357 in self.success:
17657 
        iter357.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 getAllNonFbaListedItems_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('getAllNonFbaListedItems_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 getAllNonFbaListedItems_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 
          (_etype361, _size358) = iprot.readListBegin()
17746 
          for _i362 in xrange(_size358):
17747 
            _elem363 = Amazonlisted()
17748 
            _elem363.read(iprot)
17749 
            self.success.append(_elem363)
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('getAllNonFbaListedItems_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 iter364 in self.success:
17767 
        iter364.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)