Subversion Repositories SmartDukaan

Rev

Rev 7340 | Rev 7382 | 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 
 
46 
  def getItemStatusDescription(self, itemId):
47 
    """
48 
    Parameters:
49 
     - itemId
50 
    """
51 
    pass
52 
 
53 
  def startItemOn(self, item_id, timestamp):
54 
    """
55 
    Parameters:
56 
     - item_id
57 
     - timestamp
58 
    """
59 
    pass
60 
 
61 
  def retireItemOn(self, item_id, timestamp):
62 
    """
63 
    Parameters:
64 
     - item_id
65 
     - timestamp
66 
    """
67 
    pass
68 
 
69 
  def changeItemStatus(self, item_id, timestamp, newstatus):
70 
    """
71 
    Parameters:
72 
     - item_id
73 
     - timestamp
74 
     - newstatus
75 
    """
76 
    pass
77 
 
78 
  def getItem(self, item_id):
79 
    """
80 
    Parameters:
81 
     - item_id
82 
    """
83 
    pass
84 
 
85 
  def getItemsByCatalogId(self, catalog_item_id):
86 
    """
87 
    Parameters:
88 
     - catalog_item_id
89 
    """
90 
    pass
91 
 
92 
  def getValidItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getAllItems(self, isActive):
100 
    """
101 
    Parameters:
102 
     - isActive
103 
    """
104 
    pass
105 
 
106 
  def getAllItemsByStatus(self, itemStatus):
107 
    """
108 
    Parameters:
109 
     - itemStatus
110 
    """
111 
    pass
112 
 
113 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
114 
    """
115 
    Parameters:
116 
     - entityId
117 
     - category
118 
     - brand
119 
     - modelName
120 
     - modelNumber
121 
    """
122 
    pass
123 
 
124 
  def getAllItemsInRange(self, offset, limit):
125 
    """
126 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
127 
 
128 
    Parameters:
129 
     - offset
130 
     - limit
131 
    """
132 
    pass
133 
 
134 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
135 
    """
136 
    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.
137 
 
138 
    Parameters:
139 
     - itemStatus
140 
     - offset
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getItemCountByStatus(self, useStatus, itemStatus):
146 
    """
147 
    Gets a count of all items by status
148 
 
149 
    Parameters:
150 
     - useStatus
151 
     - itemStatus
152 
    """
153 
    pass
154 
 
155 
  def getBestSellers(self, ):
156 
    pass
157 
 
158 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
159 
    """
160 
    Parameters:
161 
     - beginIndex
162 
     - totalItems
163 
     - brand
164 
     - category
165 
    """
166 
    pass
167 
 
168 
  def getBestSellersCount(self, ):
169 
    pass
170 
 
171 
  def getBestDeals(self, ):
172 
    pass
173 
 
174 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
175 
    """
176 
    Parameters:
177 
     - beginIndex
178 
     - totalItems
179 
     - brand
180 
     - category
181 
    """
182 
    pass
183 
 
184 
  def getBestDealsCount(self, ):
185 
    pass
186 
 
187 
  def getComingSoon(self, ):
188 
    pass
189 
 
190 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
191 
    """
192 
    Parameters:
193 
     - beginIndex
194 
     - totalItems
195 
     - brand
196 
     - category
197 
    """
198 
    pass
199 
 
200 
  def getComingSoonCount(self, ):
201 
    pass
202 
 
203 
  def getLatestArrivals(self, ):
204 
    """
205 
    Returns a list of items sorted in the descending order by start date.
206 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
207 
    """
208 
    pass
209 
 
210 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
211 
    """
212 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
213 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
214 
 
215 
    Parameters:
216 
     - beginIndex
217 
     - totalItems
218 
     - brand
219 
     - categories
220 
    """
221 
    pass
222 
 
223 
  def getLatestArrivalsCount(self, ):
224 
    """
225 
    Get the total number of latest arrivals we are willing to show.
226 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
227 
    """
228 
    pass
229 
 
230 
  def generateNewEntityID(self, ):
231 
    pass
232 
 
233 
  def addCategory(self, category):
234 
    """
235 
    All category related functions
236 
 
237 
    Parameters:
238 
     - category
239 
    """
240 
    pass
241 
 
242 
  def getCategory(self, id):
243 
    """
244 
    Parameters:
245 
     - id
246 
    """
247 
    pass
248 
 
249 
  def getAllCategories(self, ):
250 
    pass
251 
 
252 
  def getAllSimilarItems(self, itemId):
253 
    """
254 
    Returns the list of similar items.
255 
 
256 
    Parameters:
257 
     - itemId
258 
    """
259 
    pass
260 
 
261 
  def addSimilarItem(self, itemId, catalogItemId):
262 
    """
263 
    Adds similar item.
264 
 
265 
    Parameters:
266 
     - itemId
267 
     - catalogItemId
268 
    """
269 
    pass
270 
 
6512 kshitij.so 271 
  def addTag(self, displayName, itemId):
272 
    """
273 
    Tag Related
274 
 
275 
    Parameters:
276 
     - displayName
277 
     - itemId
278 
    """
279 
    pass
280 
 
281 
  def deleteEntityTag(self, displayName, itemId):
282 
    """
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteTag(self, displayName):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
    """
294 
    pass
295 
 
296 
  def getAllTags(self, ):
297 
    pass
298 
 
299 
  def getAllEntitiesByTagName(self, displayName):
300 
    """
301 
    Parameters:
302 
     - displayName
303 
    """
304 
    pass
305 
 
6845 amit.gupta 306 
  def getAllEntityTags(self, ):
307 
    pass
308 
 
6850 kshitij.so 309 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
310 
    """
311 
    Parameters:
312 
     - bannerName
313 
     - imageName
314 
     - link
315 
     - priority
316 
     - isActive
317 
     - hasMap
318 
    """
319 
    pass
320 
 
321 
  def getAllBanners(self, ):
322 
    pass
323 
 
324 
  def deleteBanner(self, bannerName):
325 
    """
326 
    Parameters:
327 
     - bannerName
328 
    """
329 
    pass
330 
 
331 
  def getBannerDetails(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getActiveBanners(self, ):
339 
    pass
340 
 
6849 kshitij.so 341 
  def addBannerMap(self, bannerName, mapLink, coordinates):
342 
    """
343 
    Parameters:
344 
     - bannerName
345 
     - mapLink
346 
     - coordinates
347 
    """
348 
    pass
349 
 
350 
  def deleteBannerMap(self, bannerName):
351 
    """
352 
    Parameters:
353 
     - bannerName
354 
    """
355 
    pass
356 
 
357 
  def getBannerMapDetails(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
5944 mandeep.dh 364 
  def deleteSimilarItem(self, itemId, catalogItemId):
365 
    """
366 
    Delete similar item.
367 
 
368 
    Parameters:
369 
     - itemId
370 
     - catalogItemId
371 
    """
372 
    pass
373 
 
374 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
375 
    """
376 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
377 
    If yes, returns the itemId else returns 0
378 
 
379 
    Parameters:
380 
     - brand
381 
     - modelNumber
382 
     - modelName
383 
     - color
384 
    """
385 
    pass
386 
 
387 
  def validateRiskyStatus(self, itemId):
388 
    """
389 
    Check wether item is risky and change status if inventory is not available for risky items
390 
 
391 
    Parameters:
392 
     - itemId
393 
    """
394 
    pass
395 
 
396 
  def changeItemRiskyFlag(self, itemId, risky):
397 
    """
398 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
399 
 
400 
    Parameters:
401 
     - itemId
402 
     - risky
403 
    """
404 
    pass
405 
 
406 
  def getItemsByRiskyFlag(self, ):
407 
    """
408 
    Returns list of items marked as risky.
409 
    """
410 
    pass
411 
 
412 
  def getItemsForMasterSheet(self, category, brand):
413 
    """
414 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
415 
 
416 
    Parameters:
417 
     - category
418 
     - brand
419 
    """
420 
    pass
421 
 
422 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
423 
    """
424 
    Returns list of catalog ids of items with same similarity index as of the given itemId
425 
 
426 
    Parameters:
427 
     - beginIndex
428 
     - totalItems
429 
     - itemId
430 
    """
431 
    pass
432 
 
433 
  def addProductNotification(self, itemId, email):
434 
    """
435 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
436 
 
437 
    Parameters:
438 
     - itemId
439 
     - email
440 
    """
441 
    pass
442 
 
443 
  def sendProductNotifications(self, ):
444 
    """
445 
    Send the product notifications to the users for items which has stock.
446 
    """
447 
    pass
448 
 
449 
  def getAllBrandsByCategory(self, categoryId):
450 
    """
451 
    Returns list of brand names for a given category Id
452 
 
453 
    Parameters:
454 
     - categoryId
455 
    """
456 
    pass
457 
 
458 
  def getAllBrands(self, ):
459 
    """
460 
    Returns list of brand names
461 
    """
462 
    pass
463 
 
464 
  def getAllSources(self, ):
465 
    """
466 
    Return list of all sources
467 
    """
468 
    pass
469 
 
470 
  def getItemPricingBySource(self, itemId, sourceId):
471 
    """
472 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
473 
 
474 
    Parameters:
475 
     - itemId
476 
     - sourceId
477 
    """
478 
    pass
479 
 
480 
  def addSourceItemPricing(self, sourceItemPricing):
481 
    """
482 
    Adds prices to be displayed corresponding to the item if user comes from a source.
483 
    If item is not found or source is not found, it will throw exception.
484 
 
485 
    Parameters:
486 
     - sourceItemPricing
487 
    """
488 
    pass
489 
 
490 
  def getAllSourcePricing(self, itemId):
491 
    """
492 
    Returns the list of source pricing information of an item.
493 
    Raises an exception if item not found corresponding to itemId
494 
 
495 
    Parameters:
496 
     - itemId
497 
    """
498 
    pass
499 
 
500 
  def getItemForSource(self, item_id, sourceId):
501 
    """
502 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
503 
 
504 
    Parameters:
505 
     - item_id
506 
     - sourceId
507 
    """
508 
    pass
509 
 
510 
  def searchItemsInRange(self, searchTerms, offset, limit):
511 
    """
512 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
513 
 
514 
    Parameters:
515 
     - searchTerms
516 
     - offset
517 
     - limit
518 
    """
519 
    pass
520 
 
521 
  def getSearchResultCount(self, searchTerms):
522 
    """
523 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
524 
 
525 
    Parameters:
526 
     - searchTerms
527 
    """
528 
    pass
529 
 
530 
  def getProductNotifications(self, startDateTime):
531 
    """
532 
    Returns a list of product notifications added after a supplied datetime
533 
 
534 
    Parameters:
535 
     - startDateTime
536 
    """
537 
    pass
538 
 
539 
  def getProductNotificationRequestCount(self, startDateTime):
540 
    """
541 
    Returns a list of count of requests for product notification against each item
542 
 
543 
    Parameters:
544 
     - startDateTime
545 
    """
546 
    pass
547 
 
548 
  def addAuthorizationLog(self, itemId, username, reason):
549 
    """
550 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
551 
 
552 
    Parameters:
553 
     - itemId
554 
     - username
555 
     - reason
556 
    """
557 
    pass
558 
 
559 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
560 
    """
561 
    Parameters:
562 
     - catalog_item_id
563 
     - voucherType
564 
     - voucherAmount
565 
    """
566 
    pass
567 
 
568 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
569 
    """
570 
    Parameters:
571 
     - catalog_item_id
572 
     - voucherType
573 
    """
574 
    pass
575 
 
576 
  def getVoucherAmount(self, itemId, voucherType):
577 
    """
578 
    Parameters:
579 
     - itemId
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getAllItemVouchers(self, itemId):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
    """
589 
    pass
590 
 
591 
  def isValidCatalogItemId(self, catalog_item_id):
592 
    """
593 
    Parameters:
594 
     - catalog_item_id
595 
    """
596 
    pass
597 
 
7330 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 599 
    """
600 
    Parameters:
601 
     - itemId
7330 amit.gupta 602 
     - stateId
6039 amit.gupta 603 
     - price
604 
    """
605 
    pass
5944 mandeep.dh 606 
 
6039 amit.gupta 607 
  def getVatAmountForItem(self, itemId, price):
608 
    """
609 
    Parameters:
610 
     - itemId
611 
     - price
612 
    """
613 
    pass
614 
 
6531 vikram.rag 615 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
616 
    """
617 
    Parameters:
618 
     - offset
619 
     - limit
620 
    """
621 
    pass
6039 amit.gupta 622 
 
6821 amar.kumar 623 
  def getAllAliveItems(self, ):
624 
    pass
625 
 
6921 anupam.sin 626 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 627 
    """
628 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 629 
 
6805 anupam.sin 630 
    Parameters:
631 
     - itemId
6921 anupam.sin 632 
     - price
6805 anupam.sin 633 
     - insurerId
634 
     - quantity
635 
    """
636 
    pass
637 
 
638 
  def getInsurer(self, insurerId):
639 
    """
640 
    Parameters:
641 
     - insurerId
642 
    """
643 
    pass
644 
 
6838 vikram.rag 645 
  def getAllInsurers(self, ):
646 
    pass
6805 anupam.sin 647 
 
6962 rajveer 648 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
649 
    """
650 
    Parameters:
651 
     - insurerId
652 
     - amount
653 
    """
654 
    pass
6838 vikram.rag 655 
 
7190 amar.kumar 656 
  def getFreebieForItem(self, itemId):
657 
    """
658 
    Parameters:
659 
     - itemId
660 
    """
661 
    pass
6962 rajveer 662 
 
7190 amar.kumar 663 
  def addOrUpdateFreebieForItem(self, freebieItem):
664 
    """
665 
    Parameters:
666 
     - freebieItem
667 
    """
668 
    pass
669 
 
7272 amit.gupta 670 
  def addOrUpdateBrandInfo(self, brandInfo):
671 
    """
672 
    Parameters:
673 
     - brandInfo
674 
    """
675 
    pass
676 
 
677 
  def getBrandInfo(self, ):
678 
    pass
679 
 
7256 rajveer 680 
  def getStorePricing(self, itemId):
681 
    """
682 
    Parameters:
683 
     - itemId
684 
    """
685 
    pass
7190 amar.kumar 686 
 
7306 rajveer 687 
  def getStorePricings(self, itemIds):
688 
    """
689 
    Parameters:
690 
     - itemIds
691 
    """
692 
    pass
693 
 
7265 rajveer 694 
  def updateStorePricing(self, sp):
695 
    """
696 
    Parameters:
697 
     - sp
698 
    """
699 
    pass
7256 rajveer 700 
 
7281 kshitij.so 701 
  def getAllAmazonListedItems(self, ):
702 
    pass
7265 rajveer 703 
 
7281 kshitij.so 704 
  def getAmazonItemDetails(self, itemId):
705 
    """
706 
    Parameters:
707 
     - itemId
708 
    """
709 
    pass
710 
 
7367 kshitij.so 711 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 712 
    """
713 
    Parameters:
714 
     - itemId
715 
     - fbaPrice
716 
     - sellingPrice
717 
     - isFba
718 
     - isNonFba
719 
     - isInventoryOverride
7367 kshitij.so 720 
     - handlingTime
721 
     - isCustomTime
7281 kshitij.so 722 
    """
723 
    pass
724 
 
725 
  def addAmazonItem(self, amazonlisted):
726 
    """
727 
    Parameters:
728 
     - amazonlisted
729 
    """
730 
    pass
731 
 
7291 vikram.rag 732 
  def getAsinItems(self, ):
733 
    pass
7281 kshitij.so 734 
 
7291 vikram.rag 735 
  def getAllFbaListedItems(self, ):
736 
    pass
737 
 
738 
  def getAllNonFbaListedItems(self, ):
739 
    pass
740 
 
741 
 
5944 mandeep.dh 742 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
743 
  def __init__(self, iprot, oprot=None):
744 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
745 
 
746 
  def addItem(self, item):
747 
    """
748 
    Availability and inventory attributes
749 
 
750 
    Parameters:
751 
     - item
752 
    """
753 
    self.send_addItem(item)
754 
    return self.recv_addItem()
755 
 
756 
  def send_addItem(self, item):
757 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
758 
    args = addItem_args()
759 
    args.item = item
760 
    args.write(self._oprot)
761 
    self._oprot.writeMessageEnd()
762 
    self._oprot.trans.flush()
763 
 
764 
  def recv_addItem(self, ):
765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
766 
    if mtype == TMessageType.EXCEPTION:
767 
      x = TApplicationException()
768 
      x.read(self._iprot)
769 
      self._iprot.readMessageEnd()
770 
      raise x
771 
    result = addItem_result()
772 
    result.read(self._iprot)
773 
    self._iprot.readMessageEnd()
774 
    if result.success is not None:
775 
      return result.success
776 
    if result.cex is not None:
777 
      raise result.cex
778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
779 
 
780 
  def updateItem(self, item):
781 
    """
782 
    Parameters:
783 
     - item
784 
    """
785 
    self.send_updateItem(item)
786 
    return self.recv_updateItem()
787 
 
788 
  def send_updateItem(self, item):
789 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
790 
    args = updateItem_args()
791 
    args.item = item
792 
    args.write(self._oprot)
793 
    self._oprot.writeMessageEnd()
794 
    self._oprot.trans.flush()
795 
 
796 
  def recv_updateItem(self, ):
797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
798 
    if mtype == TMessageType.EXCEPTION:
799 
      x = TApplicationException()
800 
      x.read(self._iprot)
801 
      self._iprot.readMessageEnd()
802 
      raise x
803 
    result = updateItem_result()
804 
    result.read(self._iprot)
805 
    self._iprot.readMessageEnd()
806 
    if result.success is not None:
807 
      return result.success
808 
    if result.cex is not None:
809 
      raise result.cex
810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
811 
 
812 
  def isActive(self, itemId):
813 
    """
814 
    Checks if the item given to the corresponding itemId is active. If it's active,
815 
    whether it's risky and if it's risky, its inventory position.
816 
 
817 
    Parameters:
818 
     - itemId
819 
    """
820 
    self.send_isActive(itemId)
821 
    return self.recv_isActive()
822 
 
823 
  def send_isActive(self, itemId):
824 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
825 
    args = isActive_args()
826 
    args.itemId = itemId
827 
    args.write(self._oprot)
828 
    self._oprot.writeMessageEnd()
829 
    self._oprot.trans.flush()
830 
 
831 
  def recv_isActive(self, ):
832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
833 
    if mtype == TMessageType.EXCEPTION:
834 
      x = TApplicationException()
835 
      x.read(self._iprot)
836 
      self._iprot.readMessageEnd()
837 
      raise x
838 
    result = isActive_result()
839 
    result.read(self._iprot)
840 
    self._iprot.readMessageEnd()
841 
    if result.success is not None:
842 
      return result.success
843 
    if result.isex is not None:
844 
      raise result.isex
845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
846 
 
847 
  def getItemStatusDescription(self, itemId):
848 
    """
849 
    Parameters:
850 
     - itemId
851 
    """
852 
    self.send_getItemStatusDescription(itemId)
853 
    return self.recv_getItemStatusDescription()
854 
 
855 
  def send_getItemStatusDescription(self, itemId):
856 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
857 
    args = getItemStatusDescription_args()
858 
    args.itemId = itemId
859 
    args.write(self._oprot)
860 
    self._oprot.writeMessageEnd()
861 
    self._oprot.trans.flush()
862 
 
863 
  def recv_getItemStatusDescription(self, ):
864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
865 
    if mtype == TMessageType.EXCEPTION:
866 
      x = TApplicationException()
867 
      x.read(self._iprot)
868 
      self._iprot.readMessageEnd()
869 
      raise x
870 
    result = getItemStatusDescription_result()
871 
    result.read(self._iprot)
872 
    self._iprot.readMessageEnd()
873 
    if result.success is not None:
874 
      return result.success
875 
    if result.isex is not None:
876 
      raise result.isex
877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
878 
 
879 
  def startItemOn(self, item_id, timestamp):
880 
    """
881 
    Parameters:
882 
     - item_id
883 
     - timestamp
884 
    """
885 
    self.send_startItemOn(item_id, timestamp)
886 
    self.recv_startItemOn()
887 
 
888 
  def send_startItemOn(self, item_id, timestamp):
889 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
890 
    args = startItemOn_args()
891 
    args.item_id = item_id
892 
    args.timestamp = timestamp
893 
    args.write(self._oprot)
894 
    self._oprot.writeMessageEnd()
895 
    self._oprot.trans.flush()
896 
 
897 
  def recv_startItemOn(self, ):
898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
899 
    if mtype == TMessageType.EXCEPTION:
900 
      x = TApplicationException()
901 
      x.read(self._iprot)
902 
      self._iprot.readMessageEnd()
903 
      raise x
904 
    result = startItemOn_result()
905 
    result.read(self._iprot)
906 
    self._iprot.readMessageEnd()
907 
    if result.cex is not None:
908 
      raise result.cex
909 
    return
910 
 
911 
  def retireItemOn(self, item_id, timestamp):
912 
    """
913 
    Parameters:
914 
     - item_id
915 
     - timestamp
916 
    """
917 
    self.send_retireItemOn(item_id, timestamp)
918 
    self.recv_retireItemOn()
919 
 
920 
  def send_retireItemOn(self, item_id, timestamp):
921 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
922 
    args = retireItemOn_args()
923 
    args.item_id = item_id
924 
    args.timestamp = timestamp
925 
    args.write(self._oprot)
926 
    self._oprot.writeMessageEnd()
927 
    self._oprot.trans.flush()
928 
 
929 
  def recv_retireItemOn(self, ):
930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
931 
    if mtype == TMessageType.EXCEPTION:
932 
      x = TApplicationException()
933 
      x.read(self._iprot)
934 
      self._iprot.readMessageEnd()
935 
      raise x
936 
    result = retireItemOn_result()
937 
    result.read(self._iprot)
938 
    self._iprot.readMessageEnd()
939 
    if result.cex is not None:
940 
      raise result.cex
941 
    return
942 
 
943 
  def changeItemStatus(self, item_id, timestamp, newstatus):
944 
    """
945 
    Parameters:
946 
     - item_id
947 
     - timestamp
948 
     - newstatus
949 
    """
950 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
951 
    self.recv_changeItemStatus()
952 
 
953 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
954 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
955 
    args = changeItemStatus_args()
956 
    args.item_id = item_id
957 
    args.timestamp = timestamp
958 
    args.newstatus = newstatus
959 
    args.write(self._oprot)
960 
    self._oprot.writeMessageEnd()
961 
    self._oprot.trans.flush()
962 
 
963 
  def recv_changeItemStatus(self, ):
964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
965 
    if mtype == TMessageType.EXCEPTION:
966 
      x = TApplicationException()
967 
      x.read(self._iprot)
968 
      self._iprot.readMessageEnd()
969 
      raise x
970 
    result = changeItemStatus_result()
971 
    result.read(self._iprot)
972 
    self._iprot.readMessageEnd()
973 
    if result.cex is not None:
974 
      raise result.cex
975 
    return
976 
 
977 
  def getItem(self, item_id):
978 
    """
979 
    Parameters:
980 
     - item_id
981 
    """
982 
    self.send_getItem(item_id)
983 
    return self.recv_getItem()
984 
 
985 
  def send_getItem(self, item_id):
986 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
987 
    args = getItem_args()
988 
    args.item_id = item_id
989 
    args.write(self._oprot)
990 
    self._oprot.writeMessageEnd()
991 
    self._oprot.trans.flush()
992 
 
993 
  def recv_getItem(self, ):
994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
995 
    if mtype == TMessageType.EXCEPTION:
996 
      x = TApplicationException()
997 
      x.read(self._iprot)
998 
      self._iprot.readMessageEnd()
999 
      raise x
1000 
    result = getItem_result()
1001 
    result.read(self._iprot)
1002 
    self._iprot.readMessageEnd()
1003 
    if result.success is not None:
1004 
      return result.success
1005 
    if result.cex is not None:
1006 
      raise result.cex
1007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1008 
 
1009 
  def getItemsByCatalogId(self, catalog_item_id):
1010 
    """
1011 
    Parameters:
1012 
     - catalog_item_id
1013 
    """
1014 
    self.send_getItemsByCatalogId(catalog_item_id)
1015 
    return self.recv_getItemsByCatalogId()
1016 
 
1017 
  def send_getItemsByCatalogId(self, catalog_item_id):
1018 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1019 
    args = getItemsByCatalogId_args()
1020 
    args.catalog_item_id = catalog_item_id
1021 
    args.write(self._oprot)
1022 
    self._oprot.writeMessageEnd()
1023 
    self._oprot.trans.flush()
1024 
 
1025 
  def recv_getItemsByCatalogId(self, ):
1026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1027 
    if mtype == TMessageType.EXCEPTION:
1028 
      x = TApplicationException()
1029 
      x.read(self._iprot)
1030 
      self._iprot.readMessageEnd()
1031 
      raise x
1032 
    result = getItemsByCatalogId_result()
1033 
    result.read(self._iprot)
1034 
    self._iprot.readMessageEnd()
1035 
    if result.success is not None:
1036 
      return result.success
1037 
    if result.cex is not None:
1038 
      raise result.cex
1039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1040 
 
1041 
  def getValidItemsByCatalogId(self, catalog_item_id):
1042 
    """
1043 
    Parameters:
1044 
     - catalog_item_id
1045 
    """
1046 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1047 
    return self.recv_getValidItemsByCatalogId()
1048 
 
1049 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1050 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1051 
    args = getValidItemsByCatalogId_args()
1052 
    args.catalog_item_id = catalog_item_id
1053 
    args.write(self._oprot)
1054 
    self._oprot.writeMessageEnd()
1055 
    self._oprot.trans.flush()
1056 
 
1057 
  def recv_getValidItemsByCatalogId(self, ):
1058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1059 
    if mtype == TMessageType.EXCEPTION:
1060 
      x = TApplicationException()
1061 
      x.read(self._iprot)
1062 
      self._iprot.readMessageEnd()
1063 
      raise x
1064 
    result = getValidItemsByCatalogId_result()
1065 
    result.read(self._iprot)
1066 
    self._iprot.readMessageEnd()
1067 
    if result.success is not None:
1068 
      return result.success
1069 
    if result.cex is not None:
1070 
      raise result.cex
1071 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1072 
 
1073 
  def getAllItems(self, isActive):
1074 
    """
1075 
    Parameters:
1076 
     - isActive
1077 
    """
1078 
    self.send_getAllItems(isActive)
1079 
    return self.recv_getAllItems()
1080 
 
1081 
  def send_getAllItems(self, isActive):
1082 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1083 
    args = getAllItems_args()
1084 
    args.isActive = isActive
1085 
    args.write(self._oprot)
1086 
    self._oprot.writeMessageEnd()
1087 
    self._oprot.trans.flush()
1088 
 
1089 
  def recv_getAllItems(self, ):
1090 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1091 
    if mtype == TMessageType.EXCEPTION:
1092 
      x = TApplicationException()
1093 
      x.read(self._iprot)
1094 
      self._iprot.readMessageEnd()
1095 
      raise x
1096 
    result = getAllItems_result()
1097 
    result.read(self._iprot)
1098 
    self._iprot.readMessageEnd()
1099 
    if result.success is not None:
1100 
      return result.success
1101 
    if result.cex is not None:
1102 
      raise result.cex
1103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1104 
 
1105 
  def getAllItemsByStatus(self, itemStatus):
1106 
    """
1107 
    Parameters:
1108 
     - itemStatus
1109 
    """
1110 
    self.send_getAllItemsByStatus(itemStatus)
1111 
    return self.recv_getAllItemsByStatus()
1112 
 
1113 
  def send_getAllItemsByStatus(self, itemStatus):
1114 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1115 
    args = getAllItemsByStatus_args()
1116 
    args.itemStatus = itemStatus
1117 
    args.write(self._oprot)
1118 
    self._oprot.writeMessageEnd()
1119 
    self._oprot.trans.flush()
1120 
 
1121 
  def recv_getAllItemsByStatus(self, ):
1122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1123 
    if mtype == TMessageType.EXCEPTION:
1124 
      x = TApplicationException()
1125 
      x.read(self._iprot)
1126 
      self._iprot.readMessageEnd()
1127 
      raise x
1128 
    result = getAllItemsByStatus_result()
1129 
    result.read(self._iprot)
1130 
    self._iprot.readMessageEnd()
1131 
    if result.success is not None:
1132 
      return result.success
1133 
    if result.cex is not None:
1134 
      raise result.cex
1135 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1136 
 
1137 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1138 
    """
1139 
    Parameters:
1140 
     - entityId
1141 
     - category
1142 
     - brand
1143 
     - modelName
1144 
     - modelNumber
1145 
    """
1146 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1147 
    return self.recv_markItemAsContentComplete()
1148 
 
1149 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1150 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1151 
    args = markItemAsContentComplete_args()
1152 
    args.entityId = entityId
1153 
    args.category = category
1154 
    args.brand = brand
1155 
    args.modelName = modelName
1156 
    args.modelNumber = modelNumber
1157 
    args.write(self._oprot)
1158 
    self._oprot.writeMessageEnd()
1159 
    self._oprot.trans.flush()
1160 
 
1161 
  def recv_markItemAsContentComplete(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 = markItemAsContentComplete_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, "markItemAsContentComplete failed: unknown result");
1176 
 
1177 
  def getAllItemsInRange(self, offset, limit):
1178 
    """
1179 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1180 
 
1181 
    Parameters:
1182 
     - offset
1183 
     - limit
1184 
    """
1185 
    self.send_getAllItemsInRange(offset, limit)
1186 
    return self.recv_getAllItemsInRange()
1187 
 
1188 
  def send_getAllItemsInRange(self, offset, limit):
1189 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1190 
    args = getAllItemsInRange_args()
1191 
    args.offset = offset
1192 
    args.limit = limit
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getAllItemsInRange(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getAllItemsInRange_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success is not None:
1208 
      return result.success
1209 
    if result.cex is not None:
1210 
      raise result.cex
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1212 
 
1213 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1214 
    """
1215 
    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.
1216 
 
1217 
    Parameters:
1218 
     - itemStatus
1219 
     - offset
1220 
     - limit
1221 
    """
1222 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1223 
    return self.recv_getAllItemsByStatusInRange()
1224 
 
1225 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1226 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1227 
    args = getAllItemsByStatusInRange_args()
1228 
    args.itemStatus = itemStatus
1229 
    args.offset = offset
1230 
    args.limit = limit
1231 
    args.write(self._oprot)
1232 
    self._oprot.writeMessageEnd()
1233 
    self._oprot.trans.flush()
1234 
 
1235 
  def recv_getAllItemsByStatusInRange(self, ):
1236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1237 
    if mtype == TMessageType.EXCEPTION:
1238 
      x = TApplicationException()
1239 
      x.read(self._iprot)
1240 
      self._iprot.readMessageEnd()
1241 
      raise x
1242 
    result = getAllItemsByStatusInRange_result()
1243 
    result.read(self._iprot)
1244 
    self._iprot.readMessageEnd()
1245 
    if result.success is not None:
1246 
      return result.success
1247 
    if result.cex is not None:
1248 
      raise result.cex
1249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1250 
 
1251 
  def getItemCountByStatus(self, useStatus, itemStatus):
1252 
    """
1253 
    Gets a count of all items by status
1254 
 
1255 
    Parameters:
1256 
     - useStatus
1257 
     - itemStatus
1258 
    """
1259 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1260 
    return self.recv_getItemCountByStatus()
1261 
 
1262 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1263 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1264 
    args = getItemCountByStatus_args()
1265 
    args.useStatus = useStatus
1266 
    args.itemStatus = itemStatus
1267 
    args.write(self._oprot)
1268 
    self._oprot.writeMessageEnd()
1269 
    self._oprot.trans.flush()
1270 
 
1271 
  def recv_getItemCountByStatus(self, ):
1272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1273 
    if mtype == TMessageType.EXCEPTION:
1274 
      x = TApplicationException()
1275 
      x.read(self._iprot)
1276 
      self._iprot.readMessageEnd()
1277 
      raise x
1278 
    result = getItemCountByStatus_result()
1279 
    result.read(self._iprot)
1280 
    self._iprot.readMessageEnd()
1281 
    if result.success is not None:
1282 
      return result.success
1283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1284 
 
1285 
  def getBestSellers(self, ):
1286 
    self.send_getBestSellers()
1287 
    return self.recv_getBestSellers()
1288 
 
1289 
  def send_getBestSellers(self, ):
1290 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1291 
    args = getBestSellers_args()
1292 
    args.write(self._oprot)
1293 
    self._oprot.writeMessageEnd()
1294 
    self._oprot.trans.flush()
1295 
 
1296 
  def recv_getBestSellers(self, ):
1297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1298 
    if mtype == TMessageType.EXCEPTION:
1299 
      x = TApplicationException()
1300 
      x.read(self._iprot)
1301 
      self._iprot.readMessageEnd()
1302 
      raise x
1303 
    result = getBestSellers_result()
1304 
    result.read(self._iprot)
1305 
    self._iprot.readMessageEnd()
1306 
    if result.success is not None:
1307 
      return result.success
1308 
    if result.isex is not None:
1309 
      raise result.isex
1310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1311 
 
1312 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1313 
    """
1314 
    Parameters:
1315 
     - beginIndex
1316 
     - totalItems
1317 
     - brand
1318 
     - category
1319 
    """
1320 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1321 
    return self.recv_getBestSellersCatalogIds()
1322 
 
1323 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1324 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1325 
    args = getBestSellersCatalogIds_args()
1326 
    args.beginIndex = beginIndex
1327 
    args.totalItems = totalItems
1328 
    args.brand = brand
1329 
    args.category = category
1330 
    args.write(self._oprot)
1331 
    self._oprot.writeMessageEnd()
1332 
    self._oprot.trans.flush()
1333 
 
1334 
  def recv_getBestSellersCatalogIds(self, ):
1335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1336 
    if mtype == TMessageType.EXCEPTION:
1337 
      x = TApplicationException()
1338 
      x.read(self._iprot)
1339 
      self._iprot.readMessageEnd()
1340 
      raise x
1341 
    result = getBestSellersCatalogIds_result()
1342 
    result.read(self._iprot)
1343 
    self._iprot.readMessageEnd()
1344 
    if result.success is not None:
1345 
      return result.success
1346 
    if result.cex is not None:
1347 
      raise result.cex
1348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1349 
 
1350 
  def getBestSellersCount(self, ):
1351 
    self.send_getBestSellersCount()
1352 
    return self.recv_getBestSellersCount()
1353 
 
1354 
  def send_getBestSellersCount(self, ):
1355 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1356 
    args = getBestSellersCount_args()
1357 
    args.write(self._oprot)
1358 
    self._oprot.writeMessageEnd()
1359 
    self._oprot.trans.flush()
1360 
 
1361 
  def recv_getBestSellersCount(self, ):
1362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1363 
    if mtype == TMessageType.EXCEPTION:
1364 
      x = TApplicationException()
1365 
      x.read(self._iprot)
1366 
      self._iprot.readMessageEnd()
1367 
      raise x
1368 
    result = getBestSellersCount_result()
1369 
    result.read(self._iprot)
1370 
    self._iprot.readMessageEnd()
1371 
    if result.success is not None:
1372 
      return result.success
1373 
    if result.cex is not None:
1374 
      raise result.cex
1375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1376 
 
1377 
  def getBestDeals(self, ):
1378 
    self.send_getBestDeals()
1379 
    return self.recv_getBestDeals()
1380 
 
1381 
  def send_getBestDeals(self, ):
1382 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1383 
    args = getBestDeals_args()
1384 
    args.write(self._oprot)
1385 
    self._oprot.writeMessageEnd()
1386 
    self._oprot.trans.flush()
1387 
 
1388 
  def recv_getBestDeals(self, ):
1389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1390 
    if mtype == TMessageType.EXCEPTION:
1391 
      x = TApplicationException()
1392 
      x.read(self._iprot)
1393 
      self._iprot.readMessageEnd()
1394 
      raise x
1395 
    result = getBestDeals_result()
1396 
    result.read(self._iprot)
1397 
    self._iprot.readMessageEnd()
1398 
    if result.success is not None:
1399 
      return result.success
1400 
    if result.isex is not None:
1401 
      raise result.isex
1402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1403 
 
1404 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1405 
    """
1406 
    Parameters:
1407 
     - beginIndex
1408 
     - totalItems
1409 
     - brand
1410 
     - category
1411 
    """
1412 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1413 
    return self.recv_getBestDealsCatalogIds()
1414 
 
1415 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1416 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1417 
    args = getBestDealsCatalogIds_args()
1418 
    args.beginIndex = beginIndex
1419 
    args.totalItems = totalItems
1420 
    args.brand = brand
1421 
    args.category = category
1422 
    args.write(self._oprot)
1423 
    self._oprot.writeMessageEnd()
1424 
    self._oprot.trans.flush()
1425 
 
1426 
  def recv_getBestDealsCatalogIds(self, ):
1427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1428 
    if mtype == TMessageType.EXCEPTION:
1429 
      x = TApplicationException()
1430 
      x.read(self._iprot)
1431 
      self._iprot.readMessageEnd()
1432 
      raise x
1433 
    result = getBestDealsCatalogIds_result()
1434 
    result.read(self._iprot)
1435 
    self._iprot.readMessageEnd()
1436 
    if result.success is not None:
1437 
      return result.success
1438 
    if result.cex is not None:
1439 
      raise result.cex
1440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1441 
 
1442 
  def getBestDealsCount(self, ):
1443 
    self.send_getBestDealsCount()
1444 
    return self.recv_getBestDealsCount()
1445 
 
1446 
  def send_getBestDealsCount(self, ):
1447 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1448 
    args = getBestDealsCount_args()
1449 
    args.write(self._oprot)
1450 
    self._oprot.writeMessageEnd()
1451 
    self._oprot.trans.flush()
1452 
 
1453 
  def recv_getBestDealsCount(self, ):
1454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1455 
    if mtype == TMessageType.EXCEPTION:
1456 
      x = TApplicationException()
1457 
      x.read(self._iprot)
1458 
      self._iprot.readMessageEnd()
1459 
      raise x
1460 
    result = getBestDealsCount_result()
1461 
    result.read(self._iprot)
1462 
    self._iprot.readMessageEnd()
1463 
    if result.success is not None:
1464 
      return result.success
1465 
    if result.cex is not None:
1466 
      raise result.cex
1467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1468 
 
1469 
  def getComingSoon(self, ):
1470 
    self.send_getComingSoon()
1471 
    return self.recv_getComingSoon()
1472 
 
1473 
  def send_getComingSoon(self, ):
1474 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1475 
    args = getComingSoon_args()
1476 
    args.write(self._oprot)
1477 
    self._oprot.writeMessageEnd()
1478 
    self._oprot.trans.flush()
1479 
 
1480 
  def recv_getComingSoon(self, ):
1481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1482 
    if mtype == TMessageType.EXCEPTION:
1483 
      x = TApplicationException()
1484 
      x.read(self._iprot)
1485 
      self._iprot.readMessageEnd()
1486 
      raise x
1487 
    result = getComingSoon_result()
1488 
    result.read(self._iprot)
1489 
    self._iprot.readMessageEnd()
1490 
    if result.success is not None:
1491 
      return result.success
1492 
    if result.isex is not None:
1493 
      raise result.isex
1494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1495 
 
1496 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1497 
    """
1498 
    Parameters:
1499 
     - beginIndex
1500 
     - totalItems
1501 
     - brand
1502 
     - category
1503 
    """
1504 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1505 
    return self.recv_getComingSoonCatalogIds()
1506 
 
1507 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1508 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1509 
    args = getComingSoonCatalogIds_args()
1510 
    args.beginIndex = beginIndex
1511 
    args.totalItems = totalItems
1512 
    args.brand = brand
1513 
    args.category = category
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getComingSoonCatalogIds(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getComingSoonCatalogIds_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
1528 
    if result.success is not None:
1529 
      return result.success
1530 
    if result.cex is not None:
1531 
      raise result.cex
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1533 
 
1534 
  def getComingSoonCount(self, ):
1535 
    self.send_getComingSoonCount()
1536 
    return self.recv_getComingSoonCount()
1537 
 
1538 
  def send_getComingSoonCount(self, ):
1539 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1540 
    args = getComingSoonCount_args()
1541 
    args.write(self._oprot)
1542 
    self._oprot.writeMessageEnd()
1543 
    self._oprot.trans.flush()
1544 
 
1545 
  def recv_getComingSoonCount(self, ):
1546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1547 
    if mtype == TMessageType.EXCEPTION:
1548 
      x = TApplicationException()
1549 
      x.read(self._iprot)
1550 
      self._iprot.readMessageEnd()
1551 
      raise x
1552 
    result = getComingSoonCount_result()
1553 
    result.read(self._iprot)
1554 
    self._iprot.readMessageEnd()
1555 
    if result.success is not None:
1556 
      return result.success
1557 
    if result.cex is not None:
1558 
      raise result.cex
1559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1560 
 
1561 
  def getLatestArrivals(self, ):
1562 
    """
1563 
    Returns a list of items sorted in the descending order by start date.
1564 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1565 
    """
1566 
    self.send_getLatestArrivals()
1567 
    return self.recv_getLatestArrivals()
1568 
 
1569 
  def send_getLatestArrivals(self, ):
1570 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1571 
    args = getLatestArrivals_args()
1572 
    args.write(self._oprot)
1573 
    self._oprot.writeMessageEnd()
1574 
    self._oprot.trans.flush()
1575 
 
1576 
  def recv_getLatestArrivals(self, ):
1577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1578 
    if mtype == TMessageType.EXCEPTION:
1579 
      x = TApplicationException()
1580 
      x.read(self._iprot)
1581 
      self._iprot.readMessageEnd()
1582 
      raise x
1583 
    result = getLatestArrivals_result()
1584 
    result.read(self._iprot)
1585 
    self._iprot.readMessageEnd()
1586 
    if result.success is not None:
1587 
      return result.success
1588 
    if result.isex is not None:
1589 
      raise result.isex
1590 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1591 
 
1592 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1593 
    """
1594 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1595 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1596 
 
1597 
    Parameters:
1598 
     - beginIndex
1599 
     - totalItems
1600 
     - brand
1601 
     - categories
1602 
    """
1603 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1604 
    return self.recv_getLatestArrivalsCatalogIds()
1605 
 
1606 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1607 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1608 
    args = getLatestArrivalsCatalogIds_args()
1609 
    args.beginIndex = beginIndex
1610 
    args.totalItems = totalItems
1611 
    args.brand = brand
1612 
    args.categories = categories
1613 
    args.write(self._oprot)
1614 
    self._oprot.writeMessageEnd()
1615 
    self._oprot.trans.flush()
1616 
 
1617 
  def recv_getLatestArrivalsCatalogIds(self, ):
1618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1619 
    if mtype == TMessageType.EXCEPTION:
1620 
      x = TApplicationException()
1621 
      x.read(self._iprot)
1622 
      self._iprot.readMessageEnd()
1623 
      raise x
1624 
    result = getLatestArrivalsCatalogIds_result()
1625 
    result.read(self._iprot)
1626 
    self._iprot.readMessageEnd()
1627 
    if result.success is not None:
1628 
      return result.success
1629 
    if result.cex is not None:
1630 
      raise result.cex
1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1632 
 
1633 
  def getLatestArrivalsCount(self, ):
1634 
    """
1635 
    Get the total number of latest arrivals we are willing to show.
1636 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1637 
    """
1638 
    self.send_getLatestArrivalsCount()
1639 
    return self.recv_getLatestArrivalsCount()
1640 
 
1641 
  def send_getLatestArrivalsCount(self, ):
1642 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1643 
    args = getLatestArrivalsCount_args()
1644 
    args.write(self._oprot)
1645 
    self._oprot.writeMessageEnd()
1646 
    self._oprot.trans.flush()
1647 
 
1648 
  def recv_getLatestArrivalsCount(self, ):
1649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1650 
    if mtype == TMessageType.EXCEPTION:
1651 
      x = TApplicationException()
1652 
      x.read(self._iprot)
1653 
      self._iprot.readMessageEnd()
1654 
      raise x
1655 
    result = getLatestArrivalsCount_result()
1656 
    result.read(self._iprot)
1657 
    self._iprot.readMessageEnd()
1658 
    if result.success is not None:
1659 
      return result.success
1660 
    if result.cex is not None:
1661 
      raise result.cex
1662 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1663 
 
1664 
  def generateNewEntityID(self, ):
1665 
    self.send_generateNewEntityID()
1666 
    return self.recv_generateNewEntityID()
1667 
 
1668 
  def send_generateNewEntityID(self, ):
1669 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1670 
    args = generateNewEntityID_args()
1671 
    args.write(self._oprot)
1672 
    self._oprot.writeMessageEnd()
1673 
    self._oprot.trans.flush()
1674 
 
1675 
  def recv_generateNewEntityID(self, ):
1676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1677 
    if mtype == TMessageType.EXCEPTION:
1678 
      x = TApplicationException()
1679 
      x.read(self._iprot)
1680 
      self._iprot.readMessageEnd()
1681 
      raise x
1682 
    result = generateNewEntityID_result()
1683 
    result.read(self._iprot)
1684 
    self._iprot.readMessageEnd()
1685 
    if result.success is not None:
1686 
      return result.success
1687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1688 
 
1689 
  def addCategory(self, category):
1690 
    """
1691 
    All category related functions
1692 
 
1693 
    Parameters:
1694 
     - category
1695 
    """
1696 
    self.send_addCategory(category)
1697 
    return self.recv_addCategory()
1698 
 
1699 
  def send_addCategory(self, category):
1700 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1701 
    args = addCategory_args()
1702 
    args.category = category
1703 
    args.write(self._oprot)
1704 
    self._oprot.writeMessageEnd()
1705 
    self._oprot.trans.flush()
1706 
 
1707 
  def recv_addCategory(self, ):
1708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1709 
    if mtype == TMessageType.EXCEPTION:
1710 
      x = TApplicationException()
1711 
      x.read(self._iprot)
1712 
      self._iprot.readMessageEnd()
1713 
      raise x
1714 
    result = addCategory_result()
1715 
    result.read(self._iprot)
1716 
    self._iprot.readMessageEnd()
1717 
    if result.success is not None:
1718 
      return result.success
1719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1720 
 
1721 
  def getCategory(self, id):
1722 
    """
1723 
    Parameters:
1724 
     - id
1725 
    """
1726 
    self.send_getCategory(id)
1727 
    return self.recv_getCategory()
1728 
 
1729 
  def send_getCategory(self, id):
1730 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1731 
    args = getCategory_args()
1732 
    args.id = id
1733 
    args.write(self._oprot)
1734 
    self._oprot.writeMessageEnd()
1735 
    self._oprot.trans.flush()
1736 
 
1737 
  def recv_getCategory(self, ):
1738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1739 
    if mtype == TMessageType.EXCEPTION:
1740 
      x = TApplicationException()
1741 
      x.read(self._iprot)
1742 
      self._iprot.readMessageEnd()
1743 
      raise x
1744 
    result = getCategory_result()
1745 
    result.read(self._iprot)
1746 
    self._iprot.readMessageEnd()
1747 
    if result.success is not None:
1748 
      return result.success
1749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1750 
 
1751 
  def getAllCategories(self, ):
1752 
    self.send_getAllCategories()
1753 
    return self.recv_getAllCategories()
1754 
 
1755 
  def send_getAllCategories(self, ):
1756 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1757 
    args = getAllCategories_args()
1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
1762 
  def recv_getAllCategories(self, ):
1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
1769 
    result = getAllCategories_result()
1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
1772 
    if result.success is not None:
1773 
      return result.success
1774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1775 
 
1776 
  def getAllSimilarItems(self, itemId):
1777 
    """
1778 
    Returns the list of similar items.
1779 
 
1780 
    Parameters:
1781 
     - itemId
1782 
    """
1783 
    self.send_getAllSimilarItems(itemId)
1784 
    return self.recv_getAllSimilarItems()
1785 
 
1786 
  def send_getAllSimilarItems(self, itemId):
1787 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1788 
    args = getAllSimilarItems_args()
1789 
    args.itemId = itemId
1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
1794 
  def recv_getAllSimilarItems(self, ):
1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
1801 
    result = getAllSimilarItems_result()
1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
1804 
    if result.success is not None:
1805 
      return result.success
1806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1807 
 
1808 
  def addSimilarItem(self, itemId, catalogItemId):
1809 
    """
1810 
    Adds similar item.
1811 
 
1812 
    Parameters:
1813 
     - itemId
1814 
     - catalogItemId
1815 
    """
1816 
    self.send_addSimilarItem(itemId, catalogItemId)
1817 
    return self.recv_addSimilarItem()
1818 
 
1819 
  def send_addSimilarItem(self, itemId, catalogItemId):
1820 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1821 
    args = addSimilarItem_args()
1822 
    args.itemId = itemId
1823 
    args.catalogItemId = catalogItemId
1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
1828 
  def recv_addSimilarItem(self, ):
1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
1835 
    result = addSimilarItem_result()
1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
1838 
    if result.success is not None:
1839 
      return result.success
1840 
    if result.cex is not None:
1841 
      raise result.cex
1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1843 
 
6512 kshitij.so 1844 
  def addTag(self, displayName, itemId):
1845 
    """
1846 
    Tag Related
1847 
 
1848 
    Parameters:
1849 
     - displayName
1850 
     - itemId
1851 
    """
1852 
    self.send_addTag(displayName, itemId)
1853 
    return self.recv_addTag()
1854 
 
1855 
  def send_addTag(self, displayName, itemId):
1856 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1857 
    args = addTag_args()
1858 
    args.displayName = displayName
1859 
    args.itemId = itemId
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_addTag(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = addTag_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
1874 
    if result.success is not None:
1875 
      return result.success
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1877 
 
1878 
  def deleteEntityTag(self, displayName, itemId):
1879 
    """
1880 
    Parameters:
1881 
     - displayName
1882 
     - itemId
1883 
    """
1884 
    self.send_deleteEntityTag(displayName, itemId)
1885 
    return self.recv_deleteEntityTag()
1886 
 
1887 
  def send_deleteEntityTag(self, displayName, itemId):
1888 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1889 
    args = deleteEntityTag_args()
1890 
    args.displayName = displayName
1891 
    args.itemId = itemId
1892 
    args.write(self._oprot)
1893 
    self._oprot.writeMessageEnd()
1894 
    self._oprot.trans.flush()
1895 
 
1896 
  def recv_deleteEntityTag(self, ):
1897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1898 
    if mtype == TMessageType.EXCEPTION:
1899 
      x = TApplicationException()
1900 
      x.read(self._iprot)
1901 
      self._iprot.readMessageEnd()
1902 
      raise x
1903 
    result = deleteEntityTag_result()
1904 
    result.read(self._iprot)
1905 
    self._iprot.readMessageEnd()
1906 
    if result.success is not None:
1907 
      return result.success
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1909 
 
1910 
  def deleteTag(self, displayName):
1911 
    """
1912 
    Parameters:
1913 
     - displayName
1914 
    """
1915 
    self.send_deleteTag(displayName)
1916 
    return self.recv_deleteTag()
1917 
 
1918 
  def send_deleteTag(self, displayName):
1919 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1920 
    args = deleteTag_args()
1921 
    args.displayName = displayName
1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
1926 
  def recv_deleteTag(self, ):
1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
1933 
    result = deleteTag_result()
1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
1936 
    if result.success is not None:
1937 
      return result.success
1938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1939 
 
1940 
  def getAllTags(self, ):
1941 
    self.send_getAllTags()
1942 
    return self.recv_getAllTags()
1943 
 
1944 
  def send_getAllTags(self, ):
1945 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1946 
    args = getAllTags_args()
1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
1951 
  def recv_getAllTags(self, ):
1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
1958 
    result = getAllTags_result()
1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
1961 
    if result.success is not None:
1962 
      return result.success
1963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1964 
 
1965 
  def getAllEntitiesByTagName(self, displayName):
1966 
    """
1967 
    Parameters:
1968 
     - displayName
1969 
    """
1970 
    self.send_getAllEntitiesByTagName(displayName)
1971 
    return self.recv_getAllEntitiesByTagName()
1972 
 
1973 
  def send_getAllEntitiesByTagName(self, displayName):
1974 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1975 
    args = getAllEntitiesByTagName_args()
1976 
    args.displayName = displayName
1977 
    args.write(self._oprot)
1978 
    self._oprot.writeMessageEnd()
1979 
    self._oprot.trans.flush()
1980 
 
1981 
  def recv_getAllEntitiesByTagName(self, ):
1982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1983 
    if mtype == TMessageType.EXCEPTION:
1984 
      x = TApplicationException()
1985 
      x.read(self._iprot)
1986 
      self._iprot.readMessageEnd()
1987 
      raise x
1988 
    result = getAllEntitiesByTagName_result()
1989 
    result.read(self._iprot)
1990 
    self._iprot.readMessageEnd()
1991 
    if result.success is not None:
1992 
      return result.success
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1994 
 
6845 amit.gupta 1995 
  def getAllEntityTags(self, ):
1996 
    self.send_getAllEntityTags()
1997 
    return self.recv_getAllEntityTags()
1998 
 
1999 
  def send_getAllEntityTags(self, ):
2000 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2001 
    args = getAllEntityTags_args()
2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
2006 
  def recv_getAllEntityTags(self, ):
2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
2013 
    result = getAllEntityTags_result()
2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
2016 
    if result.success is not None:
2017 
      return result.success
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2019 
 
6850 kshitij.so 2020 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2021 
    """
2022 
    Parameters:
2023 
     - bannerName
2024 
     - imageName
2025 
     - link
2026 
     - priority
2027 
     - isActive
2028 
     - hasMap
2029 
    """
2030 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2031 
    return self.recv_addBanner()
2032 
 
2033 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2034 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2035 
    args = addBanner_args()
2036 
    args.bannerName = bannerName
2037 
    args.imageName = imageName
2038 
    args.link = link
2039 
    args.priority = priority
2040 
    args.isActive = isActive
2041 
    args.hasMap = hasMap
2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
2046 
  def recv_addBanner(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 = addBanner_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, "addBanner failed: unknown result");
2059 
 
2060 
  def getAllBanners(self, ):
2061 
    self.send_getAllBanners()
2062 
    return self.recv_getAllBanners()
2063 
 
2064 
  def send_getAllBanners(self, ):
2065 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2066 
    args = getAllBanners_args()
2067 
    args.write(self._oprot)
2068 
    self._oprot.writeMessageEnd()
2069 
    self._oprot.trans.flush()
2070 
 
2071 
  def recv_getAllBanners(self, ):
2072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2073 
    if mtype == TMessageType.EXCEPTION:
2074 
      x = TApplicationException()
2075 
      x.read(self._iprot)
2076 
      self._iprot.readMessageEnd()
2077 
      raise x
2078 
    result = getAllBanners_result()
2079 
    result.read(self._iprot)
2080 
    self._iprot.readMessageEnd()
2081 
    if result.success is not None:
2082 
      return result.success
2083 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2084 
 
2085 
  def deleteBanner(self, bannerName):
2086 
    """
2087 
    Parameters:
2088 
     - bannerName
2089 
    """
2090 
    self.send_deleteBanner(bannerName)
2091 
    return self.recv_deleteBanner()
2092 
 
2093 
  def send_deleteBanner(self, bannerName):
2094 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2095 
    args = deleteBanner_args()
2096 
    args.bannerName = bannerName
2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
2101 
  def recv_deleteBanner(self, ):
2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
2108 
    result = deleteBanner_result()
2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
2111 
    if result.success is not None:
2112 
      return result.success
2113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2114 
 
2115 
  def getBannerDetails(self, bannerName):
2116 
    """
2117 
    Parameters:
2118 
     - bannerName
2119 
    """
2120 
    self.send_getBannerDetails(bannerName)
2121 
    return self.recv_getBannerDetails()
2122 
 
2123 
  def send_getBannerDetails(self, bannerName):
2124 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2125 
    args = getBannerDetails_args()
2126 
    args.bannerName = bannerName
2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
2131 
  def recv_getBannerDetails(self, ):
2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
2138 
    result = getBannerDetails_result()
2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
2141 
    if result.success is not None:
2142 
      return result.success
2143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2144 
 
2145 
  def getActiveBanners(self, ):
2146 
    self.send_getActiveBanners()
2147 
    return self.recv_getActiveBanners()
2148 
 
2149 
  def send_getActiveBanners(self, ):
2150 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2151 
    args = getActiveBanners_args()
2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
2156 
  def recv_getActiveBanners(self, ):
2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
2163 
    result = getActiveBanners_result()
2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
2166 
    if result.success is not None:
2167 
      return result.success
2168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2169 
 
6849 kshitij.so 2170 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2171 
    """
2172 
    Parameters:
2173 
     - bannerName
2174 
     - mapLink
2175 
     - coordinates
2176 
    """
2177 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2178 
    return self.recv_addBannerMap()
2179 
 
2180 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2181 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2182 
    args = addBannerMap_args()
2183 
    args.bannerName = bannerName
2184 
    args.mapLink = mapLink
2185 
    args.coordinates = coordinates
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_addBannerMap(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = addBannerMap_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
2200 
    if result.success is not None:
2201 
      return result.success
2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2203 
 
2204 
  def deleteBannerMap(self, bannerName):
2205 
    """
2206 
    Parameters:
2207 
     - bannerName
2208 
    """
2209 
    self.send_deleteBannerMap(bannerName)
2210 
    return self.recv_deleteBannerMap()
2211 
 
2212 
  def send_deleteBannerMap(self, bannerName):
2213 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2214 
    args = deleteBannerMap_args()
2215 
    args.bannerName = bannerName
2216 
    args.write(self._oprot)
2217 
    self._oprot.writeMessageEnd()
2218 
    self._oprot.trans.flush()
2219 
 
2220 
  def recv_deleteBannerMap(self, ):
2221 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2222 
    if mtype == TMessageType.EXCEPTION:
2223 
      x = TApplicationException()
2224 
      x.read(self._iprot)
2225 
      self._iprot.readMessageEnd()
2226 
      raise x
2227 
    result = deleteBannerMap_result()
2228 
    result.read(self._iprot)
2229 
    self._iprot.readMessageEnd()
2230 
    if result.success is not None:
2231 
      return result.success
2232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2233 
 
2234 
  def getBannerMapDetails(self, bannerName):
2235 
    """
2236 
    Parameters:
2237 
     - bannerName
2238 
    """
2239 
    self.send_getBannerMapDetails(bannerName)
2240 
    return self.recv_getBannerMapDetails()
2241 
 
2242 
  def send_getBannerMapDetails(self, bannerName):
2243 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2244 
    args = getBannerMapDetails_args()
2245 
    args.bannerName = bannerName
2246 
    args.write(self._oprot)
2247 
    self._oprot.writeMessageEnd()
2248 
    self._oprot.trans.flush()
2249 
 
2250 
  def recv_getBannerMapDetails(self, ):
2251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2252 
    if mtype == TMessageType.EXCEPTION:
2253 
      x = TApplicationException()
2254 
      x.read(self._iprot)
2255 
      self._iprot.readMessageEnd()
2256 
      raise x
2257 
    result = getBannerMapDetails_result()
2258 
    result.read(self._iprot)
2259 
    self._iprot.readMessageEnd()
2260 
    if result.success is not None:
2261 
      return result.success
2262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2263 
 
5944 mandeep.dh 2264 
  def deleteSimilarItem(self, itemId, catalogItemId):
2265 
    """
2266 
    Delete similar item.
2267 
 
2268 
    Parameters:
2269 
     - itemId
2270 
     - catalogItemId
2271 
    """
2272 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2273 
    return self.recv_deleteSimilarItem()
2274 
 
2275 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2276 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2277 
    args = deleteSimilarItem_args()
2278 
    args.itemId = itemId
2279 
    args.catalogItemId = catalogItemId
2280 
    args.write(self._oprot)
2281 
    self._oprot.writeMessageEnd()
2282 
    self._oprot.trans.flush()
2283 
 
2284 
  def recv_deleteSimilarItem(self, ):
2285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2286 
    if mtype == TMessageType.EXCEPTION:
2287 
      x = TApplicationException()
2288 
      x.read(self._iprot)
2289 
      self._iprot.readMessageEnd()
2290 
      raise x
2291 
    result = deleteSimilarItem_result()
2292 
    result.read(self._iprot)
2293 
    self._iprot.readMessageEnd()
2294 
    if result.success is not None:
2295 
      return result.success
2296 
    if result.cex is not None:
2297 
      raise result.cex
2298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2299 
 
2300 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2301 
    """
2302 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2303 
    If yes, returns the itemId else returns 0
2304 
 
2305 
    Parameters:
2306 
     - brand
2307 
     - modelNumber
2308 
     - modelName
2309 
     - color
2310 
    """
2311 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2312 
    return self.recv_checkSimilarItem()
2313 
 
2314 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2315 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2316 
    args = checkSimilarItem_args()
2317 
    args.brand = brand
2318 
    args.modelNumber = modelNumber
2319 
    args.modelName = modelName
2320 
    args.color = color
2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
2325 
  def recv_checkSimilarItem(self, ):
2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
2332 
    result = checkSimilarItem_result()
2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
2335 
    if result.success is not None:
2336 
      return result.success
2337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2338 
 
2339 
  def validateRiskyStatus(self, itemId):
2340 
    """
2341 
    Check wether item is risky and change status if inventory is not available for risky items
2342 
 
2343 
    Parameters:
2344 
     - itemId
2345 
    """
2346 
    self.send_validateRiskyStatus(itemId)
2347 
    self.recv_validateRiskyStatus()
2348 
 
2349 
  def send_validateRiskyStatus(self, itemId):
2350 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2351 
    args = validateRiskyStatus_args()
2352 
    args.itemId = itemId
2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_validateRiskyStatus(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = validateRiskyStatus_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
2367 
    return
2368 
 
2369 
  def changeItemRiskyFlag(self, itemId, risky):
2370 
    """
2371 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2372 
 
2373 
    Parameters:
2374 
     - itemId
2375 
     - risky
2376 
    """
2377 
    self.send_changeItemRiskyFlag(itemId, risky)
2378 
    self.recv_changeItemRiskyFlag()
2379 
 
2380 
  def send_changeItemRiskyFlag(self, itemId, risky):
2381 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2382 
    args = changeItemRiskyFlag_args()
2383 
    args.itemId = itemId
2384 
    args.risky = risky
2385 
    args.write(self._oprot)
2386 
    self._oprot.writeMessageEnd()
2387 
    self._oprot.trans.flush()
2388 
 
2389 
  def recv_changeItemRiskyFlag(self, ):
2390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2391 
    if mtype == TMessageType.EXCEPTION:
2392 
      x = TApplicationException()
2393 
      x.read(self._iprot)
2394 
      self._iprot.readMessageEnd()
2395 
      raise x
2396 
    result = changeItemRiskyFlag_result()
2397 
    result.read(self._iprot)
2398 
    self._iprot.readMessageEnd()
2399 
    return
2400 
 
2401 
  def getItemsByRiskyFlag(self, ):
2402 
    """
2403 
    Returns list of items marked as risky.
2404 
    """
2405 
    self.send_getItemsByRiskyFlag()
2406 
    return self.recv_getItemsByRiskyFlag()
2407 
 
2408 
  def send_getItemsByRiskyFlag(self, ):
2409 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2410 
    args = getItemsByRiskyFlag_args()
2411 
    args.write(self._oprot)
2412 
    self._oprot.writeMessageEnd()
2413 
    self._oprot.trans.flush()
2414 
 
2415 
  def recv_getItemsByRiskyFlag(self, ):
2416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2417 
    if mtype == TMessageType.EXCEPTION:
2418 
      x = TApplicationException()
2419 
      x.read(self._iprot)
2420 
      self._iprot.readMessageEnd()
2421 
      raise x
2422 
    result = getItemsByRiskyFlag_result()
2423 
    result.read(self._iprot)
2424 
    self._iprot.readMessageEnd()
2425 
    if result.success is not None:
2426 
      return result.success
2427 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2428 
 
2429 
  def getItemsForMasterSheet(self, category, brand):
2430 
    """
2431 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2432 
 
2433 
    Parameters:
2434 
     - category
2435 
     - brand
2436 
    """
2437 
    self.send_getItemsForMasterSheet(category, brand)
2438 
    return self.recv_getItemsForMasterSheet()
2439 
 
2440 
  def send_getItemsForMasterSheet(self, category, brand):
2441 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2442 
    args = getItemsForMasterSheet_args()
2443 
    args.category = category
2444 
    args.brand = brand
2445 
    args.write(self._oprot)
2446 
    self._oprot.writeMessageEnd()
2447 
    self._oprot.trans.flush()
2448 
 
2449 
  def recv_getItemsForMasterSheet(self, ):
2450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2451 
    if mtype == TMessageType.EXCEPTION:
2452 
      x = TApplicationException()
2453 
      x.read(self._iprot)
2454 
      self._iprot.readMessageEnd()
2455 
      raise x
2456 
    result = getItemsForMasterSheet_result()
2457 
    result.read(self._iprot)
2458 
    self._iprot.readMessageEnd()
2459 
    if result.success is not None:
2460 
      return result.success
2461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2462 
 
2463 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2464 
    """
2465 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2466 
 
2467 
    Parameters:
2468 
     - beginIndex
2469 
     - totalItems
2470 
     - itemId
2471 
    """
2472 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2473 
    return self.recv_getSimilarItemsCatalogIds()
2474 
 
2475 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2476 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2477 
    args = getSimilarItemsCatalogIds_args()
2478 
    args.beginIndex = beginIndex
2479 
    args.totalItems = totalItems
2480 
    args.itemId = itemId
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_getSimilarItemsCatalogIds(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = getSimilarItemsCatalogIds_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
2495 
    if result.success is not None:
2496 
      return result.success
2497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2498 
 
2499 
  def addProductNotification(self, itemId, email):
2500 
    """
2501 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2502 
 
2503 
    Parameters:
2504 
     - itemId
2505 
     - email
2506 
    """
2507 
    self.send_addProductNotification(itemId, email)
2508 
    return self.recv_addProductNotification()
2509 
 
2510 
  def send_addProductNotification(self, itemId, email):
2511 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2512 
    args = addProductNotification_args()
2513 
    args.itemId = itemId
2514 
    args.email = email
2515 
    args.write(self._oprot)
2516 
    self._oprot.writeMessageEnd()
2517 
    self._oprot.trans.flush()
2518 
 
2519 
  def recv_addProductNotification(self, ):
2520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2521 
    if mtype == TMessageType.EXCEPTION:
2522 
      x = TApplicationException()
2523 
      x.read(self._iprot)
2524 
      self._iprot.readMessageEnd()
2525 
      raise x
2526 
    result = addProductNotification_result()
2527 
    result.read(self._iprot)
2528 
    self._iprot.readMessageEnd()
2529 
    if result.success is not None:
2530 
      return result.success
2531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2532 
 
2533 
  def sendProductNotifications(self, ):
2534 
    """
2535 
    Send the product notifications to the users for items which has stock.
2536 
    """
2537 
    self.send_sendProductNotifications()
2538 
    return self.recv_sendProductNotifications()
2539 
 
2540 
  def send_sendProductNotifications(self, ):
2541 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2542 
    args = sendProductNotifications_args()
2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_sendProductNotifications(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = sendProductNotifications_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2560 
 
2561 
  def getAllBrandsByCategory(self, categoryId):
2562 
    """
2563 
    Returns list of brand names for a given category Id
2564 
 
2565 
    Parameters:
2566 
     - categoryId
2567 
    """
2568 
    self.send_getAllBrandsByCategory(categoryId)
2569 
    return self.recv_getAllBrandsByCategory()
2570 
 
2571 
  def send_getAllBrandsByCategory(self, categoryId):
2572 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2573 
    args = getAllBrandsByCategory_args()
2574 
    args.categoryId = categoryId
2575 
    args.write(self._oprot)
2576 
    self._oprot.writeMessageEnd()
2577 
    self._oprot.trans.flush()
2578 
 
2579 
  def recv_getAllBrandsByCategory(self, ):
2580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2581 
    if mtype == TMessageType.EXCEPTION:
2582 
      x = TApplicationException()
2583 
      x.read(self._iprot)
2584 
      self._iprot.readMessageEnd()
2585 
      raise x
2586 
    result = getAllBrandsByCategory_result()
2587 
    result.read(self._iprot)
2588 
    self._iprot.readMessageEnd()
2589 
    if result.success is not None:
2590 
      return result.success
2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2592 
 
2593 
  def getAllBrands(self, ):
2594 
    """
2595 
    Returns list of brand names
2596 
    """
2597 
    self.send_getAllBrands()
2598 
    return self.recv_getAllBrands()
2599 
 
2600 
  def send_getAllBrands(self, ):
2601 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2602 
    args = getAllBrands_args()
2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
2607 
  def recv_getAllBrands(self, ):
2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
2614 
    result = getAllBrands_result()
2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
2617 
    if result.success is not None:
2618 
      return result.success
2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2620 
 
2621 
  def getAllSources(self, ):
2622 
    """
2623 
    Return list of all sources
2624 
    """
2625 
    self.send_getAllSources()
2626 
    return self.recv_getAllSources()
2627 
 
2628 
  def send_getAllSources(self, ):
2629 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2630 
    args = getAllSources_args()
2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
2635 
  def recv_getAllSources(self, ):
2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
2642 
    result = getAllSources_result()
2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success is not None:
2646 
      return result.success
2647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2648 
 
2649 
  def getItemPricingBySource(self, itemId, sourceId):
2650 
    """
2651 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2652 
 
2653 
    Parameters:
2654 
     - itemId
2655 
     - sourceId
2656 
    """
2657 
    self.send_getItemPricingBySource(itemId, sourceId)
2658 
    return self.recv_getItemPricingBySource()
2659 
 
2660 
  def send_getItemPricingBySource(self, itemId, sourceId):
2661 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2662 
    args = getItemPricingBySource_args()
2663 
    args.itemId = itemId
2664 
    args.sourceId = sourceId
2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
2669 
  def recv_getItemPricingBySource(self, ):
2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
2676 
    result = getItemPricingBySource_result()
2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    if result.success is not None:
2680 
      return result.success
2681 
    if result.cex is not None:
2682 
      raise result.cex
2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2684 
 
2685 
  def addSourceItemPricing(self, sourceItemPricing):
2686 
    """
2687 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2688 
    If item is not found or source is not found, it will throw exception.
2689 
 
2690 
    Parameters:
2691 
     - sourceItemPricing
2692 
    """
2693 
    self.send_addSourceItemPricing(sourceItemPricing)
2694 
    self.recv_addSourceItemPricing()
2695 
 
2696 
  def send_addSourceItemPricing(self, sourceItemPricing):
2697 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2698 
    args = addSourceItemPricing_args()
2699 
    args.sourceItemPricing = sourceItemPricing
2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
2704 
  def recv_addSourceItemPricing(self, ):
2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
2711 
    result = addSourceItemPricing_result()
2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
2714 
    if result.cex is not None:
2715 
      raise result.cex
2716 
    return
2717 
 
2718 
  def getAllSourcePricing(self, itemId):
2719 
    """
2720 
    Returns the list of source pricing information of an item.
2721 
    Raises an exception if item not found corresponding to itemId
2722 
 
2723 
    Parameters:
2724 
     - itemId
2725 
    """
2726 
    self.send_getAllSourcePricing(itemId)
2727 
    return self.recv_getAllSourcePricing()
2728 
 
2729 
  def send_getAllSourcePricing(self, itemId):
2730 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2731 
    args = getAllSourcePricing_args()
2732 
    args.itemId = itemId
2733 
    args.write(self._oprot)
2734 
    self._oprot.writeMessageEnd()
2735 
    self._oprot.trans.flush()
2736 
 
2737 
  def recv_getAllSourcePricing(self, ):
2738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2739 
    if mtype == TMessageType.EXCEPTION:
2740 
      x = TApplicationException()
2741 
      x.read(self._iprot)
2742 
      self._iprot.readMessageEnd()
2743 
      raise x
2744 
    result = getAllSourcePricing_result()
2745 
    result.read(self._iprot)
2746 
    self._iprot.readMessageEnd()
2747 
    if result.success is not None:
2748 
      return result.success
2749 
    if result.cex is not None:
2750 
      raise result.cex
2751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2752 
 
2753 
  def getItemForSource(self, item_id, sourceId):
2754 
    """
2755 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2756 
 
2757 
    Parameters:
2758 
     - item_id
2759 
     - sourceId
2760 
    """
2761 
    self.send_getItemForSource(item_id, sourceId)
2762 
    return self.recv_getItemForSource()
2763 
 
2764 
  def send_getItemForSource(self, item_id, sourceId):
2765 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2766 
    args = getItemForSource_args()
2767 
    args.item_id = item_id
2768 
    args.sourceId = sourceId
2769 
    args.write(self._oprot)
2770 
    self._oprot.writeMessageEnd()
2771 
    self._oprot.trans.flush()
2772 
 
2773 
  def recv_getItemForSource(self, ):
2774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2775 
    if mtype == TMessageType.EXCEPTION:
2776 
      x = TApplicationException()
2777 
      x.read(self._iprot)
2778 
      self._iprot.readMessageEnd()
2779 
      raise x
2780 
    result = getItemForSource_result()
2781 
    result.read(self._iprot)
2782 
    self._iprot.readMessageEnd()
2783 
    if result.success is not None:
2784 
      return result.success
2785 
    if result.cex is not None:
2786 
      raise result.cex
2787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2788 
 
2789 
  def searchItemsInRange(self, searchTerms, offset, limit):
2790 
    """
2791 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2792 
 
2793 
    Parameters:
2794 
     - searchTerms
2795 
     - offset
2796 
     - limit
2797 
    """
2798 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2799 
    return self.recv_searchItemsInRange()
2800 
 
2801 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2802 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2803 
    args = searchItemsInRange_args()
2804 
    args.searchTerms = searchTerms
2805 
    args.offset = offset
2806 
    args.limit = limit
2807 
    args.write(self._oprot)
2808 
    self._oprot.writeMessageEnd()
2809 
    self._oprot.trans.flush()
2810 
 
2811 
  def recv_searchItemsInRange(self, ):
2812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2813 
    if mtype == TMessageType.EXCEPTION:
2814 
      x = TApplicationException()
2815 
      x.read(self._iprot)
2816 
      self._iprot.readMessageEnd()
2817 
      raise x
2818 
    result = searchItemsInRange_result()
2819 
    result.read(self._iprot)
2820 
    self._iprot.readMessageEnd()
2821 
    if result.success is not None:
2822 
      return result.success
2823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2824 
 
2825 
  def getSearchResultCount(self, searchTerms):
2826 
    """
2827 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2828 
 
2829 
    Parameters:
2830 
     - searchTerms
2831 
    """
2832 
    self.send_getSearchResultCount(searchTerms)
2833 
    return self.recv_getSearchResultCount()
2834 
 
2835 
  def send_getSearchResultCount(self, searchTerms):
2836 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2837 
    args = getSearchResultCount_args()
2838 
    args.searchTerms = searchTerms
2839 
    args.write(self._oprot)
2840 
    self._oprot.writeMessageEnd()
2841 
    self._oprot.trans.flush()
2842 
 
2843 
  def recv_getSearchResultCount(self, ):
2844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2845 
    if mtype == TMessageType.EXCEPTION:
2846 
      x = TApplicationException()
2847 
      x.read(self._iprot)
2848 
      self._iprot.readMessageEnd()
2849 
      raise x
2850 
    result = getSearchResultCount_result()
2851 
    result.read(self._iprot)
2852 
    self._iprot.readMessageEnd()
2853 
    if result.success is not None:
2854 
      return result.success
2855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2856 
 
2857 
  def getProductNotifications(self, startDateTime):
2858 
    """
2859 
    Returns a list of product notifications added after a supplied datetime
2860 
 
2861 
    Parameters:
2862 
     - startDateTime
2863 
    """
2864 
    self.send_getProductNotifications(startDateTime)
2865 
    return self.recv_getProductNotifications()
2866 
 
2867 
  def send_getProductNotifications(self, startDateTime):
2868 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2869 
    args = getProductNotifications_args()
2870 
    args.startDateTime = startDateTime
2871 
    args.write(self._oprot)
2872 
    self._oprot.writeMessageEnd()
2873 
    self._oprot.trans.flush()
2874 
 
2875 
  def recv_getProductNotifications(self, ):
2876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2877 
    if mtype == TMessageType.EXCEPTION:
2878 
      x = TApplicationException()
2879 
      x.read(self._iprot)
2880 
      self._iprot.readMessageEnd()
2881 
      raise x
2882 
    result = getProductNotifications_result()
2883 
    result.read(self._iprot)
2884 
    self._iprot.readMessageEnd()
2885 
    if result.success is not None:
2886 
      return result.success
2887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2888 
 
2889 
  def getProductNotificationRequestCount(self, startDateTime):
2890 
    """
2891 
    Returns a list of count of requests for product notification against each item
2892 
 
2893 
    Parameters:
2894 
     - startDateTime
2895 
    """
2896 
    self.send_getProductNotificationRequestCount(startDateTime)
2897 
    return self.recv_getProductNotificationRequestCount()
2898 
 
2899 
  def send_getProductNotificationRequestCount(self, startDateTime):
2900 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2901 
    args = getProductNotificationRequestCount_args()
2902 
    args.startDateTime = startDateTime
2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
2907 
  def recv_getProductNotificationRequestCount(self, ):
2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
2914 
    result = getProductNotificationRequestCount_result()
2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
2917 
    if result.success is not None:
2918 
      return result.success
2919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2920 
 
2921 
  def addAuthorizationLog(self, itemId, username, reason):
2922 
    """
2923 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2924 
 
2925 
    Parameters:
2926 
     - itemId
2927 
     - username
2928 
     - reason
2929 
    """
2930 
    self.send_addAuthorizationLog(itemId, username, reason)
2931 
    return self.recv_addAuthorizationLog()
2932 
 
2933 
  def send_addAuthorizationLog(self, itemId, username, reason):
2934 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2935 
    args = addAuthorizationLog_args()
2936 
    args.itemId = itemId
2937 
    args.username = username
2938 
    args.reason = reason
2939 
    args.write(self._oprot)
2940 
    self._oprot.writeMessageEnd()
2941 
    self._oprot.trans.flush()
2942 
 
2943 
  def recv_addAuthorizationLog(self, ):
2944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2945 
    if mtype == TMessageType.EXCEPTION:
2946 
      x = TApplicationException()
2947 
      x.read(self._iprot)
2948 
      self._iprot.readMessageEnd()
2949 
      raise x
2950 
    result = addAuthorizationLog_result()
2951 
    result.read(self._iprot)
2952 
    self._iprot.readMessageEnd()
2953 
    if result.success is not None:
2954 
      return result.success
2955 
    if result.cex is not None:
2956 
      raise result.cex
2957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2958 
 
2959 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2960 
    """
2961 
    Parameters:
2962 
     - catalog_item_id
2963 
     - voucherType
2964 
     - voucherAmount
2965 
    """
2966 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2967 
    return self.recv_addupdateVoucherForItem()
2968 
 
2969 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2970 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2971 
    args = addupdateVoucherForItem_args()
2972 
    args.catalog_item_id = catalog_item_id
2973 
    args.voucherType = voucherType
2974 
    args.voucherAmount = voucherAmount
2975 
    args.write(self._oprot)
2976 
    self._oprot.writeMessageEnd()
2977 
    self._oprot.trans.flush()
2978 
 
2979 
  def recv_addupdateVoucherForItem(self, ):
2980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2981 
    if mtype == TMessageType.EXCEPTION:
2982 
      x = TApplicationException()
2983 
      x.read(self._iprot)
2984 
      self._iprot.readMessageEnd()
2985 
      raise x
2986 
    result = addupdateVoucherForItem_result()
2987 
    result.read(self._iprot)
2988 
    self._iprot.readMessageEnd()
2989 
    if result.success is not None:
2990 
      return result.success
2991 
    if result.cex is not None:
2992 
      raise result.cex
2993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2994 
 
2995 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2996 
    """
2997 
    Parameters:
2998 
     - catalog_item_id
2999 
     - voucherType
3000 
    """
3001 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3002 
    return self.recv_deleteVoucherForItem()
3003 
 
3004 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3005 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3006 
    args = deleteVoucherForItem_args()
3007 
    args.catalog_item_id = catalog_item_id
3008 
    args.voucherType = voucherType
3009 
    args.write(self._oprot)
3010 
    self._oprot.writeMessageEnd()
3011 
    self._oprot.trans.flush()
3012 
 
3013 
  def recv_deleteVoucherForItem(self, ):
3014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3015 
    if mtype == TMessageType.EXCEPTION:
3016 
      x = TApplicationException()
3017 
      x.read(self._iprot)
3018 
      self._iprot.readMessageEnd()
3019 
      raise x
3020 
    result = deleteVoucherForItem_result()
3021 
    result.read(self._iprot)
3022 
    self._iprot.readMessageEnd()
3023 
    if result.success is not None:
3024 
      return result.success
3025 
    if result.cex is not None:
3026 
      raise result.cex
3027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3028 
 
3029 
  def getVoucherAmount(self, itemId, voucherType):
3030 
    """
3031 
    Parameters:
3032 
     - itemId
3033 
     - voucherType
3034 
    """
3035 
    self.send_getVoucherAmount(itemId, voucherType)
3036 
    return self.recv_getVoucherAmount()
3037 
 
3038 
  def send_getVoucherAmount(self, itemId, voucherType):
3039 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3040 
    args = getVoucherAmount_args()
3041 
    args.itemId = itemId
3042 
    args.voucherType = voucherType
3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
3047 
  def recv_getVoucherAmount(self, ):
3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
3054 
    result = getVoucherAmount_result()
3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3057 
    if result.success is not None:
3058 
      return result.success
3059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3060 
 
3061 
  def getAllItemVouchers(self, itemId):
3062 
    """
3063 
    Parameters:
3064 
     - itemId
3065 
    """
3066 
    self.send_getAllItemVouchers(itemId)
3067 
    return self.recv_getAllItemVouchers()
3068 
 
3069 
  def send_getAllItemVouchers(self, itemId):
3070 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3071 
    args = getAllItemVouchers_args()
3072 
    args.itemId = itemId
3073 
    args.write(self._oprot)
3074 
    self._oprot.writeMessageEnd()
3075 
    self._oprot.trans.flush()
3076 
 
3077 
  def recv_getAllItemVouchers(self, ):
3078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3079 
    if mtype == TMessageType.EXCEPTION:
3080 
      x = TApplicationException()
3081 
      x.read(self._iprot)
3082 
      self._iprot.readMessageEnd()
3083 
      raise x
3084 
    result = getAllItemVouchers_result()
3085 
    result.read(self._iprot)
3086 
    self._iprot.readMessageEnd()
3087 
    if result.success is not None:
3088 
      return result.success
3089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3090 
 
3091 
  def isValidCatalogItemId(self, catalog_item_id):
3092 
    """
3093 
    Parameters:
3094 
     - catalog_item_id
3095 
    """
3096 
    self.send_isValidCatalogItemId(catalog_item_id)
3097 
    return self.recv_isValidCatalogItemId()
3098 
 
3099 
  def send_isValidCatalogItemId(self, catalog_item_id):
3100 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3101 
    args = isValidCatalogItemId_args()
3102 
    args.catalog_item_id = catalog_item_id
3103 
    args.write(self._oprot)
3104 
    self._oprot.writeMessageEnd()
3105 
    self._oprot.trans.flush()
3106 
 
3107 
  def recv_isValidCatalogItemId(self, ):
3108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3109 
    if mtype == TMessageType.EXCEPTION:
3110 
      x = TApplicationException()
3111 
      x.read(self._iprot)
3112 
      self._iprot.readMessageEnd()
3113 
      raise x
3114 
    result = isValidCatalogItemId_result()
3115 
    result.read(self._iprot)
3116 
    self._iprot.readMessageEnd()
3117 
    if result.success is not None:
3118 
      return result.success
3119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3120 
 
7330 amit.gupta 3121 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3122 
    """
3123 
    Parameters:
3124 
     - itemId
7330 amit.gupta 3125 
     - stateId
6039 amit.gupta 3126 
     - price
3127 
    """
7330 amit.gupta 3128 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3129 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3130 
 
7330 amit.gupta 3131 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3132 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3133 
    args = getVatPercentageForItem_args()
3134 
    args.itemId = itemId
7330 amit.gupta 3135 
    args.stateId = stateId
6039 amit.gupta 3136 
    args.price = price
3137 
    args.write(self._oprot)
3138 
    self._oprot.writeMessageEnd()
3139 
    self._oprot.trans.flush()
3140 
 
3141 
  def recv_getVatPercentageForItem(self, ):
3142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3143 
    if mtype == TMessageType.EXCEPTION:
3144 
      x = TApplicationException()
3145 
      x.read(self._iprot)
3146 
      self._iprot.readMessageEnd()
3147 
      raise x
3148 
    result = getVatPercentageForItem_result()
3149 
    result.read(self._iprot)
3150 
    self._iprot.readMessageEnd()
3151 
    if result.success is not None:
3152 
      return result.success
7340 amit.gupta 3153 
    if result.cex is not None:
3154 
      raise result.cex
6039 amit.gupta 3155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3156 
 
3157 
  def getVatAmountForItem(self, itemId, price):
3158 
    """
3159 
    Parameters:
3160 
     - itemId
3161 
     - price
3162 
    """
3163 
    self.send_getVatAmountForItem(itemId, price)
3164 
    return self.recv_getVatAmountForItem()
3165 
 
3166 
  def send_getVatAmountForItem(self, itemId, price):
3167 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3168 
    args = getVatAmountForItem_args()
3169 
    args.itemId = itemId
3170 
    args.price = price
3171 
    args.write(self._oprot)
3172 
    self._oprot.writeMessageEnd()
3173 
    self._oprot.trans.flush()
3174 
 
3175 
  def recv_getVatAmountForItem(self, ):
3176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3177 
    if mtype == TMessageType.EXCEPTION:
3178 
      x = TApplicationException()
3179 
      x.read(self._iprot)
3180 
      self._iprot.readMessageEnd()
3181 
      raise x
3182 
    result = getVatAmountForItem_result()
3183 
    result.read(self._iprot)
3184 
    self._iprot.readMessageEnd()
3185 
    if result.success is not None:
3186 
      return result.success
3187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3188 
 
6531 vikram.rag 3189 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3190 
    """
3191 
    Parameters:
3192 
     - offset
3193 
     - limit
3194 
    """
3195 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3196 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3197 
 
6531 vikram.rag 3198 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3199 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3200 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3201 
    args.offset = offset
3202 
    args.limit = limit
3203 
    args.write(self._oprot)
3204 
    self._oprot.writeMessageEnd()
3205 
    self._oprot.trans.flush()
3206 
 
3207 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3209 
    if mtype == TMessageType.EXCEPTION:
3210 
      x = TApplicationException()
3211 
      x.read(self._iprot)
3212 
      self._iprot.readMessageEnd()
3213 
      raise x
3214 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3215 
    result.read(self._iprot)
3216 
    self._iprot.readMessageEnd()
3217 
    if result.success is not None:
3218 
      return result.success
3219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3220 
 
6821 amar.kumar 3221 
  def getAllAliveItems(self, ):
3222 
    self.send_getAllAliveItems()
3223 
    return self.recv_getAllAliveItems()
3224 
 
3225 
  def send_getAllAliveItems(self, ):
3226 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3227 
    args = getAllAliveItems_args()
3228 
    args.write(self._oprot)
3229 
    self._oprot.writeMessageEnd()
3230 
    self._oprot.trans.flush()
3231 
 
3232 
  def recv_getAllAliveItems(self, ):
3233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3234 
    if mtype == TMessageType.EXCEPTION:
3235 
      x = TApplicationException()
3236 
      x.read(self._iprot)
3237 
      self._iprot.readMessageEnd()
3238 
      raise x
3239 
    result = getAllAliveItems_result()
3240 
    result.read(self._iprot)
3241 
    self._iprot.readMessageEnd()
3242 
    if result.success is not None:
3243 
      return result.success
3244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3245 
 
6921 anupam.sin 3246 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3247 
    """
3248 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3249 
 
6805 anupam.sin 3250 
    Parameters:
3251 
     - itemId
6921 anupam.sin 3252 
     - price
6805 anupam.sin 3253 
     - insurerId
3254 
     - quantity
3255 
    """
6921 anupam.sin 3256 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3257 
    return self.recv_getInsuranceAmount()
3258 
 
6921 anupam.sin 3259 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3260 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3261 
    args = getInsuranceAmount_args()
3262 
    args.itemId = itemId
6921 anupam.sin 3263 
    args.price = price
6805 anupam.sin 3264 
    args.insurerId = insurerId
3265 
    args.quantity = quantity
3266 
    args.write(self._oprot)
3267 
    self._oprot.writeMessageEnd()
3268 
    self._oprot.trans.flush()
3269 
 
3270 
  def recv_getInsuranceAmount(self, ):
3271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3272 
    if mtype == TMessageType.EXCEPTION:
3273 
      x = TApplicationException()
3274 
      x.read(self._iprot)
3275 
      self._iprot.readMessageEnd()
3276 
      raise x
3277 
    result = getInsuranceAmount_result()
3278 
    result.read(self._iprot)
3279 
    self._iprot.readMessageEnd()
3280 
    if result.success is not None:
3281 
      return result.success
3282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3283 
 
3284 
  def getInsurer(self, insurerId):
3285 
    """
3286 
    Parameters:
3287 
     - insurerId
3288 
    """
3289 
    self.send_getInsurer(insurerId)
3290 
    return self.recv_getInsurer()
3291 
 
3292 
  def send_getInsurer(self, insurerId):
3293 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3294 
    args = getInsurer_args()
3295 
    args.insurerId = insurerId
3296 
    args.write(self._oprot)
3297 
    self._oprot.writeMessageEnd()
3298 
    self._oprot.trans.flush()
3299 
 
3300 
  def recv_getInsurer(self, ):
3301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3302 
    if mtype == TMessageType.EXCEPTION:
3303 
      x = TApplicationException()
3304 
      x.read(self._iprot)
3305 
      self._iprot.readMessageEnd()
3306 
      raise x
3307 
    result = getInsurer_result()
3308 
    result.read(self._iprot)
3309 
    self._iprot.readMessageEnd()
3310 
    if result.success is not None:
3311 
      return result.success
3312 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3313 
 
6838 vikram.rag 3314 
  def getAllInsurers(self, ):
3315 
    self.send_getAllInsurers()
3316 
    return self.recv_getAllInsurers()
6805 anupam.sin 3317 
 
6838 vikram.rag 3318 
  def send_getAllInsurers(self, ):
3319 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3320 
    args = getAllInsurers_args()
3321 
    args.write(self._oprot)
3322 
    self._oprot.writeMessageEnd()
3323 
    self._oprot.trans.flush()
3324 
 
3325 
  def recv_getAllInsurers(self, ):
3326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3327 
    if mtype == TMessageType.EXCEPTION:
3328 
      x = TApplicationException()
3329 
      x.read(self._iprot)
3330 
      self._iprot.readMessageEnd()
3331 
      raise x
3332 
    result = getAllInsurers_result()
3333 
    result.read(self._iprot)
3334 
    self._iprot.readMessageEnd()
3335 
    if result.success is not None:
3336 
      return result.success
3337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3338 
 
6962 rajveer 3339 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3340 
    """
3341 
    Parameters:
3342 
     - insurerId
3343 
     - amount
3344 
    """
3345 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3346 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3347 
 
6962 rajveer 3348 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3349 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3350 
    args = updateInsuranceDeclaredAmount_args()
3351 
    args.insurerId = insurerId
3352 
    args.amount = amount
3353 
    args.write(self._oprot)
3354 
    self._oprot.writeMessageEnd()
3355 
    self._oprot.trans.flush()
3356 
 
3357 
  def recv_updateInsuranceDeclaredAmount(self, ):
3358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3359 
    if mtype == TMessageType.EXCEPTION:
3360 
      x = TApplicationException()
3361 
      x.read(self._iprot)
3362 
      self._iprot.readMessageEnd()
3363 
      raise x
3364 
    result = updateInsuranceDeclaredAmount_result()
3365 
    result.read(self._iprot)
3366 
    self._iprot.readMessageEnd()
3367 
    return
3368 
 
7190 amar.kumar 3369 
  def getFreebieForItem(self, itemId):
3370 
    """
3371 
    Parameters:
3372 
     - itemId
3373 
    """
3374 
    self.send_getFreebieForItem(itemId)
3375 
    return self.recv_getFreebieForItem()
6962 rajveer 3376 
 
7190 amar.kumar 3377 
  def send_getFreebieForItem(self, itemId):
3378 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3379 
    args = getFreebieForItem_args()
3380 
    args.itemId = itemId
3381 
    args.write(self._oprot)
3382 
    self._oprot.writeMessageEnd()
3383 
    self._oprot.trans.flush()
3384 
 
3385 
  def recv_getFreebieForItem(self, ):
3386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3387 
    if mtype == TMessageType.EXCEPTION:
3388 
      x = TApplicationException()
3389 
      x.read(self._iprot)
3390 
      self._iprot.readMessageEnd()
3391 
      raise x
3392 
    result = getFreebieForItem_result()
3393 
    result.read(self._iprot)
3394 
    self._iprot.readMessageEnd()
3395 
    if result.success is not None:
3396 
      return result.success
3397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3398 
 
3399 
  def addOrUpdateFreebieForItem(self, freebieItem):
3400 
    """
3401 
    Parameters:
3402 
     - freebieItem
3403 
    """
3404 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3405 
    self.recv_addOrUpdateFreebieForItem()
3406 
 
3407 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3408 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3409 
    args = addOrUpdateFreebieForItem_args()
3410 
    args.freebieItem = freebieItem
3411 
    args.write(self._oprot)
3412 
    self._oprot.writeMessageEnd()
3413 
    self._oprot.trans.flush()
3414 
 
3415 
  def recv_addOrUpdateFreebieForItem(self, ):
3416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3417 
    if mtype == TMessageType.EXCEPTION:
3418 
      x = TApplicationException()
3419 
      x.read(self._iprot)
3420 
      self._iprot.readMessageEnd()
3421 
      raise x
3422 
    result = addOrUpdateFreebieForItem_result()
3423 
    result.read(self._iprot)
3424 
    self._iprot.readMessageEnd()
3425 
    return
3426 
 
7272 amit.gupta 3427 
  def addOrUpdateBrandInfo(self, brandInfo):
3428 
    """
3429 
    Parameters:
3430 
     - brandInfo
3431 
    """
3432 
    self.send_addOrUpdateBrandInfo(brandInfo)
3433 
    self.recv_addOrUpdateBrandInfo()
3434 
 
3435 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3436 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3437 
    args = addOrUpdateBrandInfo_args()
3438 
    args.brandInfo = brandInfo
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_addOrUpdateBrandInfo(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = addOrUpdateBrandInfo_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    return
3454 
 
3455 
  def getBrandInfo(self, ):
3456 
    self.send_getBrandInfo()
3457 
    return self.recv_getBrandInfo()
3458 
 
3459 
  def send_getBrandInfo(self, ):
3460 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3461 
    args = getBrandInfo_args()
3462 
    args.write(self._oprot)
3463 
    self._oprot.writeMessageEnd()
3464 
    self._oprot.trans.flush()
3465 
 
3466 
  def recv_getBrandInfo(self, ):
3467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3468 
    if mtype == TMessageType.EXCEPTION:
3469 
      x = TApplicationException()
3470 
      x.read(self._iprot)
3471 
      self._iprot.readMessageEnd()
3472 
      raise x
3473 
    result = getBrandInfo_result()
3474 
    result.read(self._iprot)
3475 
    self._iprot.readMessageEnd()
3476 
    if result.success is not None:
3477 
      return result.success
3478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3479 
 
7256 rajveer 3480 
  def getStorePricing(self, itemId):
3481 
    """
3482 
    Parameters:
3483 
     - itemId
3484 
    """
3485 
    self.send_getStorePricing(itemId)
3486 
    return self.recv_getStorePricing()
7190 amar.kumar 3487 
 
7256 rajveer 3488 
  def send_getStorePricing(self, itemId):
3489 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3490 
    args = getStorePricing_args()
3491 
    args.itemId = itemId
3492 
    args.write(self._oprot)
3493 
    self._oprot.writeMessageEnd()
3494 
    self._oprot.trans.flush()
3495 
 
3496 
  def recv_getStorePricing(self, ):
3497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3498 
    if mtype == TMessageType.EXCEPTION:
3499 
      x = TApplicationException()
3500 
      x.read(self._iprot)
3501 
      self._iprot.readMessageEnd()
3502 
      raise x
3503 
    result = getStorePricing_result()
3504 
    result.read(self._iprot)
3505 
    self._iprot.readMessageEnd()
3506 
    if result.success is not None:
3507 
      return result.success
3508 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3509 
 
7306 rajveer 3510 
  def getStorePricings(self, itemIds):
3511 
    """
3512 
    Parameters:
3513 
     - itemIds
3514 
    """
3515 
    self.send_getStorePricings(itemIds)
3516 
    return self.recv_getStorePricings()
3517 
 
3518 
  def send_getStorePricings(self, itemIds):
3519 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3520 
    args = getStorePricings_args()
3521 
    args.itemIds = itemIds
3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_getStorePricings(self, ):
3527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3528 
    if mtype == TMessageType.EXCEPTION:
3529 
      x = TApplicationException()
3530 
      x.read(self._iprot)
3531 
      self._iprot.readMessageEnd()
3532 
      raise x
3533 
    result = getStorePricings_result()
3534 
    result.read(self._iprot)
3535 
    self._iprot.readMessageEnd()
3536 
    if result.success is not None:
3537 
      return result.success
3538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3539 
 
7265 rajveer 3540 
  def updateStorePricing(self, sp):
3541 
    """
3542 
    Parameters:
3543 
     - sp
3544 
    """
3545 
    self.send_updateStorePricing(sp)
3546 
    self.recv_updateStorePricing()
7256 rajveer 3547 
 
7265 rajveer 3548 
  def send_updateStorePricing(self, sp):
3549 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3550 
    args = updateStorePricing_args()
3551 
    args.sp = sp
3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_updateStorePricing(self, ):
3557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3558 
    if mtype == TMessageType.EXCEPTION:
3559 
      x = TApplicationException()
3560 
      x.read(self._iprot)
3561 
      self._iprot.readMessageEnd()
3562 
      raise x
3563 
    result = updateStorePricing_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
3566 
    return
3567 
 
7281 kshitij.so 3568 
  def getAllAmazonListedItems(self, ):
3569 
    self.send_getAllAmazonListedItems()
3570 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3571 
 
7281 kshitij.so 3572 
  def send_getAllAmazonListedItems(self, ):
3573 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3574 
    args = getAllAmazonListedItems_args()
3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_getAllAmazonListedItems(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = getAllAmazonListedItems_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
3589 
    if result.success is not None:
3590 
      return result.success
3591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3592 
 
3593 
  def getAmazonItemDetails(self, itemId):
3594 
    """
3595 
    Parameters:
3596 
     - itemId
3597 
    """
3598 
    self.send_getAmazonItemDetails(itemId)
3599 
    return self.recv_getAmazonItemDetails()
3600 
 
3601 
  def send_getAmazonItemDetails(self, itemId):
3602 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3603 
    args = getAmazonItemDetails_args()
3604 
    args.itemId = itemId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_getAmazonItemDetails(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = getAmazonItemDetails_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3619 
    if result.success is not None:
3620 
      return result.success
3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3622 
 
7367 kshitij.so 3623 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3624 
    """
3625 
    Parameters:
3626 
     - itemId
3627 
     - fbaPrice
3628 
     - sellingPrice
3629 
     - isFba
3630 
     - isNonFba
3631 
     - isInventoryOverride
7367 kshitij.so 3632 
     - handlingTime
3633 
     - isCustomTime
7281 kshitij.so 3634 
    """
7367 kshitij.so 3635 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3636 
    self.recv_updateAmazonItemDetails()
3637 
 
7367 kshitij.so 3638 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3639 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3640 
    args = updateAmazonItemDetails_args()
3641 
    args.itemId = itemId
3642 
    args.fbaPrice = fbaPrice
3643 
    args.sellingPrice = sellingPrice
3644 
    args.isFba = isFba
3645 
    args.isNonFba = isNonFba
3646 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3647 
    args.handlingTime = handlingTime
3648 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3649 
    args.write(self._oprot)
3650 
    self._oprot.writeMessageEnd()
3651 
    self._oprot.trans.flush()
3652 
 
3653 
  def recv_updateAmazonItemDetails(self, ):
3654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3655 
    if mtype == TMessageType.EXCEPTION:
3656 
      x = TApplicationException()
3657 
      x.read(self._iprot)
3658 
      self._iprot.readMessageEnd()
3659 
      raise x
3660 
    result = updateAmazonItemDetails_result()
3661 
    result.read(self._iprot)
3662 
    self._iprot.readMessageEnd()
3663 
    return
3664 
 
3665 
  def addAmazonItem(self, amazonlisted):
3666 
    """
3667 
    Parameters:
3668 
     - amazonlisted
3669 
    """
3670 
    self.send_addAmazonItem(amazonlisted)
3671 
    self.recv_addAmazonItem()
3672 
 
3673 
  def send_addAmazonItem(self, amazonlisted):
3674 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3675 
    args = addAmazonItem_args()
3676 
    args.amazonlisted = amazonlisted
3677 
    args.write(self._oprot)
3678 
    self._oprot.writeMessageEnd()
3679 
    self._oprot.trans.flush()
3680 
 
3681 
  def recv_addAmazonItem(self, ):
3682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3683 
    if mtype == TMessageType.EXCEPTION:
3684 
      x = TApplicationException()
3685 
      x.read(self._iprot)
3686 
      self._iprot.readMessageEnd()
3687 
      raise x
3688 
    result = addAmazonItem_result()
3689 
    result.read(self._iprot)
3690 
    self._iprot.readMessageEnd()
3691 
    return
3692 
 
7291 vikram.rag 3693 
  def getAsinItems(self, ):
3694 
    self.send_getAsinItems()
3695 
    return self.recv_getAsinItems()
7281 kshitij.so 3696 
 
7291 vikram.rag 3697 
  def send_getAsinItems(self, ):
3698 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3699 
    args = getAsinItems_args()
3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
3704 
  def recv_getAsinItems(self, ):
3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
3711 
    result = getAsinItems_result()
3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3714 
    if result.success is not None:
3715 
      return result.success
3716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3717 
 
3718 
  def getAllFbaListedItems(self, ):
3719 
    self.send_getAllFbaListedItems()
3720 
    return self.recv_getAllFbaListedItems()
3721 
 
3722 
  def send_getAllFbaListedItems(self, ):
3723 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3724 
    args = getAllFbaListedItems_args()
3725 
    args.write(self._oprot)
3726 
    self._oprot.writeMessageEnd()
3727 
    self._oprot.trans.flush()
3728 
 
3729 
  def recv_getAllFbaListedItems(self, ):
3730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3731 
    if mtype == TMessageType.EXCEPTION:
3732 
      x = TApplicationException()
3733 
      x.read(self._iprot)
3734 
      self._iprot.readMessageEnd()
3735 
      raise x
3736 
    result = getAllFbaListedItems_result()
3737 
    result.read(self._iprot)
3738 
    self._iprot.readMessageEnd()
3739 
    if result.success is not None:
3740 
      return result.success
3741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3742 
 
3743 
  def getAllNonFbaListedItems(self, ):
3744 
    self.send_getAllNonFbaListedItems()
3745 
    return self.recv_getAllNonFbaListedItems()
3746 
 
3747 
  def send_getAllNonFbaListedItems(self, ):
3748 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3749 
    args = getAllNonFbaListedItems_args()
3750 
    args.write(self._oprot)
3751 
    self._oprot.writeMessageEnd()
3752 
    self._oprot.trans.flush()
3753 
 
3754 
  def recv_getAllNonFbaListedItems(self, ):
3755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3756 
    if mtype == TMessageType.EXCEPTION:
3757 
      x = TApplicationException()
3758 
      x.read(self._iprot)
3759 
      self._iprot.readMessageEnd()
3760 
      raise x
3761 
    result = getAllNonFbaListedItems_result()
3762 
    result.read(self._iprot)
3763 
    self._iprot.readMessageEnd()
3764 
    if result.success is not None:
3765 
      return result.success
3766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3767 
 
3768 
 
5944 mandeep.dh 3769 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3770 
  def __init__(self, handler):
3771 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3772 
    self._processMap["addItem"] = Processor.process_addItem
3773 
    self._processMap["updateItem"] = Processor.process_updateItem
3774 
    self._processMap["isActive"] = Processor.process_isActive
3775 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3776 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3777 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3778 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3779 
    self._processMap["getItem"] = Processor.process_getItem
3780 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3781 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3782 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3783 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3784 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3785 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3786 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3787 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3788 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3789 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3790 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3791 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3792 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3793 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3794 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3795 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3796 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3797 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3798 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3799 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3800 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3801 
    self._processMap["addCategory"] = Processor.process_addCategory
3802 
    self._processMap["getCategory"] = Processor.process_getCategory
3803 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3804 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3805 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3806 
    self._processMap["addTag"] = Processor.process_addTag
3807 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3808 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3809 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3810 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3811 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3812 
    self._processMap["addBanner"] = Processor.process_addBanner
3813 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3814 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3815 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3816 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3817 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3818 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3819 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3820 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3821 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3822 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3823 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3824 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3825 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3826 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3827 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3828 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3829 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3830 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3831 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3832 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3833 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3834 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3835 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3836 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3837 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3838 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3839 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3840 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3841 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3842 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3843 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3844 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3845 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3846 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3847 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3848 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3849 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3850 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3851 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3852 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3853 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3854 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3855 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3856 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3857 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3858 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3859 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3860 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3861 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3862 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3863 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3864 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3865 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3866 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3867 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3868 
 
3869 
  def process(self, iprot, oprot):
3870 
    (name, type, seqid) = iprot.readMessageBegin()
3871 
    if name not in self._processMap:
3872 
      iprot.skip(TType.STRUCT)
3873 
      iprot.readMessageEnd()
3874 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3875 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3876 
      x.write(oprot)
3877 
      oprot.writeMessageEnd()
3878 
      oprot.trans.flush()
3879 
      return
3880 
    else:
3881 
      self._processMap[name](self, seqid, iprot, oprot)
3882 
    return True
3883 
 
3884 
  def process_addItem(self, seqid, iprot, oprot):
3885 
    args = addItem_args()
3886 
    args.read(iprot)
3887 
    iprot.readMessageEnd()
3888 
    result = addItem_result()
3889 
    try:
3890 
      result.success = self._handler.addItem(args.item)
3891 
    except CatalogServiceException, cex:
3892 
      result.cex = cex
3893 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3894 
    result.write(oprot)
3895 
    oprot.writeMessageEnd()
3896 
    oprot.trans.flush()
3897 
 
3898 
  def process_updateItem(self, seqid, iprot, oprot):
3899 
    args = updateItem_args()
3900 
    args.read(iprot)
3901 
    iprot.readMessageEnd()
3902 
    result = updateItem_result()
3903 
    try:
3904 
      result.success = self._handler.updateItem(args.item)
3905 
    except CatalogServiceException, cex:
3906 
      result.cex = cex
3907 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3908 
    result.write(oprot)
3909 
    oprot.writeMessageEnd()
3910 
    oprot.trans.flush()
3911 
 
3912 
  def process_isActive(self, seqid, iprot, oprot):
3913 
    args = isActive_args()
3914 
    args.read(iprot)
3915 
    iprot.readMessageEnd()
3916 
    result = isActive_result()
3917 
    try:
3918 
      result.success = self._handler.isActive(args.itemId)
3919 
    except CatalogServiceException, isex:
3920 
      result.isex = isex
3921 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3922 
    result.write(oprot)
3923 
    oprot.writeMessageEnd()
3924 
    oprot.trans.flush()
3925 
 
3926 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3927 
    args = getItemStatusDescription_args()
3928 
    args.read(iprot)
3929 
    iprot.readMessageEnd()
3930 
    result = getItemStatusDescription_result()
3931 
    try:
3932 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3933 
    except CatalogServiceException, isex:
3934 
      result.isex = isex
3935 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3936 
    result.write(oprot)
3937 
    oprot.writeMessageEnd()
3938 
    oprot.trans.flush()
3939 
 
3940 
  def process_startItemOn(self, seqid, iprot, oprot):
3941 
    args = startItemOn_args()
3942 
    args.read(iprot)
3943 
    iprot.readMessageEnd()
3944 
    result = startItemOn_result()
3945 
    try:
3946 
      self._handler.startItemOn(args.item_id, args.timestamp)
3947 
    except CatalogServiceException, cex:
3948 
      result.cex = cex
3949 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3950 
    result.write(oprot)
3951 
    oprot.writeMessageEnd()
3952 
    oprot.trans.flush()
3953 
 
3954 
  def process_retireItemOn(self, seqid, iprot, oprot):
3955 
    args = retireItemOn_args()
3956 
    args.read(iprot)
3957 
    iprot.readMessageEnd()
3958 
    result = retireItemOn_result()
3959 
    try:
3960 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3961 
    except CatalogServiceException, cex:
3962 
      result.cex = cex
3963 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3964 
    result.write(oprot)
3965 
    oprot.writeMessageEnd()
3966 
    oprot.trans.flush()
3967 
 
3968 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3969 
    args = changeItemStatus_args()
3970 
    args.read(iprot)
3971 
    iprot.readMessageEnd()
3972 
    result = changeItemStatus_result()
3973 
    try:
3974 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3975 
    except CatalogServiceException, cex:
3976 
      result.cex = cex
3977 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3978 
    result.write(oprot)
3979 
    oprot.writeMessageEnd()
3980 
    oprot.trans.flush()
3981 
 
3982 
  def process_getItem(self, seqid, iprot, oprot):
3983 
    args = getItem_args()
3984 
    args.read(iprot)
3985 
    iprot.readMessageEnd()
3986 
    result = getItem_result()
3987 
    try:
3988 
      result.success = self._handler.getItem(args.item_id)
3989 
    except CatalogServiceException, cex:
3990 
      result.cex = cex
3991 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3992 
    result.write(oprot)
3993 
    oprot.writeMessageEnd()
3994 
    oprot.trans.flush()
3995 
 
3996 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3997 
    args = getItemsByCatalogId_args()
3998 
    args.read(iprot)
3999 
    iprot.readMessageEnd()
4000 
    result = getItemsByCatalogId_result()
4001 
    try:
4002 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4003 
    except CatalogServiceException, cex:
4004 
      result.cex = cex
4005 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4006 
    result.write(oprot)
4007 
    oprot.writeMessageEnd()
4008 
    oprot.trans.flush()
4009 
 
4010 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4011 
    args = getValidItemsByCatalogId_args()
4012 
    args.read(iprot)
4013 
    iprot.readMessageEnd()
4014 
    result = getValidItemsByCatalogId_result()
4015 
    try:
4016 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4017 
    except CatalogServiceException, cex:
4018 
      result.cex = cex
4019 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4020 
    result.write(oprot)
4021 
    oprot.writeMessageEnd()
4022 
    oprot.trans.flush()
4023 
 
4024 
  def process_getAllItems(self, seqid, iprot, oprot):
4025 
    args = getAllItems_args()
4026 
    args.read(iprot)
4027 
    iprot.readMessageEnd()
4028 
    result = getAllItems_result()
4029 
    try:
4030 
      result.success = self._handler.getAllItems(args.isActive)
4031 
    except CatalogServiceException, cex:
4032 
      result.cex = cex
4033 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4034 
    result.write(oprot)
4035 
    oprot.writeMessageEnd()
4036 
    oprot.trans.flush()
4037 
 
4038 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4039 
    args = getAllItemsByStatus_args()
4040 
    args.read(iprot)
4041 
    iprot.readMessageEnd()
4042 
    result = getAllItemsByStatus_result()
4043 
    try:
4044 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4045 
    except CatalogServiceException, cex:
4046 
      result.cex = cex
4047 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4048 
    result.write(oprot)
4049 
    oprot.writeMessageEnd()
4050 
    oprot.trans.flush()
4051 
 
4052 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4053 
    args = markItemAsContentComplete_args()
4054 
    args.read(iprot)
4055 
    iprot.readMessageEnd()
4056 
    result = markItemAsContentComplete_result()
4057 
    try:
4058 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4059 
    except CatalogServiceException, cex:
4060 
      result.cex = cex
4061 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4062 
    result.write(oprot)
4063 
    oprot.writeMessageEnd()
4064 
    oprot.trans.flush()
4065 
 
4066 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4067 
    args = getAllItemsInRange_args()
4068 
    args.read(iprot)
4069 
    iprot.readMessageEnd()
4070 
    result = getAllItemsInRange_result()
4071 
    try:
4072 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4073 
    except CatalogServiceException, cex:
4074 
      result.cex = cex
4075 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4076 
    result.write(oprot)
4077 
    oprot.writeMessageEnd()
4078 
    oprot.trans.flush()
4079 
 
4080 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4081 
    args = getAllItemsByStatusInRange_args()
4082 
    args.read(iprot)
4083 
    iprot.readMessageEnd()
4084 
    result = getAllItemsByStatusInRange_result()
4085 
    try:
4086 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4087 
    except CatalogServiceException, cex:
4088 
      result.cex = cex
4089 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4090 
    result.write(oprot)
4091 
    oprot.writeMessageEnd()
4092 
    oprot.trans.flush()
4093 
 
4094 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4095 
    args = getItemCountByStatus_args()
4096 
    args.read(iprot)
4097 
    iprot.readMessageEnd()
4098 
    result = getItemCountByStatus_result()
4099 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4100 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4101 
    result.write(oprot)
4102 
    oprot.writeMessageEnd()
4103 
    oprot.trans.flush()
4104 
 
4105 
  def process_getBestSellers(self, seqid, iprot, oprot):
4106 
    args = getBestSellers_args()
4107 
    args.read(iprot)
4108 
    iprot.readMessageEnd()
4109 
    result = getBestSellers_result()
4110 
    try:
4111 
      result.success = self._handler.getBestSellers()
4112 
    except CatalogServiceException, isex:
4113 
      result.isex = isex
4114 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4115 
    result.write(oprot)
4116 
    oprot.writeMessageEnd()
4117 
    oprot.trans.flush()
4118 
 
4119 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4120 
    args = getBestSellersCatalogIds_args()
4121 
    args.read(iprot)
4122 
    iprot.readMessageEnd()
4123 
    result = getBestSellersCatalogIds_result()
4124 
    try:
4125 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4126 
    except CatalogServiceException, cex:
4127 
      result.cex = cex
4128 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4129 
    result.write(oprot)
4130 
    oprot.writeMessageEnd()
4131 
    oprot.trans.flush()
4132 
 
4133 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4134 
    args = getBestSellersCount_args()
4135 
    args.read(iprot)
4136 
    iprot.readMessageEnd()
4137 
    result = getBestSellersCount_result()
4138 
    try:
4139 
      result.success = self._handler.getBestSellersCount()
4140 
    except CatalogServiceException, cex:
4141 
      result.cex = cex
4142 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4143 
    result.write(oprot)
4144 
    oprot.writeMessageEnd()
4145 
    oprot.trans.flush()
4146 
 
4147 
  def process_getBestDeals(self, seqid, iprot, oprot):
4148 
    args = getBestDeals_args()
4149 
    args.read(iprot)
4150 
    iprot.readMessageEnd()
4151 
    result = getBestDeals_result()
4152 
    try:
4153 
      result.success = self._handler.getBestDeals()
4154 
    except CatalogServiceException, isex:
4155 
      result.isex = isex
4156 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4157 
    result.write(oprot)
4158 
    oprot.writeMessageEnd()
4159 
    oprot.trans.flush()
4160 
 
4161 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4162 
    args = getBestDealsCatalogIds_args()
4163 
    args.read(iprot)
4164 
    iprot.readMessageEnd()
4165 
    result = getBestDealsCatalogIds_result()
4166 
    try:
4167 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4168 
    except CatalogServiceException, cex:
4169 
      result.cex = cex
4170 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4171 
    result.write(oprot)
4172 
    oprot.writeMessageEnd()
4173 
    oprot.trans.flush()
4174 
 
4175 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4176 
    args = getBestDealsCount_args()
4177 
    args.read(iprot)
4178 
    iprot.readMessageEnd()
4179 
    result = getBestDealsCount_result()
4180 
    try:
4181 
      result.success = self._handler.getBestDealsCount()
4182 
    except CatalogServiceException, cex:
4183 
      result.cex = cex
4184 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4185 
    result.write(oprot)
4186 
    oprot.writeMessageEnd()
4187 
    oprot.trans.flush()
4188 
 
4189 
  def process_getComingSoon(self, seqid, iprot, oprot):
4190 
    args = getComingSoon_args()
4191 
    args.read(iprot)
4192 
    iprot.readMessageEnd()
4193 
    result = getComingSoon_result()
4194 
    try:
4195 
      result.success = self._handler.getComingSoon()
4196 
    except CatalogServiceException, isex:
4197 
      result.isex = isex
4198 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4199 
    result.write(oprot)
4200 
    oprot.writeMessageEnd()
4201 
    oprot.trans.flush()
4202 
 
4203 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4204 
    args = getComingSoonCatalogIds_args()
4205 
    args.read(iprot)
4206 
    iprot.readMessageEnd()
4207 
    result = getComingSoonCatalogIds_result()
4208 
    try:
4209 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4210 
    except CatalogServiceException, cex:
4211 
      result.cex = cex
4212 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4213 
    result.write(oprot)
4214 
    oprot.writeMessageEnd()
4215 
    oprot.trans.flush()
4216 
 
4217 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4218 
    args = getComingSoonCount_args()
4219 
    args.read(iprot)
4220 
    iprot.readMessageEnd()
4221 
    result = getComingSoonCount_result()
4222 
    try:
4223 
      result.success = self._handler.getComingSoonCount()
4224 
    except CatalogServiceException, cex:
4225 
      result.cex = cex
4226 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4227 
    result.write(oprot)
4228 
    oprot.writeMessageEnd()
4229 
    oprot.trans.flush()
4230 
 
4231 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4232 
    args = getLatestArrivals_args()
4233 
    args.read(iprot)
4234 
    iprot.readMessageEnd()
4235 
    result = getLatestArrivals_result()
4236 
    try:
4237 
      result.success = self._handler.getLatestArrivals()
4238 
    except CatalogServiceException, isex:
4239 
      result.isex = isex
4240 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4241 
    result.write(oprot)
4242 
    oprot.writeMessageEnd()
4243 
    oprot.trans.flush()
4244 
 
4245 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4246 
    args = getLatestArrivalsCatalogIds_args()
4247 
    args.read(iprot)
4248 
    iprot.readMessageEnd()
4249 
    result = getLatestArrivalsCatalogIds_result()
4250 
    try:
4251 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4252 
    except CatalogServiceException, cex:
4253 
      result.cex = cex
4254 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4255 
    result.write(oprot)
4256 
    oprot.writeMessageEnd()
4257 
    oprot.trans.flush()
4258 
 
4259 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4260 
    args = getLatestArrivalsCount_args()
4261 
    args.read(iprot)
4262 
    iprot.readMessageEnd()
4263 
    result = getLatestArrivalsCount_result()
4264 
    try:
4265 
      result.success = self._handler.getLatestArrivalsCount()
4266 
    except CatalogServiceException, cex:
4267 
      result.cex = cex
4268 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4269 
    result.write(oprot)
4270 
    oprot.writeMessageEnd()
4271 
    oprot.trans.flush()
4272 
 
4273 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4274 
    args = generateNewEntityID_args()
4275 
    args.read(iprot)
4276 
    iprot.readMessageEnd()
4277 
    result = generateNewEntityID_result()
4278 
    result.success = self._handler.generateNewEntityID()
4279 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4280 
    result.write(oprot)
4281 
    oprot.writeMessageEnd()
4282 
    oprot.trans.flush()
4283 
 
4284 
  def process_addCategory(self, seqid, iprot, oprot):
4285 
    args = addCategory_args()
4286 
    args.read(iprot)
4287 
    iprot.readMessageEnd()
4288 
    result = addCategory_result()
4289 
    result.success = self._handler.addCategory(args.category)
4290 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4291 
    result.write(oprot)
4292 
    oprot.writeMessageEnd()
4293 
    oprot.trans.flush()
4294 
 
4295 
  def process_getCategory(self, seqid, iprot, oprot):
4296 
    args = getCategory_args()
4297 
    args.read(iprot)
4298 
    iprot.readMessageEnd()
4299 
    result = getCategory_result()
4300 
    result.success = self._handler.getCategory(args.id)
4301 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4302 
    result.write(oprot)
4303 
    oprot.writeMessageEnd()
4304 
    oprot.trans.flush()
4305 
 
4306 
  def process_getAllCategories(self, seqid, iprot, oprot):
4307 
    args = getAllCategories_args()
4308 
    args.read(iprot)
4309 
    iprot.readMessageEnd()
4310 
    result = getAllCategories_result()
4311 
    result.success = self._handler.getAllCategories()
4312 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4313 
    result.write(oprot)
4314 
    oprot.writeMessageEnd()
4315 
    oprot.trans.flush()
4316 
 
4317 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4318 
    args = getAllSimilarItems_args()
4319 
    args.read(iprot)
4320 
    iprot.readMessageEnd()
4321 
    result = getAllSimilarItems_result()
4322 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4323 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4324 
    result.write(oprot)
4325 
    oprot.writeMessageEnd()
4326 
    oprot.trans.flush()
4327 
 
4328 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4329 
    args = addSimilarItem_args()
4330 
    args.read(iprot)
4331 
    iprot.readMessageEnd()
4332 
    result = addSimilarItem_result()
4333 
    try:
4334 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4335 
    except CatalogServiceException, cex:
4336 
      result.cex = cex
4337 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4338 
    result.write(oprot)
4339 
    oprot.writeMessageEnd()
4340 
    oprot.trans.flush()
4341 
 
6512 kshitij.so 4342 
  def process_addTag(self, seqid, iprot, oprot):
4343 
    args = addTag_args()
4344 
    args.read(iprot)
4345 
    iprot.readMessageEnd()
4346 
    result = addTag_result()
4347 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4348 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4349 
    result.write(oprot)
4350 
    oprot.writeMessageEnd()
4351 
    oprot.trans.flush()
4352 
 
4353 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4354 
    args = deleteEntityTag_args()
4355 
    args.read(iprot)
4356 
    iprot.readMessageEnd()
4357 
    result = deleteEntityTag_result()
4358 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4359 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4360 
    result.write(oprot)
4361 
    oprot.writeMessageEnd()
4362 
    oprot.trans.flush()
4363 
 
4364 
  def process_deleteTag(self, seqid, iprot, oprot):
4365 
    args = deleteTag_args()
4366 
    args.read(iprot)
4367 
    iprot.readMessageEnd()
4368 
    result = deleteTag_result()
4369 
    result.success = self._handler.deleteTag(args.displayName)
4370 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4371 
    result.write(oprot)
4372 
    oprot.writeMessageEnd()
4373 
    oprot.trans.flush()
4374 
 
4375 
  def process_getAllTags(self, seqid, iprot, oprot):
4376 
    args = getAllTags_args()
4377 
    args.read(iprot)
4378 
    iprot.readMessageEnd()
4379 
    result = getAllTags_result()
4380 
    result.success = self._handler.getAllTags()
4381 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4382 
    result.write(oprot)
4383 
    oprot.writeMessageEnd()
4384 
    oprot.trans.flush()
4385 
 
4386 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4387 
    args = getAllEntitiesByTagName_args()
4388 
    args.read(iprot)
4389 
    iprot.readMessageEnd()
4390 
    result = getAllEntitiesByTagName_result()
4391 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4392 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4393 
    result.write(oprot)
4394 
    oprot.writeMessageEnd()
4395 
    oprot.trans.flush()
4396 
 
6845 amit.gupta 4397 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4398 
    args = getAllEntityTags_args()
4399 
    args.read(iprot)
4400 
    iprot.readMessageEnd()
4401 
    result = getAllEntityTags_result()
4402 
    result.success = self._handler.getAllEntityTags()
4403 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4404 
    result.write(oprot)
4405 
    oprot.writeMessageEnd()
4406 
    oprot.trans.flush()
4407 
 
6850 kshitij.so 4408 
  def process_addBanner(self, seqid, iprot, oprot):
4409 
    args = addBanner_args()
4410 
    args.read(iprot)
4411 
    iprot.readMessageEnd()
4412 
    result = addBanner_result()
4413 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4414 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4415 
    result.write(oprot)
4416 
    oprot.writeMessageEnd()
4417 
    oprot.trans.flush()
4418 
 
4419 
  def process_getAllBanners(self, seqid, iprot, oprot):
4420 
    args = getAllBanners_args()
4421 
    args.read(iprot)
4422 
    iprot.readMessageEnd()
4423 
    result = getAllBanners_result()
4424 
    result.success = self._handler.getAllBanners()
4425 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4426 
    result.write(oprot)
4427 
    oprot.writeMessageEnd()
4428 
    oprot.trans.flush()
4429 
 
4430 
  def process_deleteBanner(self, seqid, iprot, oprot):
4431 
    args = deleteBanner_args()
4432 
    args.read(iprot)
4433 
    iprot.readMessageEnd()
4434 
    result = deleteBanner_result()
4435 
    result.success = self._handler.deleteBanner(args.bannerName)
4436 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4437 
    result.write(oprot)
4438 
    oprot.writeMessageEnd()
4439 
    oprot.trans.flush()
4440 
 
4441 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4442 
    args = getBannerDetails_args()
4443 
    args.read(iprot)
4444 
    iprot.readMessageEnd()
4445 
    result = getBannerDetails_result()
4446 
    result.success = self._handler.getBannerDetails(args.bannerName)
4447 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4448 
    result.write(oprot)
4449 
    oprot.writeMessageEnd()
4450 
    oprot.trans.flush()
4451 
 
4452 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4453 
    args = getActiveBanners_args()
4454 
    args.read(iprot)
4455 
    iprot.readMessageEnd()
4456 
    result = getActiveBanners_result()
4457 
    result.success = self._handler.getActiveBanners()
4458 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4459 
    result.write(oprot)
4460 
    oprot.writeMessageEnd()
4461 
    oprot.trans.flush()
4462 
 
6849 kshitij.so 4463 
  def process_addBannerMap(self, seqid, iprot, oprot):
4464 
    args = addBannerMap_args()
4465 
    args.read(iprot)
4466 
    iprot.readMessageEnd()
4467 
    result = addBannerMap_result()
4468 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4469 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4470 
    result.write(oprot)
4471 
    oprot.writeMessageEnd()
4472 
    oprot.trans.flush()
4473 
 
4474 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4475 
    args = deleteBannerMap_args()
4476 
    args.read(iprot)
4477 
    iprot.readMessageEnd()
4478 
    result = deleteBannerMap_result()
4479 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4480 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4481 
    result.write(oprot)
4482 
    oprot.writeMessageEnd()
4483 
    oprot.trans.flush()
4484 
 
4485 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4486 
    args = getBannerMapDetails_args()
4487 
    args.read(iprot)
4488 
    iprot.readMessageEnd()
4489 
    result = getBannerMapDetails_result()
4490 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4491 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4492 
    result.write(oprot)
4493 
    oprot.writeMessageEnd()
4494 
    oprot.trans.flush()
4495 
 
5944 mandeep.dh 4496 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4497 
    args = deleteSimilarItem_args()
4498 
    args.read(iprot)
4499 
    iprot.readMessageEnd()
4500 
    result = deleteSimilarItem_result()
4501 
    try:
4502 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4503 
    except CatalogServiceException, cex:
4504 
      result.cex = cex
4505 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4506 
    result.write(oprot)
4507 
    oprot.writeMessageEnd()
4508 
    oprot.trans.flush()
4509 
 
4510 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4511 
    args = checkSimilarItem_args()
4512 
    args.read(iprot)
4513 
    iprot.readMessageEnd()
4514 
    result = checkSimilarItem_result()
4515 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4516 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4517 
    result.write(oprot)
4518 
    oprot.writeMessageEnd()
4519 
    oprot.trans.flush()
4520 
 
4521 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4522 
    args = validateRiskyStatus_args()
4523 
    args.read(iprot)
4524 
    iprot.readMessageEnd()
4525 
    result = validateRiskyStatus_result()
4526 
    self._handler.validateRiskyStatus(args.itemId)
4527 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4528 
    result.write(oprot)
4529 
    oprot.writeMessageEnd()
4530 
    oprot.trans.flush()
4531 
 
4532 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4533 
    args = changeItemRiskyFlag_args()
4534 
    args.read(iprot)
4535 
    iprot.readMessageEnd()
4536 
    result = changeItemRiskyFlag_result()
4537 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4538 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4539 
    result.write(oprot)
4540 
    oprot.writeMessageEnd()
4541 
    oprot.trans.flush()
4542 
 
4543 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4544 
    args = getItemsByRiskyFlag_args()
4545 
    args.read(iprot)
4546 
    iprot.readMessageEnd()
4547 
    result = getItemsByRiskyFlag_result()
4548 
    result.success = self._handler.getItemsByRiskyFlag()
4549 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4550 
    result.write(oprot)
4551 
    oprot.writeMessageEnd()
4552 
    oprot.trans.flush()
4553 
 
4554 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4555 
    args = getItemsForMasterSheet_args()
4556 
    args.read(iprot)
4557 
    iprot.readMessageEnd()
4558 
    result = getItemsForMasterSheet_result()
4559 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4560 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4561 
    result.write(oprot)
4562 
    oprot.writeMessageEnd()
4563 
    oprot.trans.flush()
4564 
 
4565 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4566 
    args = getSimilarItemsCatalogIds_args()
4567 
    args.read(iprot)
4568 
    iprot.readMessageEnd()
4569 
    result = getSimilarItemsCatalogIds_result()
4570 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4571 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4572 
    result.write(oprot)
4573 
    oprot.writeMessageEnd()
4574 
    oprot.trans.flush()
4575 
 
4576 
  def process_addProductNotification(self, seqid, iprot, oprot):
4577 
    args = addProductNotification_args()
4578 
    args.read(iprot)
4579 
    iprot.readMessageEnd()
4580 
    result = addProductNotification_result()
4581 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4582 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4583 
    result.write(oprot)
4584 
    oprot.writeMessageEnd()
4585 
    oprot.trans.flush()
4586 
 
4587 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4588 
    args = sendProductNotifications_args()
4589 
    args.read(iprot)
4590 
    iprot.readMessageEnd()
4591 
    result = sendProductNotifications_result()
4592 
    result.success = self._handler.sendProductNotifications()
4593 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4594 
    result.write(oprot)
4595 
    oprot.writeMessageEnd()
4596 
    oprot.trans.flush()
4597 
 
4598 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4599 
    args = getAllBrandsByCategory_args()
4600 
    args.read(iprot)
4601 
    iprot.readMessageEnd()
4602 
    result = getAllBrandsByCategory_result()
4603 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4604 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
4608 
 
4609 
  def process_getAllBrands(self, seqid, iprot, oprot):
4610 
    args = getAllBrands_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = getAllBrands_result()
4614 
    result.success = self._handler.getAllBrands()
4615 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4616 
    result.write(oprot)
4617 
    oprot.writeMessageEnd()
4618 
    oprot.trans.flush()
4619 
 
4620 
  def process_getAllSources(self, seqid, iprot, oprot):
4621 
    args = getAllSources_args()
4622 
    args.read(iprot)
4623 
    iprot.readMessageEnd()
4624 
    result = getAllSources_result()
4625 
    result.success = self._handler.getAllSources()
4626 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4627 
    result.write(oprot)
4628 
    oprot.writeMessageEnd()
4629 
    oprot.trans.flush()
4630 
 
4631 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4632 
    args = getItemPricingBySource_args()
4633 
    args.read(iprot)
4634 
    iprot.readMessageEnd()
4635 
    result = getItemPricingBySource_result()
4636 
    try:
4637 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4638 
    except CatalogServiceException, cex:
4639 
      result.cex = cex
4640 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4641 
    result.write(oprot)
4642 
    oprot.writeMessageEnd()
4643 
    oprot.trans.flush()
4644 
 
4645 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4646 
    args = addSourceItemPricing_args()
4647 
    args.read(iprot)
4648 
    iprot.readMessageEnd()
4649 
    result = addSourceItemPricing_result()
4650 
    try:
4651 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4652 
    except CatalogServiceException, cex:
4653 
      result.cex = cex
4654 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4655 
    result.write(oprot)
4656 
    oprot.writeMessageEnd()
4657 
    oprot.trans.flush()
4658 
 
4659 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4660 
    args = getAllSourcePricing_args()
4661 
    args.read(iprot)
4662 
    iprot.readMessageEnd()
4663 
    result = getAllSourcePricing_result()
4664 
    try:
4665 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4666 
    except CatalogServiceException, cex:
4667 
      result.cex = cex
4668 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4669 
    result.write(oprot)
4670 
    oprot.writeMessageEnd()
4671 
    oprot.trans.flush()
4672 
 
4673 
  def process_getItemForSource(self, seqid, iprot, oprot):
4674 
    args = getItemForSource_args()
4675 
    args.read(iprot)
4676 
    iprot.readMessageEnd()
4677 
    result = getItemForSource_result()
4678 
    try:
4679 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4680 
    except CatalogServiceException, cex:
4681 
      result.cex = cex
4682 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4683 
    result.write(oprot)
4684 
    oprot.writeMessageEnd()
4685 
    oprot.trans.flush()
4686 
 
4687 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4688 
    args = searchItemsInRange_args()
4689 
    args.read(iprot)
4690 
    iprot.readMessageEnd()
4691 
    result = searchItemsInRange_result()
4692 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4693 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4694 
    result.write(oprot)
4695 
    oprot.writeMessageEnd()
4696 
    oprot.trans.flush()
4697 
 
4698 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4699 
    args = getSearchResultCount_args()
4700 
    args.read(iprot)
4701 
    iprot.readMessageEnd()
4702 
    result = getSearchResultCount_result()
4703 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4704 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4705 
    result.write(oprot)
4706 
    oprot.writeMessageEnd()
4707 
    oprot.trans.flush()
4708 
 
4709 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4710 
    args = getProductNotifications_args()
4711 
    args.read(iprot)
4712 
    iprot.readMessageEnd()
4713 
    result = getProductNotifications_result()
4714 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4715 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4716 
    result.write(oprot)
4717 
    oprot.writeMessageEnd()
4718 
    oprot.trans.flush()
4719 
 
4720 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4721 
    args = getProductNotificationRequestCount_args()
4722 
    args.read(iprot)
4723 
    iprot.readMessageEnd()
4724 
    result = getProductNotificationRequestCount_result()
4725 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4726 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4727 
    result.write(oprot)
4728 
    oprot.writeMessageEnd()
4729 
    oprot.trans.flush()
4730 
 
4731 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4732 
    args = addAuthorizationLog_args()
4733 
    args.read(iprot)
4734 
    iprot.readMessageEnd()
4735 
    result = addAuthorizationLog_result()
4736 
    try:
4737 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4738 
    except CatalogServiceException, cex:
4739 
      result.cex = cex
4740 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4741 
    result.write(oprot)
4742 
    oprot.writeMessageEnd()
4743 
    oprot.trans.flush()
4744 
 
4745 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4746 
    args = addupdateVoucherForItem_args()
4747 
    args.read(iprot)
4748 
    iprot.readMessageEnd()
4749 
    result = addupdateVoucherForItem_result()
4750 
    try:
4751 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4752 
    except CatalogServiceException, cex:
4753 
      result.cex = cex
4754 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4755 
    result.write(oprot)
4756 
    oprot.writeMessageEnd()
4757 
    oprot.trans.flush()
4758 
 
4759 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4760 
    args = deleteVoucherForItem_args()
4761 
    args.read(iprot)
4762 
    iprot.readMessageEnd()
4763 
    result = deleteVoucherForItem_result()
4764 
    try:
4765 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4766 
    except CatalogServiceException, cex:
4767 
      result.cex = cex
4768 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4769 
    result.write(oprot)
4770 
    oprot.writeMessageEnd()
4771 
    oprot.trans.flush()
4772 
 
4773 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4774 
    args = getVoucherAmount_args()
4775 
    args.read(iprot)
4776 
    iprot.readMessageEnd()
4777 
    result = getVoucherAmount_result()
4778 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4779 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4780 
    result.write(oprot)
4781 
    oprot.writeMessageEnd()
4782 
    oprot.trans.flush()
4783 
 
4784 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4785 
    args = getAllItemVouchers_args()
4786 
    args.read(iprot)
4787 
    iprot.readMessageEnd()
4788 
    result = getAllItemVouchers_result()
4789 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4790 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4791 
    result.write(oprot)
4792 
    oprot.writeMessageEnd()
4793 
    oprot.trans.flush()
4794 
 
4795 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4796 
    args = isValidCatalogItemId_args()
4797 
    args.read(iprot)
4798 
    iprot.readMessageEnd()
4799 
    result = isValidCatalogItemId_result()
4800 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4801 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4802 
    result.write(oprot)
4803 
    oprot.writeMessageEnd()
4804 
    oprot.trans.flush()
4805 
 
6039 amit.gupta 4806 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4807 
    args = getVatPercentageForItem_args()
4808 
    args.read(iprot)
4809 
    iprot.readMessageEnd()
4810 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4811 
    try:
4812 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4813 
    except CatalogServiceException, cex:
4814 
      result.cex = cex
6039 amit.gupta 4815 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4816 
    result.write(oprot)
4817 
    oprot.writeMessageEnd()
4818 
    oprot.trans.flush()
5944 mandeep.dh 4819 
 
6039 amit.gupta 4820 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4821 
    args = getVatAmountForItem_args()
4822 
    args.read(iprot)
4823 
    iprot.readMessageEnd()
4824 
    result = getVatAmountForItem_result()
4825 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4826 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4827 
    result.write(oprot)
4828 
    oprot.writeMessageEnd()
4829 
    oprot.trans.flush()
4830 
 
6531 vikram.rag 4831 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4832 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4833 
    args.read(iprot)
4834 
    iprot.readMessageEnd()
4835 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4836 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4837 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4838 
    result.write(oprot)
4839 
    oprot.writeMessageEnd()
4840 
    oprot.trans.flush()
6039 amit.gupta 4841 
 
6821 amar.kumar 4842 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4843 
    args = getAllAliveItems_args()
4844 
    args.read(iprot)
4845 
    iprot.readMessageEnd()
4846 
    result = getAllAliveItems_result()
4847 
    result.success = self._handler.getAllAliveItems()
4848 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4849 
    result.write(oprot)
4850 
    oprot.writeMessageEnd()
4851 
    oprot.trans.flush()
4852 
 
6805 anupam.sin 4853 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4854 
    args = getInsuranceAmount_args()
4855 
    args.read(iprot)
4856 
    iprot.readMessageEnd()
4857 
    result = getInsuranceAmount_result()
6921 anupam.sin 4858 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4859 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4860 
    result.write(oprot)
4861 
    oprot.writeMessageEnd()
4862 
    oprot.trans.flush()
6531 vikram.rag 4863 
 
6805 anupam.sin 4864 
  def process_getInsurer(self, seqid, iprot, oprot):
4865 
    args = getInsurer_args()
4866 
    args.read(iprot)
4867 
    iprot.readMessageEnd()
4868 
    result = getInsurer_result()
4869 
    result.success = self._handler.getInsurer(args.insurerId)
4870 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4871 
    result.write(oprot)
4872 
    oprot.writeMessageEnd()
4873 
    oprot.trans.flush()
4874 
 
6838 vikram.rag 4875 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4876 
    args = getAllInsurers_args()
4877 
    args.read(iprot)
4878 
    iprot.readMessageEnd()
4879 
    result = getAllInsurers_result()
4880 
    result.success = self._handler.getAllInsurers()
4881 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4882 
    result.write(oprot)
4883 
    oprot.writeMessageEnd()
4884 
    oprot.trans.flush()
6805 anupam.sin 4885 
 
6962 rajveer 4886 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4887 
    args = updateInsuranceDeclaredAmount_args()
4888 
    args.read(iprot)
4889 
    iprot.readMessageEnd()
4890 
    result = updateInsuranceDeclaredAmount_result()
4891 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4892 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4893 
    result.write(oprot)
4894 
    oprot.writeMessageEnd()
4895 
    oprot.trans.flush()
6838 vikram.rag 4896 
 
7190 amar.kumar 4897 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4898 
    args = getFreebieForItem_args()
4899 
    args.read(iprot)
4900 
    iprot.readMessageEnd()
4901 
    result = getFreebieForItem_result()
4902 
    result.success = self._handler.getFreebieForItem(args.itemId)
4903 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4904 
    result.write(oprot)
4905 
    oprot.writeMessageEnd()
4906 
    oprot.trans.flush()
6962 rajveer 4907 
 
7190 amar.kumar 4908 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4909 
    args = addOrUpdateFreebieForItem_args()
4910 
    args.read(iprot)
4911 
    iprot.readMessageEnd()
4912 
    result = addOrUpdateFreebieForItem_result()
4913 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4914 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4915 
    result.write(oprot)
4916 
    oprot.writeMessageEnd()
4917 
    oprot.trans.flush()
4918 
 
7272 amit.gupta 4919 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4920 
    args = addOrUpdateBrandInfo_args()
4921 
    args.read(iprot)
4922 
    iprot.readMessageEnd()
4923 
    result = addOrUpdateBrandInfo_result()
4924 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4925 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4926 
    result.write(oprot)
4927 
    oprot.writeMessageEnd()
4928 
    oprot.trans.flush()
4929 
 
4930 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4931 
    args = getBrandInfo_args()
4932 
    args.read(iprot)
4933 
    iprot.readMessageEnd()
4934 
    result = getBrandInfo_result()
4935 
    result.success = self._handler.getBrandInfo()
4936 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4937 
    result.write(oprot)
4938 
    oprot.writeMessageEnd()
4939 
    oprot.trans.flush()
4940 
 
7256 rajveer 4941 
  def process_getStorePricing(self, seqid, iprot, oprot):
4942 
    args = getStorePricing_args()
4943 
    args.read(iprot)
4944 
    iprot.readMessageEnd()
4945 
    result = getStorePricing_result()
4946 
    result.success = self._handler.getStorePricing(args.itemId)
4947 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4948 
    result.write(oprot)
4949 
    oprot.writeMessageEnd()
4950 
    oprot.trans.flush()
7190 amar.kumar 4951 
 
7306 rajveer 4952 
  def process_getStorePricings(self, seqid, iprot, oprot):
4953 
    args = getStorePricings_args()
4954 
    args.read(iprot)
4955 
    iprot.readMessageEnd()
4956 
    result = getStorePricings_result()
4957 
    result.success = self._handler.getStorePricings(args.itemIds)
4958 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
4959 
    result.write(oprot)
4960 
    oprot.writeMessageEnd()
4961 
    oprot.trans.flush()
4962 
 
7265 rajveer 4963 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4964 
    args = updateStorePricing_args()
4965 
    args.read(iprot)
4966 
    iprot.readMessageEnd()
4967 
    result = updateStorePricing_result()
4968 
    self._handler.updateStorePricing(args.sp)
4969 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4970 
    result.write(oprot)
4971 
    oprot.writeMessageEnd()
4972 
    oprot.trans.flush()
7256 rajveer 4973 
 
7281 kshitij.so 4974 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4975 
    args = getAllAmazonListedItems_args()
4976 
    args.read(iprot)
4977 
    iprot.readMessageEnd()
4978 
    result = getAllAmazonListedItems_result()
4979 
    result.success = self._handler.getAllAmazonListedItems()
4980 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4981 
    result.write(oprot)
4982 
    oprot.writeMessageEnd()
4983 
    oprot.trans.flush()
7265 rajveer 4984 
 
7281 kshitij.so 4985 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4986 
    args = getAmazonItemDetails_args()
4987 
    args.read(iprot)
4988 
    iprot.readMessageEnd()
4989 
    result = getAmazonItemDetails_result()
4990 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4991 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4992 
    result.write(oprot)
4993 
    oprot.writeMessageEnd()
4994 
    oprot.trans.flush()
4995 
 
4996 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4997 
    args = updateAmazonItemDetails_args()
4998 
    args.read(iprot)
4999 
    iprot.readMessageEnd()
5000 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5001 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5002 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5003 
    result.write(oprot)
5004 
    oprot.writeMessageEnd()
5005 
    oprot.trans.flush()
5006 
 
5007 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5008 
    args = addAmazonItem_args()
5009 
    args.read(iprot)
5010 
    iprot.readMessageEnd()
5011 
    result = addAmazonItem_result()
5012 
    self._handler.addAmazonItem(args.amazonlisted)
5013 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5014 
    result.write(oprot)
5015 
    oprot.writeMessageEnd()
5016 
    oprot.trans.flush()
5017 
 
7291 vikram.rag 5018 
  def process_getAsinItems(self, seqid, iprot, oprot):
5019 
    args = getAsinItems_args()
5020 
    args.read(iprot)
5021 
    iprot.readMessageEnd()
5022 
    result = getAsinItems_result()
5023 
    result.success = self._handler.getAsinItems()
5024 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5025 
    result.write(oprot)
5026 
    oprot.writeMessageEnd()
5027 
    oprot.trans.flush()
7281 kshitij.so 5028 
 
7291 vikram.rag 5029 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5030 
    args = getAllFbaListedItems_args()
5031 
    args.read(iprot)
5032 
    iprot.readMessageEnd()
5033 
    result = getAllFbaListedItems_result()
5034 
    result.success = self._handler.getAllFbaListedItems()
5035 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5036 
    result.write(oprot)
5037 
    oprot.writeMessageEnd()
5038 
    oprot.trans.flush()
5039 
 
5040 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5041 
    args = getAllNonFbaListedItems_args()
5042 
    args.read(iprot)
5043 
    iprot.readMessageEnd()
5044 
    result = getAllNonFbaListedItems_result()
5045 
    result.success = self._handler.getAllNonFbaListedItems()
5046 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5047 
    result.write(oprot)
5048 
    oprot.writeMessageEnd()
5049 
    oprot.trans.flush()
5050 
 
5051 
 
5944 mandeep.dh 5052 
# HELPER FUNCTIONS AND STRUCTURES
5053 
 
5054 
class addItem_args:
5055 
  """
5056 
  Attributes:
5057 
   - item
5058 
  """
5059 
 
5060 
  thrift_spec = (
5061 
    None, # 0
5062 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5063 
  )
5064 
 
5065 
  def __init__(self, item=None,):
5066 
    self.item = item
5067 
 
5068 
  def read(self, iprot):
5069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5071 
      return
5072 
    iprot.readStructBegin()
5073 
    while True:
5074 
      (fname, ftype, fid) = iprot.readFieldBegin()
5075 
      if ftype == TType.STOP:
5076 
        break
5077 
      if fid == 1:
5078 
        if ftype == TType.STRUCT:
5079 
          self.item = Item()
5080 
          self.item.read(iprot)
5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      else:
5084 
        iprot.skip(ftype)
5085 
      iprot.readFieldEnd()
5086 
    iprot.readStructEnd()
5087 
 
5088 
  def write(self, oprot):
5089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5091 
      return
5092 
    oprot.writeStructBegin('addItem_args')
5093 
    if self.item is not None:
5094 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5095 
      self.item.write(oprot)
5096 
      oprot.writeFieldEnd()
5097 
    oprot.writeFieldStop()
5098 
    oprot.writeStructEnd()
5099 
 
5100 
  def validate(self):
5101 
    return
5102 
 
5103 
 
5104 
  def __repr__(self):
5105 
    L = ['%s=%r' % (key, value)
5106 
      for key, value in self.__dict__.iteritems()]
5107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5108 
 
5109 
  def __eq__(self, other):
5110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5111 
 
5112 
  def __ne__(self, other):
5113 
    return not (self == other)
5114 
 
5115 
class addItem_result:
5116 
  """
5117 
  Attributes:
5118 
   - success
5119 
   - cex
5120 
  """
5121 
 
5122 
  thrift_spec = (
5123 
    (0, TType.I64, 'success', None, None, ), # 0
5124 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5125 
  )
5126 
 
5127 
  def __init__(self, success=None, cex=None,):
5128 
    self.success = success
5129 
    self.cex = cex
5130 
 
5131 
  def read(self, iprot):
5132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5134 
      return
5135 
    iprot.readStructBegin()
5136 
    while True:
5137 
      (fname, ftype, fid) = iprot.readFieldBegin()
5138 
      if ftype == TType.STOP:
5139 
        break
5140 
      if fid == 0:
5141 
        if ftype == TType.I64:
5142 
          self.success = iprot.readI64();
5143 
        else:
5144 
          iprot.skip(ftype)
5145 
      elif fid == 1:
5146 
        if ftype == TType.STRUCT:
5147 
          self.cex = CatalogServiceException()
5148 
          self.cex.read(iprot)
5149 
        else:
5150 
          iprot.skip(ftype)
5151 
      else:
5152 
        iprot.skip(ftype)
5153 
      iprot.readFieldEnd()
5154 
    iprot.readStructEnd()
5155 
 
5156 
  def write(self, oprot):
5157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5159 
      return
5160 
    oprot.writeStructBegin('addItem_result')
5161 
    if self.success is not None:
5162 
      oprot.writeFieldBegin('success', TType.I64, 0)
5163 
      oprot.writeI64(self.success)
5164 
      oprot.writeFieldEnd()
5165 
    if self.cex is not None:
5166 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5167 
      self.cex.write(oprot)
5168 
      oprot.writeFieldEnd()
5169 
    oprot.writeFieldStop()
5170 
    oprot.writeStructEnd()
5171 
 
5172 
  def validate(self):
5173 
    return
5174 
 
5175 
 
5176 
  def __repr__(self):
5177 
    L = ['%s=%r' % (key, value)
5178 
      for key, value in self.__dict__.iteritems()]
5179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5180 
 
5181 
  def __eq__(self, other):
5182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5183 
 
5184 
  def __ne__(self, other):
5185 
    return not (self == other)
5186 
 
5187 
class updateItem_args:
5188 
  """
5189 
  Attributes:
5190 
   - item
5191 
  """
5192 
 
5193 
  thrift_spec = (
5194 
    None, # 0
5195 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5196 
  )
5197 
 
5198 
  def __init__(self, item=None,):
5199 
    self.item = item
5200 
 
5201 
  def read(self, iprot):
5202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5204 
      return
5205 
    iprot.readStructBegin()
5206 
    while True:
5207 
      (fname, ftype, fid) = iprot.readFieldBegin()
5208 
      if ftype == TType.STOP:
5209 
        break
5210 
      if fid == 1:
5211 
        if ftype == TType.STRUCT:
5212 
          self.item = Item()
5213 
          self.item.read(iprot)
5214 
        else:
5215 
          iprot.skip(ftype)
5216 
      else:
5217 
        iprot.skip(ftype)
5218 
      iprot.readFieldEnd()
5219 
    iprot.readStructEnd()
5220 
 
5221 
  def write(self, oprot):
5222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5224 
      return
5225 
    oprot.writeStructBegin('updateItem_args')
5226 
    if self.item is not None:
5227 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5228 
      self.item.write(oprot)
5229 
      oprot.writeFieldEnd()
5230 
    oprot.writeFieldStop()
5231 
    oprot.writeStructEnd()
5232 
 
5233 
  def validate(self):
5234 
    return
5235 
 
5236 
 
5237 
  def __repr__(self):
5238 
    L = ['%s=%r' % (key, value)
5239 
      for key, value in self.__dict__.iteritems()]
5240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5241 
 
5242 
  def __eq__(self, other):
5243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5244 
 
5245 
  def __ne__(self, other):
5246 
    return not (self == other)
5247 
 
5248 
class updateItem_result:
5249 
  """
5250 
  Attributes:
5251 
   - success
5252 
   - cex
5253 
  """
5254 
 
5255 
  thrift_spec = (
5256 
    (0, TType.I64, 'success', None, None, ), # 0
5257 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5258 
  )
5259 
 
5260 
  def __init__(self, success=None, cex=None,):
5261 
    self.success = success
5262 
    self.cex = cex
5263 
 
5264 
  def read(self, iprot):
5265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5267 
      return
5268 
    iprot.readStructBegin()
5269 
    while True:
5270 
      (fname, ftype, fid) = iprot.readFieldBegin()
5271 
      if ftype == TType.STOP:
5272 
        break
5273 
      if fid == 0:
5274 
        if ftype == TType.I64:
5275 
          self.success = iprot.readI64();
5276 
        else:
5277 
          iprot.skip(ftype)
5278 
      elif fid == 1:
5279 
        if ftype == TType.STRUCT:
5280 
          self.cex = CatalogServiceException()
5281 
          self.cex.read(iprot)
5282 
        else:
5283 
          iprot.skip(ftype)
5284 
      else:
5285 
        iprot.skip(ftype)
5286 
      iprot.readFieldEnd()
5287 
    iprot.readStructEnd()
5288 
 
5289 
  def write(self, oprot):
5290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5292 
      return
5293 
    oprot.writeStructBegin('updateItem_result')
5294 
    if self.success is not None:
5295 
      oprot.writeFieldBegin('success', TType.I64, 0)
5296 
      oprot.writeI64(self.success)
5297 
      oprot.writeFieldEnd()
5298 
    if self.cex is not None:
5299 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5300 
      self.cex.write(oprot)
5301 
      oprot.writeFieldEnd()
5302 
    oprot.writeFieldStop()
5303 
    oprot.writeStructEnd()
5304 
 
5305 
  def validate(self):
5306 
    return
5307 
 
5308 
 
5309 
  def __repr__(self):
5310 
    L = ['%s=%r' % (key, value)
5311 
      for key, value in self.__dict__.iteritems()]
5312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5313 
 
5314 
  def __eq__(self, other):
5315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5316 
 
5317 
  def __ne__(self, other):
5318 
    return not (self == other)
5319 
 
5320 
class isActive_args:
5321 
  """
5322 
  Attributes:
5323 
   - itemId
5324 
  """
5325 
 
5326 
  thrift_spec = (
5327 
    None, # 0
5328 
    (1, TType.I64, 'itemId', None, None, ), # 1
5329 
  )
5330 
 
5331 
  def __init__(self, itemId=None,):
5332 
    self.itemId = itemId
5333 
 
5334 
  def read(self, iprot):
5335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5337 
      return
5338 
    iprot.readStructBegin()
5339 
    while True:
5340 
      (fname, ftype, fid) = iprot.readFieldBegin()
5341 
      if ftype == TType.STOP:
5342 
        break
5343 
      if fid == 1:
5344 
        if ftype == TType.I64:
5345 
          self.itemId = iprot.readI64();
5346 
        else:
5347 
          iprot.skip(ftype)
5348 
      else:
5349 
        iprot.skip(ftype)
5350 
      iprot.readFieldEnd()
5351 
    iprot.readStructEnd()
5352 
 
5353 
  def write(self, oprot):
5354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5356 
      return
5357 
    oprot.writeStructBegin('isActive_args')
5358 
    if self.itemId is not None:
5359 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5360 
      oprot.writeI64(self.itemId)
5361 
      oprot.writeFieldEnd()
5362 
    oprot.writeFieldStop()
5363 
    oprot.writeStructEnd()
5364 
 
5365 
  def validate(self):
5366 
    return
5367 
 
5368 
 
5369 
  def __repr__(self):
5370 
    L = ['%s=%r' % (key, value)
5371 
      for key, value in self.__dict__.iteritems()]
5372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5373 
 
5374 
  def __eq__(self, other):
5375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5376 
 
5377 
  def __ne__(self, other):
5378 
    return not (self == other)
5379 
 
5380 
class isActive_result:
5381 
  """
5382 
  Attributes:
5383 
   - success
5384 
   - isex
5385 
  """
5386 
 
5387 
  thrift_spec = (
5388 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5389 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5390 
  )
5391 
 
5392 
  def __init__(self, success=None, isex=None,):
5393 
    self.success = success
5394 
    self.isex = isex
5395 
 
5396 
  def read(self, iprot):
5397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5399 
      return
5400 
    iprot.readStructBegin()
5401 
    while True:
5402 
      (fname, ftype, fid) = iprot.readFieldBegin()
5403 
      if ftype == TType.STOP:
5404 
        break
5405 
      if fid == 0:
5406 
        if ftype == TType.STRUCT:
5407 
          self.success = ItemShippingInfo()
5408 
          self.success.read(iprot)
5409 
        else:
5410 
          iprot.skip(ftype)
5411 
      elif fid == 1:
5412 
        if ftype == TType.STRUCT:
5413 
          self.isex = CatalogServiceException()
5414 
          self.isex.read(iprot)
5415 
        else:
5416 
          iprot.skip(ftype)
5417 
      else:
5418 
        iprot.skip(ftype)
5419 
      iprot.readFieldEnd()
5420 
    iprot.readStructEnd()
5421 
 
5422 
  def write(self, oprot):
5423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5425 
      return
5426 
    oprot.writeStructBegin('isActive_result')
5427 
    if self.success is not None:
5428 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5429 
      self.success.write(oprot)
5430 
      oprot.writeFieldEnd()
5431 
    if self.isex is not None:
5432 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5433 
      self.isex.write(oprot)
5434 
      oprot.writeFieldEnd()
5435 
    oprot.writeFieldStop()
5436 
    oprot.writeStructEnd()
5437 
 
5438 
  def validate(self):
5439 
    return
5440 
 
5441 
 
5442 
  def __repr__(self):
5443 
    L = ['%s=%r' % (key, value)
5444 
      for key, value in self.__dict__.iteritems()]
5445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5446 
 
5447 
  def __eq__(self, other):
5448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5449 
 
5450 
  def __ne__(self, other):
5451 
    return not (self == other)
5452 
 
5453 
class getItemStatusDescription_args:
5454 
  """
5455 
  Attributes:
5456 
   - itemId
5457 
  """
5458 
 
5459 
  thrift_spec = (
5460 
    None, # 0
5461 
    (1, TType.I64, 'itemId', None, None, ), # 1
5462 
  )
5463 
 
5464 
  def __init__(self, itemId=None,):
5465 
    self.itemId = itemId
5466 
 
5467 
  def read(self, iprot):
5468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5470 
      return
5471 
    iprot.readStructBegin()
5472 
    while True:
5473 
      (fname, ftype, fid) = iprot.readFieldBegin()
5474 
      if ftype == TType.STOP:
5475 
        break
5476 
      if fid == 1:
5477 
        if ftype == TType.I64:
5478 
          self.itemId = iprot.readI64();
5479 
        else:
5480 
          iprot.skip(ftype)
5481 
      else:
5482 
        iprot.skip(ftype)
5483 
      iprot.readFieldEnd()
5484 
    iprot.readStructEnd()
5485 
 
5486 
  def write(self, oprot):
5487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5489 
      return
5490 
    oprot.writeStructBegin('getItemStatusDescription_args')
5491 
    if self.itemId is not None:
5492 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5493 
      oprot.writeI64(self.itemId)
5494 
      oprot.writeFieldEnd()
5495 
    oprot.writeFieldStop()
5496 
    oprot.writeStructEnd()
5497 
 
5498 
  def validate(self):
5499 
    return
5500 
 
5501 
 
5502 
  def __repr__(self):
5503 
    L = ['%s=%r' % (key, value)
5504 
      for key, value in self.__dict__.iteritems()]
5505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5506 
 
5507 
  def __eq__(self, other):
5508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5509 
 
5510 
  def __ne__(self, other):
5511 
    return not (self == other)
5512 
 
5513 
class getItemStatusDescription_result:
5514 
  """
5515 
  Attributes:
5516 
   - success
5517 
   - isex
5518 
  """
5519 
 
5520 
  thrift_spec = (
5521 
    (0, TType.STRING, 'success', None, None, ), # 0
5522 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5523 
  )
5524 
 
5525 
  def __init__(self, success=None, isex=None,):
5526 
    self.success = success
5527 
    self.isex = isex
5528 
 
5529 
  def read(self, iprot):
5530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5532 
      return
5533 
    iprot.readStructBegin()
5534 
    while True:
5535 
      (fname, ftype, fid) = iprot.readFieldBegin()
5536 
      if ftype == TType.STOP:
5537 
        break
5538 
      if fid == 0:
5539 
        if ftype == TType.STRING:
5540 
          self.success = iprot.readString();
5541 
        else:
5542 
          iprot.skip(ftype)
5543 
      elif fid == 1:
5544 
        if ftype == TType.STRUCT:
5545 
          self.isex = CatalogServiceException()
5546 
          self.isex.read(iprot)
5547 
        else:
5548 
          iprot.skip(ftype)
5549 
      else:
5550 
        iprot.skip(ftype)
5551 
      iprot.readFieldEnd()
5552 
    iprot.readStructEnd()
5553 
 
5554 
  def write(self, oprot):
5555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5557 
      return
5558 
    oprot.writeStructBegin('getItemStatusDescription_result')
5559 
    if self.success is not None:
5560 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5561 
      oprot.writeString(self.success)
5562 
      oprot.writeFieldEnd()
5563 
    if self.isex is not None:
5564 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5565 
      self.isex.write(oprot)
5566 
      oprot.writeFieldEnd()
5567 
    oprot.writeFieldStop()
5568 
    oprot.writeStructEnd()
5569 
 
5570 
  def validate(self):
5571 
    return
5572 
 
5573 
 
5574 
  def __repr__(self):
5575 
    L = ['%s=%r' % (key, value)
5576 
      for key, value in self.__dict__.iteritems()]
5577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5578 
 
5579 
  def __eq__(self, other):
5580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5581 
 
5582 
  def __ne__(self, other):
5583 
    return not (self == other)
5584 
 
5585 
class startItemOn_args:
5586 
  """
5587 
  Attributes:
5588 
   - item_id
5589 
   - timestamp
5590 
  """
5591 
 
5592 
  thrift_spec = (
5593 
    None, # 0
5594 
    (1, TType.I64, 'item_id', None, None, ), # 1
5595 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5596 
  )
5597 
 
5598 
  def __init__(self, item_id=None, timestamp=None,):
5599 
    self.item_id = item_id
5600 
    self.timestamp = timestamp
5601 
 
5602 
  def read(self, iprot):
5603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5605 
      return
5606 
    iprot.readStructBegin()
5607 
    while True:
5608 
      (fname, ftype, fid) = iprot.readFieldBegin()
5609 
      if ftype == TType.STOP:
5610 
        break
5611 
      if fid == 1:
5612 
        if ftype == TType.I64:
5613 
          self.item_id = iprot.readI64();
5614 
        else:
5615 
          iprot.skip(ftype)
5616 
      elif fid == 2:
5617 
        if ftype == TType.I64:
5618 
          self.timestamp = iprot.readI64();
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      else:
5622 
        iprot.skip(ftype)
5623 
      iprot.readFieldEnd()
5624 
    iprot.readStructEnd()
5625 
 
5626 
  def write(self, oprot):
5627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5629 
      return
5630 
    oprot.writeStructBegin('startItemOn_args')
5631 
    if self.item_id is not None:
5632 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5633 
      oprot.writeI64(self.item_id)
5634 
      oprot.writeFieldEnd()
5635 
    if self.timestamp is not None:
5636 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5637 
      oprot.writeI64(self.timestamp)
5638 
      oprot.writeFieldEnd()
5639 
    oprot.writeFieldStop()
5640 
    oprot.writeStructEnd()
5641 
 
5642 
  def validate(self):
5643 
    return
5644 
 
5645 
 
5646 
  def __repr__(self):
5647 
    L = ['%s=%r' % (key, value)
5648 
      for key, value in self.__dict__.iteritems()]
5649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5650 
 
5651 
  def __eq__(self, other):
5652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5653 
 
5654 
  def __ne__(self, other):
5655 
    return not (self == other)
5656 
 
5657 
class startItemOn_result:
5658 
  """
5659 
  Attributes:
5660 
   - cex
5661 
  """
5662 
 
5663 
  thrift_spec = (
5664 
    None, # 0
5665 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5666 
  )
5667 
 
5668 
  def __init__(self, cex=None,):
5669 
    self.cex = cex
5670 
 
5671 
  def read(self, iprot):
5672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5674 
      return
5675 
    iprot.readStructBegin()
5676 
    while True:
5677 
      (fname, ftype, fid) = iprot.readFieldBegin()
5678 
      if ftype == TType.STOP:
5679 
        break
5680 
      if fid == 1:
5681 
        if ftype == TType.STRUCT:
5682 
          self.cex = CatalogServiceException()
5683 
          self.cex.read(iprot)
5684 
        else:
5685 
          iprot.skip(ftype)
5686 
      else:
5687 
        iprot.skip(ftype)
5688 
      iprot.readFieldEnd()
5689 
    iprot.readStructEnd()
5690 
 
5691 
  def write(self, oprot):
5692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5694 
      return
5695 
    oprot.writeStructBegin('startItemOn_result')
5696 
    if self.cex is not None:
5697 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5698 
      self.cex.write(oprot)
5699 
      oprot.writeFieldEnd()
5700 
    oprot.writeFieldStop()
5701 
    oprot.writeStructEnd()
5702 
 
5703 
  def validate(self):
5704 
    return
5705 
 
5706 
 
5707 
  def __repr__(self):
5708 
    L = ['%s=%r' % (key, value)
5709 
      for key, value in self.__dict__.iteritems()]
5710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5711 
 
5712 
  def __eq__(self, other):
5713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5714 
 
5715 
  def __ne__(self, other):
5716 
    return not (self == other)
5717 
 
5718 
class retireItemOn_args:
5719 
  """
5720 
  Attributes:
5721 
   - item_id
5722 
   - timestamp
5723 
  """
5724 
 
5725 
  thrift_spec = (
5726 
    None, # 0
5727 
    (1, TType.I64, 'item_id', None, None, ), # 1
5728 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5729 
  )
5730 
 
5731 
  def __init__(self, item_id=None, timestamp=None,):
5732 
    self.item_id = item_id
5733 
    self.timestamp = timestamp
5734 
 
5735 
  def read(self, iprot):
5736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5738 
      return
5739 
    iprot.readStructBegin()
5740 
    while True:
5741 
      (fname, ftype, fid) = iprot.readFieldBegin()
5742 
      if ftype == TType.STOP:
5743 
        break
5744 
      if fid == 1:
5745 
        if ftype == TType.I64:
5746 
          self.item_id = iprot.readI64();
5747 
        else:
5748 
          iprot.skip(ftype)
5749 
      elif fid == 2:
5750 
        if ftype == TType.I64:
5751 
          self.timestamp = iprot.readI64();
5752 
        else:
5753 
          iprot.skip(ftype)
5754 
      else:
5755 
        iprot.skip(ftype)
5756 
      iprot.readFieldEnd()
5757 
    iprot.readStructEnd()
5758 
 
5759 
  def write(self, oprot):
5760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5762 
      return
5763 
    oprot.writeStructBegin('retireItemOn_args')
5764 
    if self.item_id is not None:
5765 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5766 
      oprot.writeI64(self.item_id)
5767 
      oprot.writeFieldEnd()
5768 
    if self.timestamp is not None:
5769 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5770 
      oprot.writeI64(self.timestamp)
5771 
      oprot.writeFieldEnd()
5772 
    oprot.writeFieldStop()
5773 
    oprot.writeStructEnd()
5774 
 
5775 
  def validate(self):
5776 
    return
5777 
 
5778 
 
5779 
  def __repr__(self):
5780 
    L = ['%s=%r' % (key, value)
5781 
      for key, value in self.__dict__.iteritems()]
5782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5783 
 
5784 
  def __eq__(self, other):
5785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5786 
 
5787 
  def __ne__(self, other):
5788 
    return not (self == other)
5789 
 
5790 
class retireItemOn_result:
5791 
  """
5792 
  Attributes:
5793 
   - cex
5794 
  """
5795 
 
5796 
  thrift_spec = (
5797 
    None, # 0
5798 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5799 
  )
5800 
 
5801 
  def __init__(self, cex=None,):
5802 
    self.cex = cex
5803 
 
5804 
  def read(self, iprot):
5805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5807 
      return
5808 
    iprot.readStructBegin()
5809 
    while True:
5810 
      (fname, ftype, fid) = iprot.readFieldBegin()
5811 
      if ftype == TType.STOP:
5812 
        break
5813 
      if fid == 1:
5814 
        if ftype == TType.STRUCT:
5815 
          self.cex = CatalogServiceException()
5816 
          self.cex.read(iprot)
5817 
        else:
5818 
          iprot.skip(ftype)
5819 
      else:
5820 
        iprot.skip(ftype)
5821 
      iprot.readFieldEnd()
5822 
    iprot.readStructEnd()
5823 
 
5824 
  def write(self, oprot):
5825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5827 
      return
5828 
    oprot.writeStructBegin('retireItemOn_result')
5829 
    if self.cex is not None:
5830 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5831 
      self.cex.write(oprot)
5832 
      oprot.writeFieldEnd()
5833 
    oprot.writeFieldStop()
5834 
    oprot.writeStructEnd()
5835 
 
5836 
  def validate(self):
5837 
    return
5838 
 
5839 
 
5840 
  def __repr__(self):
5841 
    L = ['%s=%r' % (key, value)
5842 
      for key, value in self.__dict__.iteritems()]
5843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5844 
 
5845 
  def __eq__(self, other):
5846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5847 
 
5848 
  def __ne__(self, other):
5849 
    return not (self == other)
5850 
 
5851 
class changeItemStatus_args:
5852 
  """
5853 
  Attributes:
5854 
   - item_id
5855 
   - timestamp
5856 
   - newstatus
5857 
  """
5858 
 
5859 
  thrift_spec = (
5860 
    None, # 0
5861 
    (1, TType.I64, 'item_id', None, None, ), # 1
5862 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5863 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5864 
  )
5865 
 
5866 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5867 
    self.item_id = item_id
5868 
    self.timestamp = timestamp
5869 
    self.newstatus = newstatus
5870 
 
5871 
  def read(self, iprot):
5872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5874 
      return
5875 
    iprot.readStructBegin()
5876 
    while True:
5877 
      (fname, ftype, fid) = iprot.readFieldBegin()
5878 
      if ftype == TType.STOP:
5879 
        break
5880 
      if fid == 1:
5881 
        if ftype == TType.I64:
5882 
          self.item_id = iprot.readI64();
5883 
        else:
5884 
          iprot.skip(ftype)
5885 
      elif fid == 2:
5886 
        if ftype == TType.I64:
5887 
          self.timestamp = iprot.readI64();
5888 
        else:
5889 
          iprot.skip(ftype)
5890 
      elif fid == 3:
5891 
        if ftype == TType.I32:
5892 
          self.newstatus = iprot.readI32();
5893 
        else:
5894 
          iprot.skip(ftype)
5895 
      else:
5896 
        iprot.skip(ftype)
5897 
      iprot.readFieldEnd()
5898 
    iprot.readStructEnd()
5899 
 
5900 
  def write(self, oprot):
5901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5903 
      return
5904 
    oprot.writeStructBegin('changeItemStatus_args')
5905 
    if self.item_id is not None:
5906 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5907 
      oprot.writeI64(self.item_id)
5908 
      oprot.writeFieldEnd()
5909 
    if self.timestamp is not None:
5910 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5911 
      oprot.writeI64(self.timestamp)
5912 
      oprot.writeFieldEnd()
5913 
    if self.newstatus is not None:
5914 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5915 
      oprot.writeI32(self.newstatus)
5916 
      oprot.writeFieldEnd()
5917 
    oprot.writeFieldStop()
5918 
    oprot.writeStructEnd()
5919 
 
5920 
  def validate(self):
5921 
    return
5922 
 
5923 
 
5924 
  def __repr__(self):
5925 
    L = ['%s=%r' % (key, value)
5926 
      for key, value in self.__dict__.iteritems()]
5927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5928 
 
5929 
  def __eq__(self, other):
5930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5931 
 
5932 
  def __ne__(self, other):
5933 
    return not (self == other)
5934 
 
5935 
class changeItemStatus_result:
5936 
  """
5937 
  Attributes:
5938 
   - cex
5939 
  """
5940 
 
5941 
  thrift_spec = (
5942 
    None, # 0
5943 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5944 
  )
5945 
 
5946 
  def __init__(self, cex=None,):
5947 
    self.cex = cex
5948 
 
5949 
  def read(self, iprot):
5950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5952 
      return
5953 
    iprot.readStructBegin()
5954 
    while True:
5955 
      (fname, ftype, fid) = iprot.readFieldBegin()
5956 
      if ftype == TType.STOP:
5957 
        break
5958 
      if fid == 1:
5959 
        if ftype == TType.STRUCT:
5960 
          self.cex = CatalogServiceException()
5961 
          self.cex.read(iprot)
5962 
        else:
5963 
          iprot.skip(ftype)
5964 
      else:
5965 
        iprot.skip(ftype)
5966 
      iprot.readFieldEnd()
5967 
    iprot.readStructEnd()
5968 
 
5969 
  def write(self, oprot):
5970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5972 
      return
5973 
    oprot.writeStructBegin('changeItemStatus_result')
5974 
    if self.cex is not None:
5975 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5976 
      self.cex.write(oprot)
5977 
      oprot.writeFieldEnd()
5978 
    oprot.writeFieldStop()
5979 
    oprot.writeStructEnd()
5980 
 
5981 
  def validate(self):
5982 
    return
5983 
 
5984 
 
5985 
  def __repr__(self):
5986 
    L = ['%s=%r' % (key, value)
5987 
      for key, value in self.__dict__.iteritems()]
5988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5989 
 
5990 
  def __eq__(self, other):
5991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5992 
 
5993 
  def __ne__(self, other):
5994 
    return not (self == other)
5995 
 
5996 
class getItem_args:
5997 
  """
5998 
  Attributes:
5999 
   - item_id
6000 
  """
6001 
 
6002 
  thrift_spec = (
6003 
    None, # 0
6004 
    (1, TType.I64, 'item_id', None, None, ), # 1
6005 
  )
6006 
 
6007 
  def __init__(self, item_id=None,):
6008 
    self.item_id = item_id
6009 
 
6010 
  def read(self, iprot):
6011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6013 
      return
6014 
    iprot.readStructBegin()
6015 
    while True:
6016 
      (fname, ftype, fid) = iprot.readFieldBegin()
6017 
      if ftype == TType.STOP:
6018 
        break
6019 
      if fid == 1:
6020 
        if ftype == TType.I64:
6021 
          self.item_id = iprot.readI64();
6022 
        else:
6023 
          iprot.skip(ftype)
6024 
      else:
6025 
        iprot.skip(ftype)
6026 
      iprot.readFieldEnd()
6027 
    iprot.readStructEnd()
6028 
 
6029 
  def write(self, oprot):
6030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6032 
      return
6033 
    oprot.writeStructBegin('getItem_args')
6034 
    if self.item_id is not None:
6035 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6036 
      oprot.writeI64(self.item_id)
6037 
      oprot.writeFieldEnd()
6038 
    oprot.writeFieldStop()
6039 
    oprot.writeStructEnd()
6040 
 
6041 
  def validate(self):
6042 
    return
6043 
 
6044 
 
6045 
  def __repr__(self):
6046 
    L = ['%s=%r' % (key, value)
6047 
      for key, value in self.__dict__.iteritems()]
6048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6049 
 
6050 
  def __eq__(self, other):
6051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6052 
 
6053 
  def __ne__(self, other):
6054 
    return not (self == other)
6055 
 
6056 
class getItem_result:
6057 
  """
6058 
  Attributes:
6059 
   - success
6060 
   - cex
6061 
  """
6062 
 
6063 
  thrift_spec = (
6064 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6065 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6066 
  )
6067 
 
6068 
  def __init__(self, success=None, cex=None,):
6069 
    self.success = success
6070 
    self.cex = cex
6071 
 
6072 
  def read(self, iprot):
6073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6075 
      return
6076 
    iprot.readStructBegin()
6077 
    while True:
6078 
      (fname, ftype, fid) = iprot.readFieldBegin()
6079 
      if ftype == TType.STOP:
6080 
        break
6081 
      if fid == 0:
6082 
        if ftype == TType.STRUCT:
6083 
          self.success = Item()
6084 
          self.success.read(iprot)
6085 
        else:
6086 
          iprot.skip(ftype)
6087 
      elif fid == 1:
6088 
        if ftype == TType.STRUCT:
6089 
          self.cex = CatalogServiceException()
6090 
          self.cex.read(iprot)
6091 
        else:
6092 
          iprot.skip(ftype)
6093 
      else:
6094 
        iprot.skip(ftype)
6095 
      iprot.readFieldEnd()
6096 
    iprot.readStructEnd()
6097 
 
6098 
  def write(self, oprot):
6099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6101 
      return
6102 
    oprot.writeStructBegin('getItem_result')
6103 
    if self.success is not None:
6104 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6105 
      self.success.write(oprot)
6106 
      oprot.writeFieldEnd()
6107 
    if self.cex is not None:
6108 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6109 
      self.cex.write(oprot)
6110 
      oprot.writeFieldEnd()
6111 
    oprot.writeFieldStop()
6112 
    oprot.writeStructEnd()
6113 
 
6114 
  def validate(self):
6115 
    return
6116 
 
6117 
 
6118 
  def __repr__(self):
6119 
    L = ['%s=%r' % (key, value)
6120 
      for key, value in self.__dict__.iteritems()]
6121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6122 
 
6123 
  def __eq__(self, other):
6124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6125 
 
6126 
  def __ne__(self, other):
6127 
    return not (self == other)
6128 
 
6129 
class getItemsByCatalogId_args:
6130 
  """
6131 
  Attributes:
6132 
   - catalog_item_id
6133 
  """
6134 
 
6135 
  thrift_spec = (
6136 
    None, # 0
6137 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6138 
  )
6139 
 
6140 
  def __init__(self, catalog_item_id=None,):
6141 
    self.catalog_item_id = catalog_item_id
6142 
 
6143 
  def read(self, iprot):
6144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6146 
      return
6147 
    iprot.readStructBegin()
6148 
    while True:
6149 
      (fname, ftype, fid) = iprot.readFieldBegin()
6150 
      if ftype == TType.STOP:
6151 
        break
6152 
      if fid == 1:
6153 
        if ftype == TType.I64:
6154 
          self.catalog_item_id = iprot.readI64();
6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      else:
6158 
        iprot.skip(ftype)
6159 
      iprot.readFieldEnd()
6160 
    iprot.readStructEnd()
6161 
 
6162 
  def write(self, oprot):
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6165 
      return
6166 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6167 
    if self.catalog_item_id is not None:
6168 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6169 
      oprot.writeI64(self.catalog_item_id)
6170 
      oprot.writeFieldEnd()
6171 
    oprot.writeFieldStop()
6172 
    oprot.writeStructEnd()
6173 
 
6174 
  def validate(self):
6175 
    return
6176 
 
6177 
 
6178 
  def __repr__(self):
6179 
    L = ['%s=%r' % (key, value)
6180 
      for key, value in self.__dict__.iteritems()]
6181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6182 
 
6183 
  def __eq__(self, other):
6184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6185 
 
6186 
  def __ne__(self, other):
6187 
    return not (self == other)
6188 
 
6189 
class getItemsByCatalogId_result:
6190 
  """
6191 
  Attributes:
6192 
   - success
6193 
   - cex
6194 
  """
6195 
 
6196 
  thrift_spec = (
6197 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6198 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6199 
  )
6200 
 
6201 
  def __init__(self, success=None, cex=None,):
6202 
    self.success = success
6203 
    self.cex = cex
6204 
 
6205 
  def read(self, iprot):
6206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6208 
      return
6209 
    iprot.readStructBegin()
6210 
    while True:
6211 
      (fname, ftype, fid) = iprot.readFieldBegin()
6212 
      if ftype == TType.STOP:
6213 
        break
6214 
      if fid == 0:
6215 
        if ftype == TType.LIST:
6216 
          self.success = []
6217 
          (_etype19, _size16) = iprot.readListBegin()
6218 
          for _i20 in xrange(_size16):
6219 
            _elem21 = Item()
6220 
            _elem21.read(iprot)
6221 
            self.success.append(_elem21)
6222 
          iprot.readListEnd()
6223 
        else:
6224 
          iprot.skip(ftype)
6225 
      elif fid == 1:
6226 
        if ftype == TType.STRUCT:
6227 
          self.cex = CatalogServiceException()
6228 
          self.cex.read(iprot)
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('getItemsByCatalogId_result')
6241 
    if self.success is not None:
6242 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6243 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6244 
      for iter22 in self.success:
6245 
        iter22.write(oprot)
6246 
      oprot.writeListEnd()
6247 
      oprot.writeFieldEnd()
6248 
    if self.cex is not None:
6249 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6250 
      self.cex.write(oprot)
6251 
      oprot.writeFieldEnd()
6252 
    oprot.writeFieldStop()
6253 
    oprot.writeStructEnd()
6254 
 
6255 
  def validate(self):
6256 
    return
6257 
 
6258 
 
6259 
  def __repr__(self):
6260 
    L = ['%s=%r' % (key, value)
6261 
      for key, value in self.__dict__.iteritems()]
6262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6263 
 
6264 
  def __eq__(self, other):
6265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6266 
 
6267 
  def __ne__(self, other):
6268 
    return not (self == other)
6269 
 
6270 
class getValidItemsByCatalogId_args:
6271 
  """
6272 
  Attributes:
6273 
   - catalog_item_id
6274 
  """
6275 
 
6276 
  thrift_spec = (
6277 
    None, # 0
6278 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6279 
  )
6280 
 
6281 
  def __init__(self, catalog_item_id=None,):
6282 
    self.catalog_item_id = catalog_item_id
6283 
 
6284 
  def read(self, iprot):
6285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6287 
      return
6288 
    iprot.readStructBegin()
6289 
    while True:
6290 
      (fname, ftype, fid) = iprot.readFieldBegin()
6291 
      if ftype == TType.STOP:
6292 
        break
6293 
      if fid == 1:
6294 
        if ftype == TType.I64:
6295 
          self.catalog_item_id = iprot.readI64();
6296 
        else:
6297 
          iprot.skip(ftype)
6298 
      else:
6299 
        iprot.skip(ftype)
6300 
      iprot.readFieldEnd()
6301 
    iprot.readStructEnd()
6302 
 
6303 
  def write(self, oprot):
6304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6306 
      return
6307 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6308 
    if self.catalog_item_id is not None:
6309 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6310 
      oprot.writeI64(self.catalog_item_id)
6311 
      oprot.writeFieldEnd()
6312 
    oprot.writeFieldStop()
6313 
    oprot.writeStructEnd()
6314 
 
6315 
  def validate(self):
6316 
    return
6317 
 
6318 
 
6319 
  def __repr__(self):
6320 
    L = ['%s=%r' % (key, value)
6321 
      for key, value in self.__dict__.iteritems()]
6322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6323 
 
6324 
  def __eq__(self, other):
6325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6326 
 
6327 
  def __ne__(self, other):
6328 
    return not (self == other)
6329 
 
6330 
class getValidItemsByCatalogId_result:
6331 
  """
6332 
  Attributes:
6333 
   - success
6334 
   - cex
6335 
  """
6336 
 
6337 
  thrift_spec = (
6338 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6339 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6340 
  )
6341 
 
6342 
  def __init__(self, success=None, cex=None,):
6343 
    self.success = success
6344 
    self.cex = cex
6345 
 
6346 
  def read(self, iprot):
6347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6349 
      return
6350 
    iprot.readStructBegin()
6351 
    while True:
6352 
      (fname, ftype, fid) = iprot.readFieldBegin()
6353 
      if ftype == TType.STOP:
6354 
        break
6355 
      if fid == 0:
6356 
        if ftype == TType.LIST:
6357 
          self.success = []
6358 
          (_etype26, _size23) = iprot.readListBegin()
6359 
          for _i27 in xrange(_size23):
6360 
            _elem28 = Item()
6361 
            _elem28.read(iprot)
6362 
            self.success.append(_elem28)
6363 
          iprot.readListEnd()
6364 
        else:
6365 
          iprot.skip(ftype)
6366 
      elif fid == 1:
6367 
        if ftype == TType.STRUCT:
6368 
          self.cex = CatalogServiceException()
6369 
          self.cex.read(iprot)
6370 
        else:
6371 
          iprot.skip(ftype)
6372 
      else:
6373 
        iprot.skip(ftype)
6374 
      iprot.readFieldEnd()
6375 
    iprot.readStructEnd()
6376 
 
6377 
  def write(self, oprot):
6378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6380 
      return
6381 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6382 
    if self.success is not None:
6383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6385 
      for iter29 in self.success:
6386 
        iter29.write(oprot)
6387 
      oprot.writeListEnd()
6388 
      oprot.writeFieldEnd()
6389 
    if self.cex is not None:
6390 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6391 
      self.cex.write(oprot)
6392 
      oprot.writeFieldEnd()
6393 
    oprot.writeFieldStop()
6394 
    oprot.writeStructEnd()
6395 
 
6396 
  def validate(self):
6397 
    return
6398 
 
6399 
 
6400 
  def __repr__(self):
6401 
    L = ['%s=%r' % (key, value)
6402 
      for key, value in self.__dict__.iteritems()]
6403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6404 
 
6405 
  def __eq__(self, other):
6406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6407 
 
6408 
  def __ne__(self, other):
6409 
    return not (self == other)
6410 
 
6411 
class getAllItems_args:
6412 
  """
6413 
  Attributes:
6414 
   - isActive
6415 
  """
6416 
 
6417 
  thrift_spec = (
6418 
    None, # 0
6419 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6420 
  )
6421 
 
6422 
  def __init__(self, isActive=None,):
6423 
    self.isActive = isActive
6424 
 
6425 
  def read(self, iprot):
6426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6428 
      return
6429 
    iprot.readStructBegin()
6430 
    while True:
6431 
      (fname, ftype, fid) = iprot.readFieldBegin()
6432 
      if ftype == TType.STOP:
6433 
        break
6434 
      if fid == 1:
6435 
        if ftype == TType.BOOL:
6436 
          self.isActive = iprot.readBool();
6437 
        else:
6438 
          iprot.skip(ftype)
6439 
      else:
6440 
        iprot.skip(ftype)
6441 
      iprot.readFieldEnd()
6442 
    iprot.readStructEnd()
6443 
 
6444 
  def write(self, oprot):
6445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6447 
      return
6448 
    oprot.writeStructBegin('getAllItems_args')
6449 
    if self.isActive is not None:
6450 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6451 
      oprot.writeBool(self.isActive)
6452 
      oprot.writeFieldEnd()
6453 
    oprot.writeFieldStop()
6454 
    oprot.writeStructEnd()
6455 
 
6456 
  def validate(self):
6457 
    return
6458 
 
6459 
 
6460 
  def __repr__(self):
6461 
    L = ['%s=%r' % (key, value)
6462 
      for key, value in self.__dict__.iteritems()]
6463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6464 
 
6465 
  def __eq__(self, other):
6466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6467 
 
6468 
  def __ne__(self, other):
6469 
    return not (self == other)
6470 
 
6471 
class getAllItems_result:
6472 
  """
6473 
  Attributes:
6474 
   - success
6475 
   - cex
6476 
  """
6477 
 
6478 
  thrift_spec = (
6479 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6480 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6481 
  )
6482 
 
6483 
  def __init__(self, success=None, cex=None,):
6484 
    self.success = success
6485 
    self.cex = cex
6486 
 
6487 
  def read(self, iprot):
6488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6490 
      return
6491 
    iprot.readStructBegin()
6492 
    while True:
6493 
      (fname, ftype, fid) = iprot.readFieldBegin()
6494 
      if ftype == TType.STOP:
6495 
        break
6496 
      if fid == 0:
6497 
        if ftype == TType.LIST:
6498 
          self.success = []
6499 
          (_etype33, _size30) = iprot.readListBegin()
6500 
          for _i34 in xrange(_size30):
6501 
            _elem35 = Item()
6502 
            _elem35.read(iprot)
6503 
            self.success.append(_elem35)
6504 
          iprot.readListEnd()
6505 
        else:
6506 
          iprot.skip(ftype)
6507 
      elif fid == 1:
6508 
        if ftype == TType.STRUCT:
6509 
          self.cex = CatalogServiceException()
6510 
          self.cex.read(iprot)
6511 
        else:
6512 
          iprot.skip(ftype)
6513 
      else:
6514 
        iprot.skip(ftype)
6515 
      iprot.readFieldEnd()
6516 
    iprot.readStructEnd()
6517 
 
6518 
  def write(self, oprot):
6519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6521 
      return
6522 
    oprot.writeStructBegin('getAllItems_result')
6523 
    if self.success is not None:
6524 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6525 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6526 
      for iter36 in self.success:
6527 
        iter36.write(oprot)
6528 
      oprot.writeListEnd()
6529 
      oprot.writeFieldEnd()
6530 
    if self.cex is not None:
6531 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6532 
      self.cex.write(oprot)
6533 
      oprot.writeFieldEnd()
6534 
    oprot.writeFieldStop()
6535 
    oprot.writeStructEnd()
6536 
 
6537 
  def validate(self):
6538 
    return
6539 
 
6540 
 
6541 
  def __repr__(self):
6542 
    L = ['%s=%r' % (key, value)
6543 
      for key, value in self.__dict__.iteritems()]
6544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6545 
 
6546 
  def __eq__(self, other):
6547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6548 
 
6549 
  def __ne__(self, other):
6550 
    return not (self == other)
6551 
 
6552 
class getAllItemsByStatus_args:
6553 
  """
6554 
  Attributes:
6555 
   - itemStatus
6556 
  """
6557 
 
6558 
  thrift_spec = (
6559 
    None, # 0
6560 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6561 
  )
6562 
 
6563 
  def __init__(self, itemStatus=None,):
6564 
    self.itemStatus = itemStatus
6565 
 
6566 
  def read(self, iprot):
6567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6569 
      return
6570 
    iprot.readStructBegin()
6571 
    while True:
6572 
      (fname, ftype, fid) = iprot.readFieldBegin()
6573 
      if ftype == TType.STOP:
6574 
        break
6575 
      if fid == 1:
6576 
        if ftype == TType.I32:
6577 
          self.itemStatus = iprot.readI32();
6578 
        else:
6579 
          iprot.skip(ftype)
6580 
      else:
6581 
        iprot.skip(ftype)
6582 
      iprot.readFieldEnd()
6583 
    iprot.readStructEnd()
6584 
 
6585 
  def write(self, oprot):
6586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6588 
      return
6589 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6590 
    if self.itemStatus is not None:
6591 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6592 
      oprot.writeI32(self.itemStatus)
6593 
      oprot.writeFieldEnd()
6594 
    oprot.writeFieldStop()
6595 
    oprot.writeStructEnd()
6596 
 
6597 
  def validate(self):
6598 
    return
6599 
 
6600 
 
6601 
  def __repr__(self):
6602 
    L = ['%s=%r' % (key, value)
6603 
      for key, value in self.__dict__.iteritems()]
6604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6605 
 
6606 
  def __eq__(self, other):
6607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6608 
 
6609 
  def __ne__(self, other):
6610 
    return not (self == other)
6611 
 
6612 
class getAllItemsByStatus_result:
6613 
  """
6614 
  Attributes:
6615 
   - success
6616 
   - cex
6617 
  """
6618 
 
6619 
  thrift_spec = (
6620 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6621 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6622 
  )
6623 
 
6624 
  def __init__(self, success=None, cex=None,):
6625 
    self.success = success
6626 
    self.cex = cex
6627 
 
6628 
  def read(self, iprot):
6629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6631 
      return
6632 
    iprot.readStructBegin()
6633 
    while True:
6634 
      (fname, ftype, fid) = iprot.readFieldBegin()
6635 
      if ftype == TType.STOP:
6636 
        break
6637 
      if fid == 0:
6638 
        if ftype == TType.LIST:
6639 
          self.success = []
6640 
          (_etype40, _size37) = iprot.readListBegin()
6641 
          for _i41 in xrange(_size37):
6642 
            _elem42 = Item()
6643 
            _elem42.read(iprot)
6644 
            self.success.append(_elem42)
6645 
          iprot.readListEnd()
6646 
        else:
6647 
          iprot.skip(ftype)
6648 
      elif fid == 1:
6649 
        if ftype == TType.STRUCT:
6650 
          self.cex = CatalogServiceException()
6651 
          self.cex.read(iprot)
6652 
        else:
6653 
          iprot.skip(ftype)
6654 
      else:
6655 
        iprot.skip(ftype)
6656 
      iprot.readFieldEnd()
6657 
    iprot.readStructEnd()
6658 
 
6659 
  def write(self, oprot):
6660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6662 
      return
6663 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6664 
    if self.success is not None:
6665 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6666 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6667 
      for iter43 in self.success:
6668 
        iter43.write(oprot)
6669 
      oprot.writeListEnd()
6670 
      oprot.writeFieldEnd()
6671 
    if self.cex is not None:
6672 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6673 
      self.cex.write(oprot)
6674 
      oprot.writeFieldEnd()
6675 
    oprot.writeFieldStop()
6676 
    oprot.writeStructEnd()
6677 
 
6678 
  def validate(self):
6679 
    return
6680 
 
6681 
 
6682 
  def __repr__(self):
6683 
    L = ['%s=%r' % (key, value)
6684 
      for key, value in self.__dict__.iteritems()]
6685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6686 
 
6687 
  def __eq__(self, other):
6688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6689 
 
6690 
  def __ne__(self, other):
6691 
    return not (self == other)
6692 
 
6693 
class markItemAsContentComplete_args:
6694 
  """
6695 
  Attributes:
6696 
   - entityId
6697 
   - category
6698 
   - brand
6699 
   - modelName
6700 
   - modelNumber
6701 
  """
6702 
 
6703 
  thrift_spec = (
6704 
    None, # 0
6705 
    (1, TType.I64, 'entityId', None, None, ), # 1
6706 
    (2, TType.I64, 'category', None, None, ), # 2
6707 
    (3, TType.STRING, 'brand', None, None, ), # 3
6708 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6709 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6710 
  )
6711 
 
6712 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6713 
    self.entityId = entityId
6714 
    self.category = category
6715 
    self.brand = brand
6716 
    self.modelName = modelName
6717 
    self.modelNumber = modelNumber
6718 
 
6719 
  def read(self, iprot):
6720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6722 
      return
6723 
    iprot.readStructBegin()
6724 
    while True:
6725 
      (fname, ftype, fid) = iprot.readFieldBegin()
6726 
      if ftype == TType.STOP:
6727 
        break
6728 
      if fid == 1:
6729 
        if ftype == TType.I64:
6730 
          self.entityId = iprot.readI64();
6731 
        else:
6732 
          iprot.skip(ftype)
6733 
      elif fid == 2:
6734 
        if ftype == TType.I64:
6735 
          self.category = iprot.readI64();
6736 
        else:
6737 
          iprot.skip(ftype)
6738 
      elif fid == 3:
6739 
        if ftype == TType.STRING:
6740 
          self.brand = iprot.readString();
6741 
        else:
6742 
          iprot.skip(ftype)
6743 
      elif fid == 4:
6744 
        if ftype == TType.STRING:
6745 
          self.modelName = iprot.readString();
6746 
        else:
6747 
          iprot.skip(ftype)
6748 
      elif fid == 5:
6749 
        if ftype == TType.STRING:
6750 
          self.modelNumber = iprot.readString();
6751 
        else:
6752 
          iprot.skip(ftype)
6753 
      else:
6754 
        iprot.skip(ftype)
6755 
      iprot.readFieldEnd()
6756 
    iprot.readStructEnd()
6757 
 
6758 
  def write(self, oprot):
6759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6761 
      return
6762 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6763 
    if self.entityId is not None:
6764 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6765 
      oprot.writeI64(self.entityId)
6766 
      oprot.writeFieldEnd()
6767 
    if self.category is not None:
6768 
      oprot.writeFieldBegin('category', TType.I64, 2)
6769 
      oprot.writeI64(self.category)
6770 
      oprot.writeFieldEnd()
6771 
    if self.brand is not None:
6772 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6773 
      oprot.writeString(self.brand)
6774 
      oprot.writeFieldEnd()
6775 
    if self.modelName is not None:
6776 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6777 
      oprot.writeString(self.modelName)
6778 
      oprot.writeFieldEnd()
6779 
    if self.modelNumber is not None:
6780 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6781 
      oprot.writeString(self.modelNumber)
6782 
      oprot.writeFieldEnd()
6783 
    oprot.writeFieldStop()
6784 
    oprot.writeStructEnd()
6785 
 
6786 
  def validate(self):
6787 
    return
6788 
 
6789 
 
6790 
  def __repr__(self):
6791 
    L = ['%s=%r' % (key, value)
6792 
      for key, value in self.__dict__.iteritems()]
6793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6794 
 
6795 
  def __eq__(self, other):
6796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6797 
 
6798 
  def __ne__(self, other):
6799 
    return not (self == other)
6800 
 
6801 
class markItemAsContentComplete_result:
6802 
  """
6803 
  Attributes:
6804 
   - success
6805 
   - cex
6806 
  """
6807 
 
6808 
  thrift_spec = (
6809 
    (0, TType.BOOL, 'success', None, None, ), # 0
6810 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6811 
  )
6812 
 
6813 
  def __init__(self, success=None, cex=None,):
6814 
    self.success = success
6815 
    self.cex = cex
6816 
 
6817 
  def read(self, iprot):
6818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6820 
      return
6821 
    iprot.readStructBegin()
6822 
    while True:
6823 
      (fname, ftype, fid) = iprot.readFieldBegin()
6824 
      if ftype == TType.STOP:
6825 
        break
6826 
      if fid == 0:
6827 
        if ftype == TType.BOOL:
6828 
          self.success = iprot.readBool();
6829 
        else:
6830 
          iprot.skip(ftype)
6831 
      elif fid == 1:
6832 
        if ftype == TType.STRUCT:
6833 
          self.cex = CatalogServiceException()
6834 
          self.cex.read(iprot)
6835 
        else:
6836 
          iprot.skip(ftype)
6837 
      else:
6838 
        iprot.skip(ftype)
6839 
      iprot.readFieldEnd()
6840 
    iprot.readStructEnd()
6841 
 
6842 
  def write(self, oprot):
6843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6845 
      return
6846 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6847 
    if self.success is not None:
6848 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6849 
      oprot.writeBool(self.success)
6850 
      oprot.writeFieldEnd()
6851 
    if self.cex is not None:
6852 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6853 
      self.cex.write(oprot)
6854 
      oprot.writeFieldEnd()
6855 
    oprot.writeFieldStop()
6856 
    oprot.writeStructEnd()
6857 
 
6858 
  def validate(self):
6859 
    return
6860 
 
6861 
 
6862 
  def __repr__(self):
6863 
    L = ['%s=%r' % (key, value)
6864 
      for key, value in self.__dict__.iteritems()]
6865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6866 
 
6867 
  def __eq__(self, other):
6868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6869 
 
6870 
  def __ne__(self, other):
6871 
    return not (self == other)
6872 
 
6873 
class getAllItemsInRange_args:
6874 
  """
6875 
  Attributes:
6876 
   - offset
6877 
   - limit
6878 
  """
6879 
 
6880 
  thrift_spec = (
6881 
    None, # 0
6882 
    (1, TType.I64, 'offset', None, None, ), # 1
6883 
    (2, TType.I64, 'limit', None, None, ), # 2
6884 
  )
6885 
 
6886 
  def __init__(self, offset=None, limit=None,):
6887 
    self.offset = offset
6888 
    self.limit = limit
6889 
 
6890 
  def read(self, iprot):
6891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6893 
      return
6894 
    iprot.readStructBegin()
6895 
    while True:
6896 
      (fname, ftype, fid) = iprot.readFieldBegin()
6897 
      if ftype == TType.STOP:
6898 
        break
6899 
      if fid == 1:
6900 
        if ftype == TType.I64:
6901 
          self.offset = iprot.readI64();
6902 
        else:
6903 
          iprot.skip(ftype)
6904 
      elif fid == 2:
6905 
        if ftype == TType.I64:
6906 
          self.limit = iprot.readI64();
6907 
        else:
6908 
          iprot.skip(ftype)
6909 
      else:
6910 
        iprot.skip(ftype)
6911 
      iprot.readFieldEnd()
6912 
    iprot.readStructEnd()
6913 
 
6914 
  def write(self, oprot):
6915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6917 
      return
6918 
    oprot.writeStructBegin('getAllItemsInRange_args')
6919 
    if self.offset is not None:
6920 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6921 
      oprot.writeI64(self.offset)
6922 
      oprot.writeFieldEnd()
6923 
    if self.limit is not None:
6924 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6925 
      oprot.writeI64(self.limit)
6926 
      oprot.writeFieldEnd()
6927 
    oprot.writeFieldStop()
6928 
    oprot.writeStructEnd()
6929 
 
6930 
  def validate(self):
6931 
    return
6932 
 
6933 
 
6934 
  def __repr__(self):
6935 
    L = ['%s=%r' % (key, value)
6936 
      for key, value in self.__dict__.iteritems()]
6937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6938 
 
6939 
  def __eq__(self, other):
6940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6941 
 
6942 
  def __ne__(self, other):
6943 
    return not (self == other)
6944 
 
6945 
class getAllItemsInRange_result:
6946 
  """
6947 
  Attributes:
6948 
   - success
6949 
   - cex
6950 
  """
6951 
 
6952 
  thrift_spec = (
6953 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6954 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6955 
  )
6956 
 
6957 
  def __init__(self, success=None, cex=None,):
6958 
    self.success = success
6959 
    self.cex = cex
6960 
 
6961 
  def read(self, iprot):
6962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6964 
      return
6965 
    iprot.readStructBegin()
6966 
    while True:
6967 
      (fname, ftype, fid) = iprot.readFieldBegin()
6968 
      if ftype == TType.STOP:
6969 
        break
6970 
      if fid == 0:
6971 
        if ftype == TType.LIST:
6972 
          self.success = []
6973 
          (_etype47, _size44) = iprot.readListBegin()
6974 
          for _i48 in xrange(_size44):
6975 
            _elem49 = Item()
6976 
            _elem49.read(iprot)
6977 
            self.success.append(_elem49)
6978 
          iprot.readListEnd()
6979 
        else:
6980 
          iprot.skip(ftype)
6981 
      elif fid == 1:
6982 
        if ftype == TType.STRUCT:
6983 
          self.cex = CatalogServiceException()
6984 
          self.cex.read(iprot)
6985 
        else:
6986 
          iprot.skip(ftype)
6987 
      else:
6988 
        iprot.skip(ftype)
6989 
      iprot.readFieldEnd()
6990 
    iprot.readStructEnd()
6991 
 
6992 
  def write(self, oprot):
6993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6995 
      return
6996 
    oprot.writeStructBegin('getAllItemsInRange_result')
6997 
    if self.success is not None:
6998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7000 
      for iter50 in self.success:
7001 
        iter50.write(oprot)
7002 
      oprot.writeListEnd()
7003 
      oprot.writeFieldEnd()
7004 
    if self.cex is not None:
7005 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7006 
      self.cex.write(oprot)
7007 
      oprot.writeFieldEnd()
7008 
    oprot.writeFieldStop()
7009 
    oprot.writeStructEnd()
7010 
 
7011 
  def validate(self):
7012 
    return
7013 
 
7014 
 
7015 
  def __repr__(self):
7016 
    L = ['%s=%r' % (key, value)
7017 
      for key, value in self.__dict__.iteritems()]
7018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7019 
 
7020 
  def __eq__(self, other):
7021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7022 
 
7023 
  def __ne__(self, other):
7024 
    return not (self == other)
7025 
 
7026 
class getAllItemsByStatusInRange_args:
7027 
  """
7028 
  Attributes:
7029 
   - itemStatus
7030 
   - offset
7031 
   - limit
7032 
  """
7033 
 
7034 
  thrift_spec = (
7035 
    None, # 0
7036 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7037 
    (2, TType.I64, 'offset', None, None, ), # 2
7038 
    (3, TType.I64, 'limit', None, None, ), # 3
7039 
  )
7040 
 
7041 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7042 
    self.itemStatus = itemStatus
7043 
    self.offset = offset
7044 
    self.limit = limit
7045 
 
7046 
  def read(self, iprot):
7047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7049 
      return
7050 
    iprot.readStructBegin()
7051 
    while True:
7052 
      (fname, ftype, fid) = iprot.readFieldBegin()
7053 
      if ftype == TType.STOP:
7054 
        break
7055 
      if fid == 1:
7056 
        if ftype == TType.I32:
7057 
          self.itemStatus = iprot.readI32();
7058 
        else:
7059 
          iprot.skip(ftype)
7060 
      elif fid == 2:
7061 
        if ftype == TType.I64:
7062 
          self.offset = iprot.readI64();
7063 
        else:
7064 
          iprot.skip(ftype)
7065 
      elif fid == 3:
7066 
        if ftype == TType.I64:
7067 
          self.limit = iprot.readI64();
7068 
        else:
7069 
          iprot.skip(ftype)
7070 
      else:
7071 
        iprot.skip(ftype)
7072 
      iprot.readFieldEnd()
7073 
    iprot.readStructEnd()
7074 
 
7075 
  def write(self, oprot):
7076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7078 
      return
7079 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7080 
    if self.itemStatus is not None:
7081 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7082 
      oprot.writeI32(self.itemStatus)
7083 
      oprot.writeFieldEnd()
7084 
    if self.offset is not None:
7085 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7086 
      oprot.writeI64(self.offset)
7087 
      oprot.writeFieldEnd()
7088 
    if self.limit is not None:
7089 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7090 
      oprot.writeI64(self.limit)
7091 
      oprot.writeFieldEnd()
7092 
    oprot.writeFieldStop()
7093 
    oprot.writeStructEnd()
7094 
 
7095 
  def validate(self):
7096 
    return
7097 
 
7098 
 
7099 
  def __repr__(self):
7100 
    L = ['%s=%r' % (key, value)
7101 
      for key, value in self.__dict__.iteritems()]
7102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7103 
 
7104 
  def __eq__(self, other):
7105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7106 
 
7107 
  def __ne__(self, other):
7108 
    return not (self == other)
7109 
 
7110 
class getAllItemsByStatusInRange_result:
7111 
  """
7112 
  Attributes:
7113 
   - success
7114 
   - cex
7115 
  """
7116 
 
7117 
  thrift_spec = (
7118 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7119 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7120 
  )
7121 
 
7122 
  def __init__(self, success=None, cex=None,):
7123 
    self.success = success
7124 
    self.cex = cex
7125 
 
7126 
  def read(self, iprot):
7127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7129 
      return
7130 
    iprot.readStructBegin()
7131 
    while True:
7132 
      (fname, ftype, fid) = iprot.readFieldBegin()
7133 
      if ftype == TType.STOP:
7134 
        break
7135 
      if fid == 0:
7136 
        if ftype == TType.LIST:
7137 
          self.success = []
7138 
          (_etype54, _size51) = iprot.readListBegin()
7139 
          for _i55 in xrange(_size51):
7140 
            _elem56 = Item()
7141 
            _elem56.read(iprot)
7142 
            self.success.append(_elem56)
7143 
          iprot.readListEnd()
7144 
        else:
7145 
          iprot.skip(ftype)
7146 
      elif fid == 1:
7147 
        if ftype == TType.STRUCT:
7148 
          self.cex = CatalogServiceException()
7149 
          self.cex.read(iprot)
7150 
        else:
7151 
          iprot.skip(ftype)
7152 
      else:
7153 
        iprot.skip(ftype)
7154 
      iprot.readFieldEnd()
7155 
    iprot.readStructEnd()
7156 
 
7157 
  def write(self, oprot):
7158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7160 
      return
7161 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7162 
    if self.success is not None:
7163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7165 
      for iter57 in self.success:
7166 
        iter57.write(oprot)
7167 
      oprot.writeListEnd()
7168 
      oprot.writeFieldEnd()
7169 
    if self.cex is not None:
7170 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7171 
      self.cex.write(oprot)
7172 
      oprot.writeFieldEnd()
7173 
    oprot.writeFieldStop()
7174 
    oprot.writeStructEnd()
7175 
 
7176 
  def validate(self):
7177 
    return
7178 
 
7179 
 
7180 
  def __repr__(self):
7181 
    L = ['%s=%r' % (key, value)
7182 
      for key, value in self.__dict__.iteritems()]
7183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7184 
 
7185 
  def __eq__(self, other):
7186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7187 
 
7188 
  def __ne__(self, other):
7189 
    return not (self == other)
7190 
 
7191 
class getItemCountByStatus_args:
7192 
  """
7193 
  Attributes:
7194 
   - useStatus
7195 
   - itemStatus
7196 
  """
7197 
 
7198 
  thrift_spec = (
7199 
    None, # 0
7200 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7201 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7202 
  )
7203 
 
7204 
  def __init__(self, useStatus=None, itemStatus=None,):
7205 
    self.useStatus = useStatus
7206 
    self.itemStatus = itemStatus
7207 
 
7208 
  def read(self, iprot):
7209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7211 
      return
7212 
    iprot.readStructBegin()
7213 
    while True:
7214 
      (fname, ftype, fid) = iprot.readFieldBegin()
7215 
      if ftype == TType.STOP:
7216 
        break
7217 
      if fid == 1:
7218 
        if ftype == TType.BOOL:
7219 
          self.useStatus = iprot.readBool();
7220 
        else:
7221 
          iprot.skip(ftype)
7222 
      elif fid == 2:
7223 
        if ftype == TType.I32:
7224 
          self.itemStatus = iprot.readI32();
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      else:
7228 
        iprot.skip(ftype)
7229 
      iprot.readFieldEnd()
7230 
    iprot.readStructEnd()
7231 
 
7232 
  def write(self, oprot):
7233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7235 
      return
7236 
    oprot.writeStructBegin('getItemCountByStatus_args')
7237 
    if self.useStatus is not None:
7238 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7239 
      oprot.writeBool(self.useStatus)
7240 
      oprot.writeFieldEnd()
7241 
    if self.itemStatus is not None:
7242 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7243 
      oprot.writeI32(self.itemStatus)
7244 
      oprot.writeFieldEnd()
7245 
    oprot.writeFieldStop()
7246 
    oprot.writeStructEnd()
7247 
 
7248 
  def validate(self):
7249 
    return
7250 
 
7251 
 
7252 
  def __repr__(self):
7253 
    L = ['%s=%r' % (key, value)
7254 
      for key, value in self.__dict__.iteritems()]
7255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7256 
 
7257 
  def __eq__(self, other):
7258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7259 
 
7260 
  def __ne__(self, other):
7261 
    return not (self == other)
7262 
 
7263 
class getItemCountByStatus_result:
7264 
  """
7265 
  Attributes:
7266 
   - success
7267 
  """
7268 
 
7269 
  thrift_spec = (
7270 
    (0, TType.I32, 'success', None, None, ), # 0
7271 
  )
7272 
 
7273 
  def __init__(self, success=None,):
7274 
    self.success = success
7275 
 
7276 
  def read(self, iprot):
7277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7279 
      return
7280 
    iprot.readStructBegin()
7281 
    while True:
7282 
      (fname, ftype, fid) = iprot.readFieldBegin()
7283 
      if ftype == TType.STOP:
7284 
        break
7285 
      if fid == 0:
7286 
        if ftype == TType.I32:
7287 
          self.success = iprot.readI32();
7288 
        else:
7289 
          iprot.skip(ftype)
7290 
      else:
7291 
        iprot.skip(ftype)
7292 
      iprot.readFieldEnd()
7293 
    iprot.readStructEnd()
7294 
 
7295 
  def write(self, oprot):
7296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7298 
      return
7299 
    oprot.writeStructBegin('getItemCountByStatus_result')
7300 
    if self.success is not None:
7301 
      oprot.writeFieldBegin('success', TType.I32, 0)
7302 
      oprot.writeI32(self.success)
7303 
      oprot.writeFieldEnd()
7304 
    oprot.writeFieldStop()
7305 
    oprot.writeStructEnd()
7306 
 
7307 
  def validate(self):
7308 
    return
7309 
 
7310 
 
7311 
  def __repr__(self):
7312 
    L = ['%s=%r' % (key, value)
7313 
      for key, value in self.__dict__.iteritems()]
7314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7315 
 
7316 
  def __eq__(self, other):
7317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7318 
 
7319 
  def __ne__(self, other):
7320 
    return not (self == other)
7321 
 
7322 
class getBestSellers_args:
7323 
 
7324 
  thrift_spec = (
7325 
  )
7326 
 
7327 
  def read(self, iprot):
7328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7330 
      return
7331 
    iprot.readStructBegin()
7332 
    while True:
7333 
      (fname, ftype, fid) = iprot.readFieldBegin()
7334 
      if ftype == TType.STOP:
7335 
        break
7336 
      else:
7337 
        iprot.skip(ftype)
7338 
      iprot.readFieldEnd()
7339 
    iprot.readStructEnd()
7340 
 
7341 
  def write(self, oprot):
7342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7344 
      return
7345 
    oprot.writeStructBegin('getBestSellers_args')
7346 
    oprot.writeFieldStop()
7347 
    oprot.writeStructEnd()
7348 
 
7349 
  def validate(self):
7350 
    return
7351 
 
7352 
 
7353 
  def __repr__(self):
7354 
    L = ['%s=%r' % (key, value)
7355 
      for key, value in self.__dict__.iteritems()]
7356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7357 
 
7358 
  def __eq__(self, other):
7359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7360 
 
7361 
  def __ne__(self, other):
7362 
    return not (self == other)
7363 
 
7364 
class getBestSellers_result:
7365 
  """
7366 
  Attributes:
7367 
   - success
7368 
   - isex
7369 
  """
7370 
 
7371 
  thrift_spec = (
7372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7373 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7374 
  )
7375 
 
7376 
  def __init__(self, success=None, isex=None,):
7377 
    self.success = success
7378 
    self.isex = isex
7379 
 
7380 
  def read(self, iprot):
7381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7383 
      return
7384 
    iprot.readStructBegin()
7385 
    while True:
7386 
      (fname, ftype, fid) = iprot.readFieldBegin()
7387 
      if ftype == TType.STOP:
7388 
        break
7389 
      if fid == 0:
7390 
        if ftype == TType.LIST:
7391 
          self.success = []
7392 
          (_etype61, _size58) = iprot.readListBegin()
7393 
          for _i62 in xrange(_size58):
7394 
            _elem63 = Item()
7395 
            _elem63.read(iprot)
7396 
            self.success.append(_elem63)
7397 
          iprot.readListEnd()
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      elif fid == 1:
7401 
        if ftype == TType.STRUCT:
7402 
          self.isex = CatalogServiceException()
7403 
          self.isex.read(iprot)
7404 
        else:
7405 
          iprot.skip(ftype)
7406 
      else:
7407 
        iprot.skip(ftype)
7408 
      iprot.readFieldEnd()
7409 
    iprot.readStructEnd()
7410 
 
7411 
  def write(self, oprot):
7412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7414 
      return
7415 
    oprot.writeStructBegin('getBestSellers_result')
7416 
    if self.success is not None:
7417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7419 
      for iter64 in self.success:
7420 
        iter64.write(oprot)
7421 
      oprot.writeListEnd()
7422 
      oprot.writeFieldEnd()
7423 
    if self.isex is not None:
7424 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7425 
      self.isex.write(oprot)
7426 
      oprot.writeFieldEnd()
7427 
    oprot.writeFieldStop()
7428 
    oprot.writeStructEnd()
7429 
 
7430 
  def validate(self):
7431 
    return
7432 
 
7433 
 
7434 
  def __repr__(self):
7435 
    L = ['%s=%r' % (key, value)
7436 
      for key, value in self.__dict__.iteritems()]
7437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7438 
 
7439 
  def __eq__(self, other):
7440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7441 
 
7442 
  def __ne__(self, other):
7443 
    return not (self == other)
7444 
 
7445 
class getBestSellersCatalogIds_args:
7446 
  """
7447 
  Attributes:
7448 
   - beginIndex
7449 
   - totalItems
7450 
   - brand
7451 
   - category
7452 
  """
7453 
 
7454 
  thrift_spec = (
7455 
    None, # 0
7456 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7457 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7458 
    (3, TType.STRING, 'brand', None, None, ), # 3
7459 
    (4, TType.I64, 'category', None, None, ), # 4
7460 
  )
7461 
 
7462 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7463 
    self.beginIndex = beginIndex
7464 
    self.totalItems = totalItems
7465 
    self.brand = brand
7466 
    self.category = category
7467 
 
7468 
  def read(self, iprot):
7469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7471 
      return
7472 
    iprot.readStructBegin()
7473 
    while True:
7474 
      (fname, ftype, fid) = iprot.readFieldBegin()
7475 
      if ftype == TType.STOP:
7476 
        break
7477 
      if fid == 1:
7478 
        if ftype == TType.I64:
7479 
          self.beginIndex = iprot.readI64();
7480 
        else:
7481 
          iprot.skip(ftype)
7482 
      elif fid == 2:
7483 
        if ftype == TType.I64:
7484 
          self.totalItems = iprot.readI64();
7485 
        else:
7486 
          iprot.skip(ftype)
7487 
      elif fid == 3:
7488 
        if ftype == TType.STRING:
7489 
          self.brand = iprot.readString();
7490 
        else:
7491 
          iprot.skip(ftype)
7492 
      elif fid == 4:
7493 
        if ftype == TType.I64:
7494 
          self.category = iprot.readI64();
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('getBestSellersCatalogIds_args')
7507 
    if self.beginIndex is not None:
7508 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7509 
      oprot.writeI64(self.beginIndex)
7510 
      oprot.writeFieldEnd()
7511 
    if self.totalItems is not None:
7512 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7513 
      oprot.writeI64(self.totalItems)
7514 
      oprot.writeFieldEnd()
7515 
    if self.brand is not None:
7516 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7517 
      oprot.writeString(self.brand)
7518 
      oprot.writeFieldEnd()
7519 
    if self.category is not None:
7520 
      oprot.writeFieldBegin('category', TType.I64, 4)
7521 
      oprot.writeI64(self.category)
7522 
      oprot.writeFieldEnd()
7523 
    oprot.writeFieldStop()
7524 
    oprot.writeStructEnd()
7525 
 
7526 
  def validate(self):
7527 
    return
7528 
 
7529 
 
7530 
  def __repr__(self):
7531 
    L = ['%s=%r' % (key, value)
7532 
      for key, value in self.__dict__.iteritems()]
7533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7534 
 
7535 
  def __eq__(self, other):
7536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7537 
 
7538 
  def __ne__(self, other):
7539 
    return not (self == other)
7540 
 
7541 
class getBestSellersCatalogIds_result:
7542 
  """
7543 
  Attributes:
7544 
   - success
7545 
   - cex
7546 
  """
7547 
 
7548 
  thrift_spec = (
7549 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7550 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7551 
  )
7552 
 
7553 
  def __init__(self, success=None, cex=None,):
7554 
    self.success = success
7555 
    self.cex = cex
7556 
 
7557 
  def read(self, iprot):
7558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7560 
      return
7561 
    iprot.readStructBegin()
7562 
    while True:
7563 
      (fname, ftype, fid) = iprot.readFieldBegin()
7564 
      if ftype == TType.STOP:
7565 
        break
7566 
      if fid == 0:
7567 
        if ftype == TType.LIST:
7568 
          self.success = []
7569 
          (_etype68, _size65) = iprot.readListBegin()
7570 
          for _i69 in xrange(_size65):
7571 
            _elem70 = iprot.readI64();
7572 
            self.success.append(_elem70)
7573 
          iprot.readListEnd()
7574 
        else:
7575 
          iprot.skip(ftype)
7576 
      elif fid == 1:
7577 
        if ftype == TType.STRUCT:
7578 
          self.cex = CatalogServiceException()
7579 
          self.cex.read(iprot)
7580 
        else:
7581 
          iprot.skip(ftype)
7582 
      else:
7583 
        iprot.skip(ftype)
7584 
      iprot.readFieldEnd()
7585 
    iprot.readStructEnd()
7586 
 
7587 
  def write(self, oprot):
7588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7590 
      return
7591 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7592 
    if self.success is not None:
7593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7594 
      oprot.writeListBegin(TType.I64, len(self.success))
7595 
      for iter71 in self.success:
7596 
        oprot.writeI64(iter71)
7597 
      oprot.writeListEnd()
7598 
      oprot.writeFieldEnd()
7599 
    if self.cex is not None:
7600 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7601 
      self.cex.write(oprot)
7602 
      oprot.writeFieldEnd()
7603 
    oprot.writeFieldStop()
7604 
    oprot.writeStructEnd()
7605 
 
7606 
  def validate(self):
7607 
    return
7608 
 
7609 
 
7610 
  def __repr__(self):
7611 
    L = ['%s=%r' % (key, value)
7612 
      for key, value in self.__dict__.iteritems()]
7613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7614 
 
7615 
  def __eq__(self, other):
7616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7617 
 
7618 
  def __ne__(self, other):
7619 
    return not (self == other)
7620 
 
7621 
class getBestSellersCount_args:
7622 
 
7623 
  thrift_spec = (
7624 
  )
7625 
 
7626 
  def read(self, iprot):
7627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7629 
      return
7630 
    iprot.readStructBegin()
7631 
    while True:
7632 
      (fname, ftype, fid) = iprot.readFieldBegin()
7633 
      if ftype == TType.STOP:
7634 
        break
7635 
      else:
7636 
        iprot.skip(ftype)
7637 
      iprot.readFieldEnd()
7638 
    iprot.readStructEnd()
7639 
 
7640 
  def write(self, oprot):
7641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7643 
      return
7644 
    oprot.writeStructBegin('getBestSellersCount_args')
7645 
    oprot.writeFieldStop()
7646 
    oprot.writeStructEnd()
7647 
 
7648 
  def validate(self):
7649 
    return
7650 
 
7651 
 
7652 
  def __repr__(self):
7653 
    L = ['%s=%r' % (key, value)
7654 
      for key, value in self.__dict__.iteritems()]
7655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7656 
 
7657 
  def __eq__(self, other):
7658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7659 
 
7660 
  def __ne__(self, other):
7661 
    return not (self == other)
7662 
 
7663 
class getBestSellersCount_result:
7664 
  """
7665 
  Attributes:
7666 
   - success
7667 
   - cex
7668 
  """
7669 
 
7670 
  thrift_spec = (
7671 
    (0, TType.I64, 'success', None, None, ), # 0
7672 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7673 
  )
7674 
 
7675 
  def __init__(self, success=None, cex=None,):
7676 
    self.success = success
7677 
    self.cex = cex
7678 
 
7679 
  def read(self, iprot):
7680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7682 
      return
7683 
    iprot.readStructBegin()
7684 
    while True:
7685 
      (fname, ftype, fid) = iprot.readFieldBegin()
7686 
      if ftype == TType.STOP:
7687 
        break
7688 
      if fid == 0:
7689 
        if ftype == TType.I64:
7690 
          self.success = iprot.readI64();
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      elif fid == 1:
7694 
        if ftype == TType.STRUCT:
7695 
          self.cex = CatalogServiceException()
7696 
          self.cex.read(iprot)
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      else:
7700 
        iprot.skip(ftype)
7701 
      iprot.readFieldEnd()
7702 
    iprot.readStructEnd()
7703 
 
7704 
  def write(self, oprot):
7705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7707 
      return
7708 
    oprot.writeStructBegin('getBestSellersCount_result')
7709 
    if self.success is not None:
7710 
      oprot.writeFieldBegin('success', TType.I64, 0)
7711 
      oprot.writeI64(self.success)
7712 
      oprot.writeFieldEnd()
7713 
    if self.cex is not None:
7714 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7715 
      self.cex.write(oprot)
7716 
      oprot.writeFieldEnd()
7717 
    oprot.writeFieldStop()
7718 
    oprot.writeStructEnd()
7719 
 
7720 
  def validate(self):
7721 
    return
7722 
 
7723 
 
7724 
  def __repr__(self):
7725 
    L = ['%s=%r' % (key, value)
7726 
      for key, value in self.__dict__.iteritems()]
7727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7728 
 
7729 
  def __eq__(self, other):
7730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7731 
 
7732 
  def __ne__(self, other):
7733 
    return not (self == other)
7734 
 
7735 
class getBestDeals_args:
7736 
 
7737 
  thrift_spec = (
7738 
  )
7739 
 
7740 
  def read(self, iprot):
7741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7743 
      return
7744 
    iprot.readStructBegin()
7745 
    while True:
7746 
      (fname, ftype, fid) = iprot.readFieldBegin()
7747 
      if ftype == TType.STOP:
7748 
        break
7749 
      else:
7750 
        iprot.skip(ftype)
7751 
      iprot.readFieldEnd()
7752 
    iprot.readStructEnd()
7753 
 
7754 
  def write(self, oprot):
7755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7757 
      return
7758 
    oprot.writeStructBegin('getBestDeals_args')
7759 
    oprot.writeFieldStop()
7760 
    oprot.writeStructEnd()
7761 
 
7762 
  def validate(self):
7763 
    return
7764 
 
7765 
 
7766 
  def __repr__(self):
7767 
    L = ['%s=%r' % (key, value)
7768 
      for key, value in self.__dict__.iteritems()]
7769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7770 
 
7771 
  def __eq__(self, other):
7772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7773 
 
7774 
  def __ne__(self, other):
7775 
    return not (self == other)
7776 
 
7777 
class getBestDeals_result:
7778 
  """
7779 
  Attributes:
7780 
   - success
7781 
   - isex
7782 
  """
7783 
 
7784 
  thrift_spec = (
7785 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7786 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7787 
  )
7788 
 
7789 
  def __init__(self, success=None, isex=None,):
7790 
    self.success = success
7791 
    self.isex = isex
7792 
 
7793 
  def read(self, iprot):
7794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7796 
      return
7797 
    iprot.readStructBegin()
7798 
    while True:
7799 
      (fname, ftype, fid) = iprot.readFieldBegin()
7800 
      if ftype == TType.STOP:
7801 
        break
7802 
      if fid == 0:
7803 
        if ftype == TType.LIST:
7804 
          self.success = []
7805 
          (_etype75, _size72) = iprot.readListBegin()
7806 
          for _i76 in xrange(_size72):
7807 
            _elem77 = Item()
7808 
            _elem77.read(iprot)
7809 
            self.success.append(_elem77)
7810 
          iprot.readListEnd()
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      elif fid == 1:
7814 
        if ftype == TType.STRUCT:
7815 
          self.isex = CatalogServiceException()
7816 
          self.isex.read(iprot)
7817 
        else:
7818 
          iprot.skip(ftype)
7819 
      else:
7820 
        iprot.skip(ftype)
7821 
      iprot.readFieldEnd()
7822 
    iprot.readStructEnd()
7823 
 
7824 
  def write(self, oprot):
7825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7827 
      return
7828 
    oprot.writeStructBegin('getBestDeals_result')
7829 
    if self.success is not None:
7830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7832 
      for iter78 in self.success:
7833 
        iter78.write(oprot)
7834 
      oprot.writeListEnd()
7835 
      oprot.writeFieldEnd()
7836 
    if self.isex is not None:
7837 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7838 
      self.isex.write(oprot)
7839 
      oprot.writeFieldEnd()
7840 
    oprot.writeFieldStop()
7841 
    oprot.writeStructEnd()
7842 
 
7843 
  def validate(self):
7844 
    return
7845 
 
7846 
 
7847 
  def __repr__(self):
7848 
    L = ['%s=%r' % (key, value)
7849 
      for key, value in self.__dict__.iteritems()]
7850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7851 
 
7852 
  def __eq__(self, other):
7853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7854 
 
7855 
  def __ne__(self, other):
7856 
    return not (self == other)
7857 
 
7858 
class getBestDealsCatalogIds_args:
7859 
  """
7860 
  Attributes:
7861 
   - beginIndex
7862 
   - totalItems
7863 
   - brand
7864 
   - category
7865 
  """
7866 
 
7867 
  thrift_spec = (
7868 
    None, # 0
7869 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7870 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7871 
    (3, TType.STRING, 'brand', None, None, ), # 3
7872 
    (4, TType.I64, 'category', None, None, ), # 4
7873 
  )
7874 
 
7875 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7876 
    self.beginIndex = beginIndex
7877 
    self.totalItems = totalItems
7878 
    self.brand = brand
7879 
    self.category = category
7880 
 
7881 
  def read(self, iprot):
7882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7884 
      return
7885 
    iprot.readStructBegin()
7886 
    while True:
7887 
      (fname, ftype, fid) = iprot.readFieldBegin()
7888 
      if ftype == TType.STOP:
7889 
        break
7890 
      if fid == 1:
7891 
        if ftype == TType.I64:
7892 
          self.beginIndex = iprot.readI64();
7893 
        else:
7894 
          iprot.skip(ftype)
7895 
      elif fid == 2:
7896 
        if ftype == TType.I64:
7897 
          self.totalItems = iprot.readI64();
7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      elif fid == 3:
7901 
        if ftype == TType.STRING:
7902 
          self.brand = iprot.readString();
7903 
        else:
7904 
          iprot.skip(ftype)
7905 
      elif fid == 4:
7906 
        if ftype == TType.I64:
7907 
          self.category = iprot.readI64();
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      else:
7911 
        iprot.skip(ftype)
7912 
      iprot.readFieldEnd()
7913 
    iprot.readStructEnd()
7914 
 
7915 
  def write(self, oprot):
7916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7918 
      return
7919 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7920 
    if self.beginIndex is not None:
7921 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7922 
      oprot.writeI64(self.beginIndex)
7923 
      oprot.writeFieldEnd()
7924 
    if self.totalItems is not None:
7925 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7926 
      oprot.writeI64(self.totalItems)
7927 
      oprot.writeFieldEnd()
7928 
    if self.brand is not None:
7929 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7930 
      oprot.writeString(self.brand)
7931 
      oprot.writeFieldEnd()
7932 
    if self.category is not None:
7933 
      oprot.writeFieldBegin('category', TType.I64, 4)
7934 
      oprot.writeI64(self.category)
7935 
      oprot.writeFieldEnd()
7936 
    oprot.writeFieldStop()
7937 
    oprot.writeStructEnd()
7938 
 
7939 
  def validate(self):
7940 
    return
7941 
 
7942 
 
7943 
  def __repr__(self):
7944 
    L = ['%s=%r' % (key, value)
7945 
      for key, value in self.__dict__.iteritems()]
7946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7947 
 
7948 
  def __eq__(self, other):
7949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7950 
 
7951 
  def __ne__(self, other):
7952 
    return not (self == other)
7953 
 
7954 
class getBestDealsCatalogIds_result:
7955 
  """
7956 
  Attributes:
7957 
   - success
7958 
   - cex
7959 
  """
7960 
 
7961 
  thrift_spec = (
7962 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7963 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7964 
  )
7965 
 
7966 
  def __init__(self, success=None, cex=None,):
7967 
    self.success = success
7968 
    self.cex = cex
7969 
 
7970 
  def read(self, iprot):
7971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7973 
      return
7974 
    iprot.readStructBegin()
7975 
    while True:
7976 
      (fname, ftype, fid) = iprot.readFieldBegin()
7977 
      if ftype == TType.STOP:
7978 
        break
7979 
      if fid == 0:
7980 
        if ftype == TType.LIST:
7981 
          self.success = []
7982 
          (_etype82, _size79) = iprot.readListBegin()
7983 
          for _i83 in xrange(_size79):
7984 
            _elem84 = iprot.readI64();
7985 
            self.success.append(_elem84)
7986 
          iprot.readListEnd()
7987 
        else:
7988 
          iprot.skip(ftype)
7989 
      elif fid == 1:
7990 
        if ftype == TType.STRUCT:
7991 
          self.cex = CatalogServiceException()
7992 
          self.cex.read(iprot)
7993 
        else:
7994 
          iprot.skip(ftype)
7995 
      else:
7996 
        iprot.skip(ftype)
7997 
      iprot.readFieldEnd()
7998 
    iprot.readStructEnd()
7999 
 
8000 
  def write(self, oprot):
8001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8003 
      return
8004 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8005 
    if self.success is not None:
8006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8007 
      oprot.writeListBegin(TType.I64, len(self.success))
8008 
      for iter85 in self.success:
8009 
        oprot.writeI64(iter85)
8010 
      oprot.writeListEnd()
8011 
      oprot.writeFieldEnd()
8012 
    if self.cex is not None:
8013 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8014 
      self.cex.write(oprot)
8015 
      oprot.writeFieldEnd()
8016 
    oprot.writeFieldStop()
8017 
    oprot.writeStructEnd()
8018 
 
8019 
  def validate(self):
8020 
    return
8021 
 
8022 
 
8023 
  def __repr__(self):
8024 
    L = ['%s=%r' % (key, value)
8025 
      for key, value in self.__dict__.iteritems()]
8026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8027 
 
8028 
  def __eq__(self, other):
8029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8030 
 
8031 
  def __ne__(self, other):
8032 
    return not (self == other)
8033 
 
8034 
class getBestDealsCount_args:
8035 
 
8036 
  thrift_spec = (
8037 
  )
8038 
 
8039 
  def read(self, iprot):
8040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8042 
      return
8043 
    iprot.readStructBegin()
8044 
    while True:
8045 
      (fname, ftype, fid) = iprot.readFieldBegin()
8046 
      if ftype == TType.STOP:
8047 
        break
8048 
      else:
8049 
        iprot.skip(ftype)
8050 
      iprot.readFieldEnd()
8051 
    iprot.readStructEnd()
8052 
 
8053 
  def write(self, oprot):
8054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8056 
      return
8057 
    oprot.writeStructBegin('getBestDealsCount_args')
8058 
    oprot.writeFieldStop()
8059 
    oprot.writeStructEnd()
8060 
 
8061 
  def validate(self):
8062 
    return
8063 
 
8064 
 
8065 
  def __repr__(self):
8066 
    L = ['%s=%r' % (key, value)
8067 
      for key, value in self.__dict__.iteritems()]
8068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8069 
 
8070 
  def __eq__(self, other):
8071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8072 
 
8073 
  def __ne__(self, other):
8074 
    return not (self == other)
8075 
 
8076 
class getBestDealsCount_result:
8077 
  """
8078 
  Attributes:
8079 
   - success
8080 
   - cex
8081 
  """
8082 
 
8083 
  thrift_spec = (
8084 
    (0, TType.I64, 'success', None, None, ), # 0
8085 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8086 
  )
8087 
 
8088 
  def __init__(self, success=None, cex=None,):
8089 
    self.success = success
8090 
    self.cex = cex
8091 
 
8092 
  def read(self, iprot):
8093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8095 
      return
8096 
    iprot.readStructBegin()
8097 
    while True:
8098 
      (fname, ftype, fid) = iprot.readFieldBegin()
8099 
      if ftype == TType.STOP:
8100 
        break
8101 
      if fid == 0:
8102 
        if ftype == TType.I64:
8103 
          self.success = iprot.readI64();
8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      elif fid == 1:
8107 
        if ftype == TType.STRUCT:
8108 
          self.cex = CatalogServiceException()
8109 
          self.cex.read(iprot)
8110 
        else:
8111 
          iprot.skip(ftype)
8112 
      else:
8113 
        iprot.skip(ftype)
8114 
      iprot.readFieldEnd()
8115 
    iprot.readStructEnd()
8116 
 
8117 
  def write(self, oprot):
8118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8120 
      return
8121 
    oprot.writeStructBegin('getBestDealsCount_result')
8122 
    if self.success is not None:
8123 
      oprot.writeFieldBegin('success', TType.I64, 0)
8124 
      oprot.writeI64(self.success)
8125 
      oprot.writeFieldEnd()
8126 
    if self.cex is not None:
8127 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8128 
      self.cex.write(oprot)
8129 
      oprot.writeFieldEnd()
8130 
    oprot.writeFieldStop()
8131 
    oprot.writeStructEnd()
8132 
 
8133 
  def validate(self):
8134 
    return
8135 
 
8136 
 
8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
8148 
class getComingSoon_args:
8149 
 
8150 
  thrift_spec = (
8151 
  )
8152 
 
8153 
  def read(self, iprot):
8154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8156 
      return
8157 
    iprot.readStructBegin()
8158 
    while True:
8159 
      (fname, ftype, fid) = iprot.readFieldBegin()
8160 
      if ftype == TType.STOP:
8161 
        break
8162 
      else:
8163 
        iprot.skip(ftype)
8164 
      iprot.readFieldEnd()
8165 
    iprot.readStructEnd()
8166 
 
8167 
  def write(self, oprot):
8168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8170 
      return
8171 
    oprot.writeStructBegin('getComingSoon_args')
8172 
    oprot.writeFieldStop()
8173 
    oprot.writeStructEnd()
8174 
 
8175 
  def validate(self):
8176 
    return
8177 
 
8178 
 
8179 
  def __repr__(self):
8180 
    L = ['%s=%r' % (key, value)
8181 
      for key, value in self.__dict__.iteritems()]
8182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8183 
 
8184 
  def __eq__(self, other):
8185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8186 
 
8187 
  def __ne__(self, other):
8188 
    return not (self == other)
8189 
 
8190 
class getComingSoon_result:
8191 
  """
8192 
  Attributes:
8193 
   - success
8194 
   - isex
8195 
  """
8196 
 
8197 
  thrift_spec = (
8198 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8199 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8200 
  )
8201 
 
8202 
  def __init__(self, success=None, isex=None,):
8203 
    self.success = success
8204 
    self.isex = isex
8205 
 
8206 
  def read(self, iprot):
8207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8209 
      return
8210 
    iprot.readStructBegin()
8211 
    while True:
8212 
      (fname, ftype, fid) = iprot.readFieldBegin()
8213 
      if ftype == TType.STOP:
8214 
        break
8215 
      if fid == 0:
8216 
        if ftype == TType.LIST:
8217 
          self.success = []
8218 
          (_etype89, _size86) = iprot.readListBegin()
8219 
          for _i90 in xrange(_size86):
8220 
            _elem91 = Item()
8221 
            _elem91.read(iprot)
8222 
            self.success.append(_elem91)
8223 
          iprot.readListEnd()
8224 
        else:
8225 
          iprot.skip(ftype)
8226 
      elif fid == 1:
8227 
        if ftype == TType.STRUCT:
8228 
          self.isex = CatalogServiceException()
8229 
          self.isex.read(iprot)
8230 
        else:
8231 
          iprot.skip(ftype)
8232 
      else:
8233 
        iprot.skip(ftype)
8234 
      iprot.readFieldEnd()
8235 
    iprot.readStructEnd()
8236 
 
8237 
  def write(self, oprot):
8238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8240 
      return
8241 
    oprot.writeStructBegin('getComingSoon_result')
8242 
    if self.success is not None:
8243 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8244 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8245 
      for iter92 in self.success:
8246 
        iter92.write(oprot)
8247 
      oprot.writeListEnd()
8248 
      oprot.writeFieldEnd()
8249 
    if self.isex is not None:
8250 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8251 
      self.isex.write(oprot)
8252 
      oprot.writeFieldEnd()
8253 
    oprot.writeFieldStop()
8254 
    oprot.writeStructEnd()
8255 
 
8256 
  def validate(self):
8257 
    return
8258 
 
8259 
 
8260 
  def __repr__(self):
8261 
    L = ['%s=%r' % (key, value)
8262 
      for key, value in self.__dict__.iteritems()]
8263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8264 
 
8265 
  def __eq__(self, other):
8266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8267 
 
8268 
  def __ne__(self, other):
8269 
    return not (self == other)
8270 
 
8271 
class getComingSoonCatalogIds_args:
8272 
  """
8273 
  Attributes:
8274 
   - beginIndex
8275 
   - totalItems
8276 
   - brand
8277 
   - category
8278 
  """
8279 
 
8280 
  thrift_spec = (
8281 
    None, # 0
8282 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8283 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8284 
    (3, TType.STRING, 'brand', None, None, ), # 3
8285 
    (4, TType.I64, 'category', None, None, ), # 4
8286 
  )
8287 
 
8288 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8289 
    self.beginIndex = beginIndex
8290 
    self.totalItems = totalItems
8291 
    self.brand = brand
8292 
    self.category = category
8293 
 
8294 
  def read(self, iprot):
8295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8297 
      return
8298 
    iprot.readStructBegin()
8299 
    while True:
8300 
      (fname, ftype, fid) = iprot.readFieldBegin()
8301 
      if ftype == TType.STOP:
8302 
        break
8303 
      if fid == 1:
8304 
        if ftype == TType.I64:
8305 
          self.beginIndex = iprot.readI64();
8306 
        else:
8307 
          iprot.skip(ftype)
8308 
      elif fid == 2:
8309 
        if ftype == TType.I64:
8310 
          self.totalItems = iprot.readI64();
8311 
        else:
8312 
          iprot.skip(ftype)
8313 
      elif fid == 3:
8314 
        if ftype == TType.STRING:
8315 
          self.brand = iprot.readString();
8316 
        else:
8317 
          iprot.skip(ftype)
8318 
      elif fid == 4:
8319 
        if ftype == TType.I64:
8320 
          self.category = iprot.readI64();
8321 
        else:
8322 
          iprot.skip(ftype)
8323 
      else:
8324 
        iprot.skip(ftype)
8325 
      iprot.readFieldEnd()
8326 
    iprot.readStructEnd()
8327 
 
8328 
  def write(self, oprot):
8329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8331 
      return
8332 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8333 
    if self.beginIndex is not None:
8334 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8335 
      oprot.writeI64(self.beginIndex)
8336 
      oprot.writeFieldEnd()
8337 
    if self.totalItems is not None:
8338 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8339 
      oprot.writeI64(self.totalItems)
8340 
      oprot.writeFieldEnd()
8341 
    if self.brand is not None:
8342 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8343 
      oprot.writeString(self.brand)
8344 
      oprot.writeFieldEnd()
8345 
    if self.category is not None:
8346 
      oprot.writeFieldBegin('category', TType.I64, 4)
8347 
      oprot.writeI64(self.category)
8348 
      oprot.writeFieldEnd()
8349 
    oprot.writeFieldStop()
8350 
    oprot.writeStructEnd()
8351 
 
8352 
  def validate(self):
8353 
    return
8354 
 
8355 
 
8356 
  def __repr__(self):
8357 
    L = ['%s=%r' % (key, value)
8358 
      for key, value in self.__dict__.iteritems()]
8359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8360 
 
8361 
  def __eq__(self, other):
8362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8363 
 
8364 
  def __ne__(self, other):
8365 
    return not (self == other)
8366 
 
8367 
class getComingSoonCatalogIds_result:
8368 
  """
8369 
  Attributes:
8370 
   - success
8371 
   - cex
8372 
  """
8373 
 
8374 
  thrift_spec = (
8375 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8376 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8377 
  )
8378 
 
8379 
  def __init__(self, success=None, cex=None,):
8380 
    self.success = success
8381 
    self.cex = cex
8382 
 
8383 
  def read(self, iprot):
8384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8386 
      return
8387 
    iprot.readStructBegin()
8388 
    while True:
8389 
      (fname, ftype, fid) = iprot.readFieldBegin()
8390 
      if ftype == TType.STOP:
8391 
        break
8392 
      if fid == 0:
8393 
        if ftype == TType.LIST:
8394 
          self.success = []
8395 
          (_etype96, _size93) = iprot.readListBegin()
8396 
          for _i97 in xrange(_size93):
8397 
            _elem98 = iprot.readI64();
8398 
            self.success.append(_elem98)
8399 
          iprot.readListEnd()
8400 
        else:
8401 
          iprot.skip(ftype)
8402 
      elif fid == 1:
8403 
        if ftype == TType.STRUCT:
8404 
          self.cex = CatalogServiceException()
8405 
          self.cex.read(iprot)
8406 
        else:
8407 
          iprot.skip(ftype)
8408 
      else:
8409 
        iprot.skip(ftype)
8410 
      iprot.readFieldEnd()
8411 
    iprot.readStructEnd()
8412 
 
8413 
  def write(self, oprot):
8414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8416 
      return
8417 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8418 
    if self.success is not None:
8419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8420 
      oprot.writeListBegin(TType.I64, len(self.success))
8421 
      for iter99 in self.success:
8422 
        oprot.writeI64(iter99)
8423 
      oprot.writeListEnd()
8424 
      oprot.writeFieldEnd()
8425 
    if self.cex is not None:
8426 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8427 
      self.cex.write(oprot)
8428 
      oprot.writeFieldEnd()
8429 
    oprot.writeFieldStop()
8430 
    oprot.writeStructEnd()
8431 
 
8432 
  def validate(self):
8433 
    return
8434 
 
8435 
 
8436 
  def __repr__(self):
8437 
    L = ['%s=%r' % (key, value)
8438 
      for key, value in self.__dict__.iteritems()]
8439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8440 
 
8441 
  def __eq__(self, other):
8442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8443 
 
8444 
  def __ne__(self, other):
8445 
    return not (self == other)
8446 
 
8447 
class getComingSoonCount_args:
8448 
 
8449 
  thrift_spec = (
8450 
  )
8451 
 
8452 
  def read(self, iprot):
8453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8455 
      return
8456 
    iprot.readStructBegin()
8457 
    while True:
8458 
      (fname, ftype, fid) = iprot.readFieldBegin()
8459 
      if ftype == TType.STOP:
8460 
        break
8461 
      else:
8462 
        iprot.skip(ftype)
8463 
      iprot.readFieldEnd()
8464 
    iprot.readStructEnd()
8465 
 
8466 
  def write(self, oprot):
8467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8469 
      return
8470 
    oprot.writeStructBegin('getComingSoonCount_args')
8471 
    oprot.writeFieldStop()
8472 
    oprot.writeStructEnd()
8473 
 
8474 
  def validate(self):
8475 
    return
8476 
 
8477 
 
8478 
  def __repr__(self):
8479 
    L = ['%s=%r' % (key, value)
8480 
      for key, value in self.__dict__.iteritems()]
8481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8482 
 
8483 
  def __eq__(self, other):
8484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8485 
 
8486 
  def __ne__(self, other):
8487 
    return not (self == other)
8488 
 
8489 
class getComingSoonCount_result:
8490 
  """
8491 
  Attributes:
8492 
   - success
8493 
   - cex
8494 
  """
8495 
 
8496 
  thrift_spec = (
8497 
    (0, TType.I64, 'success', None, None, ), # 0
8498 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8499 
  )
8500 
 
8501 
  def __init__(self, success=None, cex=None,):
8502 
    self.success = success
8503 
    self.cex = cex
8504 
 
8505 
  def read(self, iprot):
8506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8508 
      return
8509 
    iprot.readStructBegin()
8510 
    while True:
8511 
      (fname, ftype, fid) = iprot.readFieldBegin()
8512 
      if ftype == TType.STOP:
8513 
        break
8514 
      if fid == 0:
8515 
        if ftype == TType.I64:
8516 
          self.success = iprot.readI64();
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      elif fid == 1:
8520 
        if ftype == TType.STRUCT:
8521 
          self.cex = CatalogServiceException()
8522 
          self.cex.read(iprot)
8523 
        else:
8524 
          iprot.skip(ftype)
8525 
      else:
8526 
        iprot.skip(ftype)
8527 
      iprot.readFieldEnd()
8528 
    iprot.readStructEnd()
8529 
 
8530 
  def write(self, oprot):
8531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8533 
      return
8534 
    oprot.writeStructBegin('getComingSoonCount_result')
8535 
    if self.success is not None:
8536 
      oprot.writeFieldBegin('success', TType.I64, 0)
8537 
      oprot.writeI64(self.success)
8538 
      oprot.writeFieldEnd()
8539 
    if self.cex is not None:
8540 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8541 
      self.cex.write(oprot)
8542 
      oprot.writeFieldEnd()
8543 
    oprot.writeFieldStop()
8544 
    oprot.writeStructEnd()
8545 
 
8546 
  def validate(self):
8547 
    return
8548 
 
8549 
 
8550 
  def __repr__(self):
8551 
    L = ['%s=%r' % (key, value)
8552 
      for key, value in self.__dict__.iteritems()]
8553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8554 
 
8555 
  def __eq__(self, other):
8556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8557 
 
8558 
  def __ne__(self, other):
8559 
    return not (self == other)
8560 
 
8561 
class getLatestArrivals_args:
8562 
 
8563 
  thrift_spec = (
8564 
  )
8565 
 
8566 
  def read(self, iprot):
8567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8569 
      return
8570 
    iprot.readStructBegin()
8571 
    while True:
8572 
      (fname, ftype, fid) = iprot.readFieldBegin()
8573 
      if ftype == TType.STOP:
8574 
        break
8575 
      else:
8576 
        iprot.skip(ftype)
8577 
      iprot.readFieldEnd()
8578 
    iprot.readStructEnd()
8579 
 
8580 
  def write(self, oprot):
8581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8583 
      return
8584 
    oprot.writeStructBegin('getLatestArrivals_args')
8585 
    oprot.writeFieldStop()
8586 
    oprot.writeStructEnd()
8587 
 
8588 
  def validate(self):
8589 
    return
8590 
 
8591 
 
8592 
  def __repr__(self):
8593 
    L = ['%s=%r' % (key, value)
8594 
      for key, value in self.__dict__.iteritems()]
8595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8596 
 
8597 
  def __eq__(self, other):
8598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8599 
 
8600 
  def __ne__(self, other):
8601 
    return not (self == other)
8602 
 
8603 
class getLatestArrivals_result:
8604 
  """
8605 
  Attributes:
8606 
   - success
8607 
   - isex
8608 
  """
8609 
 
8610 
  thrift_spec = (
8611 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8612 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8613 
  )
8614 
 
8615 
  def __init__(self, success=None, isex=None,):
8616 
    self.success = success
8617 
    self.isex = isex
8618 
 
8619 
  def read(self, iprot):
8620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8622 
      return
8623 
    iprot.readStructBegin()
8624 
    while True:
8625 
      (fname, ftype, fid) = iprot.readFieldBegin()
8626 
      if ftype == TType.STOP:
8627 
        break
8628 
      if fid == 0:
8629 
        if ftype == TType.LIST:
8630 
          self.success = []
8631 
          (_etype103, _size100) = iprot.readListBegin()
8632 
          for _i104 in xrange(_size100):
8633 
            _elem105 = Item()
8634 
            _elem105.read(iprot)
8635 
            self.success.append(_elem105)
8636 
          iprot.readListEnd()
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      elif fid == 1:
8640 
        if ftype == TType.STRUCT:
8641 
          self.isex = CatalogServiceException()
8642 
          self.isex.read(iprot)
8643 
        else:
8644 
          iprot.skip(ftype)
8645 
      else:
8646 
        iprot.skip(ftype)
8647 
      iprot.readFieldEnd()
8648 
    iprot.readStructEnd()
8649 
 
8650 
  def write(self, oprot):
8651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8653 
      return
8654 
    oprot.writeStructBegin('getLatestArrivals_result')
8655 
    if self.success is not None:
8656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8658 
      for iter106 in self.success:
8659 
        iter106.write(oprot)
8660 
      oprot.writeListEnd()
8661 
      oprot.writeFieldEnd()
8662 
    if self.isex is not None:
8663 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8664 
      self.isex.write(oprot)
8665 
      oprot.writeFieldEnd()
8666 
    oprot.writeFieldStop()
8667 
    oprot.writeStructEnd()
8668 
 
8669 
  def validate(self):
8670 
    return
8671 
 
8672 
 
8673 
  def __repr__(self):
8674 
    L = ['%s=%r' % (key, value)
8675 
      for key, value in self.__dict__.iteritems()]
8676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8677 
 
8678 
  def __eq__(self, other):
8679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8680 
 
8681 
  def __ne__(self, other):
8682 
    return not (self == other)
8683 
 
8684 
class getLatestArrivalsCatalogIds_args:
8685 
  """
8686 
  Attributes:
8687 
   - beginIndex
8688 
   - totalItems
8689 
   - brand
8690 
   - categories
8691 
  """
8692 
 
8693 
  thrift_spec = (
8694 
    None, # 0
8695 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8696 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8697 
    (3, TType.STRING, 'brand', None, None, ), # 3
8698 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8699 
  )
8700 
 
8701 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8702 
    self.beginIndex = beginIndex
8703 
    self.totalItems = totalItems
8704 
    self.brand = brand
8705 
    self.categories = categories
8706 
 
8707 
  def read(self, iprot):
8708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8710 
      return
8711 
    iprot.readStructBegin()
8712 
    while True:
8713 
      (fname, ftype, fid) = iprot.readFieldBegin()
8714 
      if ftype == TType.STOP:
8715 
        break
8716 
      if fid == 1:
8717 
        if ftype == TType.I64:
8718 
          self.beginIndex = iprot.readI64();
8719 
        else:
8720 
          iprot.skip(ftype)
8721 
      elif fid == 2:
8722 
        if ftype == TType.I64:
8723 
          self.totalItems = iprot.readI64();
8724 
        else:
8725 
          iprot.skip(ftype)
8726 
      elif fid == 3:
8727 
        if ftype == TType.STRING:
8728 
          self.brand = iprot.readString();
8729 
        else:
8730 
          iprot.skip(ftype)
8731 
      elif fid == 4:
8732 
        if ftype == TType.LIST:
8733 
          self.categories = []
8734 
          (_etype110, _size107) = iprot.readListBegin()
8735 
          for _i111 in xrange(_size107):
8736 
            _elem112 = iprot.readI64();
8737 
            self.categories.append(_elem112)
8738 
          iprot.readListEnd()
8739 
        else:
8740 
          iprot.skip(ftype)
8741 
      else:
8742 
        iprot.skip(ftype)
8743 
      iprot.readFieldEnd()
8744 
    iprot.readStructEnd()
8745 
 
8746 
  def write(self, oprot):
8747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8749 
      return
8750 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8751 
    if self.beginIndex is not None:
8752 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8753 
      oprot.writeI64(self.beginIndex)
8754 
      oprot.writeFieldEnd()
8755 
    if self.totalItems is not None:
8756 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8757 
      oprot.writeI64(self.totalItems)
8758 
      oprot.writeFieldEnd()
8759 
    if self.brand is not None:
8760 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8761 
      oprot.writeString(self.brand)
8762 
      oprot.writeFieldEnd()
8763 
    if self.categories is not None:
8764 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8765 
      oprot.writeListBegin(TType.I64, len(self.categories))
8766 
      for iter113 in self.categories:
8767 
        oprot.writeI64(iter113)
8768 
      oprot.writeListEnd()
8769 
      oprot.writeFieldEnd()
8770 
    oprot.writeFieldStop()
8771 
    oprot.writeStructEnd()
8772 
 
8773 
  def validate(self):
8774 
    return
8775 
 
8776 
 
8777 
  def __repr__(self):
8778 
    L = ['%s=%r' % (key, value)
8779 
      for key, value in self.__dict__.iteritems()]
8780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8781 
 
8782 
  def __eq__(self, other):
8783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8784 
 
8785 
  def __ne__(self, other):
8786 
    return not (self == other)
8787 
 
8788 
class getLatestArrivalsCatalogIds_result:
8789 
  """
8790 
  Attributes:
8791 
   - success
8792 
   - cex
8793 
  """
8794 
 
8795 
  thrift_spec = (
8796 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8797 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8798 
  )
8799 
 
8800 
  def __init__(self, success=None, cex=None,):
8801 
    self.success = success
8802 
    self.cex = cex
8803 
 
8804 
  def read(self, iprot):
8805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8807 
      return
8808 
    iprot.readStructBegin()
8809 
    while True:
8810 
      (fname, ftype, fid) = iprot.readFieldBegin()
8811 
      if ftype == TType.STOP:
8812 
        break
8813 
      if fid == 0:
8814 
        if ftype == TType.LIST:
8815 
          self.success = []
8816 
          (_etype117, _size114) = iprot.readListBegin()
8817 
          for _i118 in xrange(_size114):
8818 
            _elem119 = iprot.readI64();
8819 
            self.success.append(_elem119)
8820 
          iprot.readListEnd()
8821 
        else:
8822 
          iprot.skip(ftype)
8823 
      elif fid == 1:
8824 
        if ftype == TType.STRUCT:
8825 
          self.cex = CatalogServiceException()
8826 
          self.cex.read(iprot)
8827 
        else:
8828 
          iprot.skip(ftype)
8829 
      else:
8830 
        iprot.skip(ftype)
8831 
      iprot.readFieldEnd()
8832 
    iprot.readStructEnd()
8833 
 
8834 
  def write(self, oprot):
8835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8837 
      return
8838 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8839 
    if self.success is not None:
8840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8841 
      oprot.writeListBegin(TType.I64, len(self.success))
8842 
      for iter120 in self.success:
8843 
        oprot.writeI64(iter120)
8844 
      oprot.writeListEnd()
8845 
      oprot.writeFieldEnd()
8846 
    if self.cex is not None:
8847 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8848 
      self.cex.write(oprot)
8849 
      oprot.writeFieldEnd()
8850 
    oprot.writeFieldStop()
8851 
    oprot.writeStructEnd()
8852 
 
8853 
  def validate(self):
8854 
    return
8855 
 
8856 
 
8857 
  def __repr__(self):
8858 
    L = ['%s=%r' % (key, value)
8859 
      for key, value in self.__dict__.iteritems()]
8860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8861 
 
8862 
  def __eq__(self, other):
8863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8864 
 
8865 
  def __ne__(self, other):
8866 
    return not (self == other)
8867 
 
8868 
class getLatestArrivalsCount_args:
8869 
 
8870 
  thrift_spec = (
8871 
  )
8872 
 
8873 
  def read(self, iprot):
8874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8876 
      return
8877 
    iprot.readStructBegin()
8878 
    while True:
8879 
      (fname, ftype, fid) = iprot.readFieldBegin()
8880 
      if ftype == TType.STOP:
8881 
        break
8882 
      else:
8883 
        iprot.skip(ftype)
8884 
      iprot.readFieldEnd()
8885 
    iprot.readStructEnd()
8886 
 
8887 
  def write(self, oprot):
8888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8890 
      return
8891 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8892 
    oprot.writeFieldStop()
8893 
    oprot.writeStructEnd()
8894 
 
8895 
  def validate(self):
8896 
    return
8897 
 
8898 
 
8899 
  def __repr__(self):
8900 
    L = ['%s=%r' % (key, value)
8901 
      for key, value in self.__dict__.iteritems()]
8902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8903 
 
8904 
  def __eq__(self, other):
8905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8906 
 
8907 
  def __ne__(self, other):
8908 
    return not (self == other)
8909 
 
8910 
class getLatestArrivalsCount_result:
8911 
  """
8912 
  Attributes:
8913 
   - success
8914 
   - cex
8915 
  """
8916 
 
8917 
  thrift_spec = (
8918 
    (0, TType.I64, 'success', None, None, ), # 0
8919 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8920 
  )
8921 
 
8922 
  def __init__(self, success=None, cex=None,):
8923 
    self.success = success
8924 
    self.cex = cex
8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      if fid == 0:
8936 
        if ftype == TType.I64:
8937 
          self.success = iprot.readI64();
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      elif fid == 1:
8941 
        if ftype == TType.STRUCT:
8942 
          self.cex = CatalogServiceException()
8943 
          self.cex.read(iprot)
8944 
        else:
8945 
          iprot.skip(ftype)
8946 
      else:
8947 
        iprot.skip(ftype)
8948 
      iprot.readFieldEnd()
8949 
    iprot.readStructEnd()
8950 
 
8951 
  def write(self, oprot):
8952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8954 
      return
8955 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8956 
    if self.success is not None:
8957 
      oprot.writeFieldBegin('success', TType.I64, 0)
8958 
      oprot.writeI64(self.success)
8959 
      oprot.writeFieldEnd()
8960 
    if self.cex is not None:
8961 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8962 
      self.cex.write(oprot)
8963 
      oprot.writeFieldEnd()
8964 
    oprot.writeFieldStop()
8965 
    oprot.writeStructEnd()
8966 
 
8967 
  def validate(self):
8968 
    return
8969 
 
8970 
 
8971 
  def __repr__(self):
8972 
    L = ['%s=%r' % (key, value)
8973 
      for key, value in self.__dict__.iteritems()]
8974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8975 
 
8976 
  def __eq__(self, other):
8977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8978 
 
8979 
  def __ne__(self, other):
8980 
    return not (self == other)
8981 
 
8982 
class generateNewEntityID_args:
8983 
 
8984 
  thrift_spec = (
8985 
  )
8986 
 
8987 
  def read(self, iprot):
8988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8990 
      return
8991 
    iprot.readStructBegin()
8992 
    while True:
8993 
      (fname, ftype, fid) = iprot.readFieldBegin()
8994 
      if ftype == TType.STOP:
8995 
        break
8996 
      else:
8997 
        iprot.skip(ftype)
8998 
      iprot.readFieldEnd()
8999 
    iprot.readStructEnd()
9000 
 
9001 
  def write(self, oprot):
9002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9004 
      return
9005 
    oprot.writeStructBegin('generateNewEntityID_args')
9006 
    oprot.writeFieldStop()
9007 
    oprot.writeStructEnd()
9008 
 
9009 
  def validate(self):
9010 
    return
9011 
 
9012 
 
9013 
  def __repr__(self):
9014 
    L = ['%s=%r' % (key, value)
9015 
      for key, value in self.__dict__.iteritems()]
9016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9017 
 
9018 
  def __eq__(self, other):
9019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9020 
 
9021 
  def __ne__(self, other):
9022 
    return not (self == other)
9023 
 
9024 
class generateNewEntityID_result:
9025 
  """
9026 
  Attributes:
9027 
   - success
9028 
  """
9029 
 
9030 
  thrift_spec = (
9031 
    (0, TType.I64, 'success', None, None, ), # 0
9032 
  )
9033 
 
9034 
  def __init__(self, success=None,):
9035 
    self.success = success
9036 
 
9037 
  def read(self, iprot):
9038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9040 
      return
9041 
    iprot.readStructBegin()
9042 
    while True:
9043 
      (fname, ftype, fid) = iprot.readFieldBegin()
9044 
      if ftype == TType.STOP:
9045 
        break
9046 
      if fid == 0:
9047 
        if ftype == TType.I64:
9048 
          self.success = iprot.readI64();
9049 
        else:
9050 
          iprot.skip(ftype)
9051 
      else:
9052 
        iprot.skip(ftype)
9053 
      iprot.readFieldEnd()
9054 
    iprot.readStructEnd()
9055 
 
9056 
  def write(self, oprot):
9057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9059 
      return
9060 
    oprot.writeStructBegin('generateNewEntityID_result')
9061 
    if self.success is not None:
9062 
      oprot.writeFieldBegin('success', TType.I64, 0)
9063 
      oprot.writeI64(self.success)
9064 
      oprot.writeFieldEnd()
9065 
    oprot.writeFieldStop()
9066 
    oprot.writeStructEnd()
9067 
 
9068 
  def validate(self):
9069 
    return
9070 
 
9071 
 
9072 
  def __repr__(self):
9073 
    L = ['%s=%r' % (key, value)
9074 
      for key, value in self.__dict__.iteritems()]
9075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9076 
 
9077 
  def __eq__(self, other):
9078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9079 
 
9080 
  def __ne__(self, other):
9081 
    return not (self == other)
9082 
 
9083 
class addCategory_args:
9084 
  """
9085 
  Attributes:
9086 
   - category
9087 
  """
9088 
 
9089 
  thrift_spec = (
9090 
    None, # 0
9091 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9092 
  )
9093 
 
9094 
  def __init__(self, category=None,):
9095 
    self.category = category
9096 
 
9097 
  def read(self, iprot):
9098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9100 
      return
9101 
    iprot.readStructBegin()
9102 
    while True:
9103 
      (fname, ftype, fid) = iprot.readFieldBegin()
9104 
      if ftype == TType.STOP:
9105 
        break
9106 
      if fid == 1:
9107 
        if ftype == TType.STRUCT:
9108 
          self.category = Category()
9109 
          self.category.read(iprot)
9110 
        else:
9111 
          iprot.skip(ftype)
9112 
      else:
9113 
        iprot.skip(ftype)
9114 
      iprot.readFieldEnd()
9115 
    iprot.readStructEnd()
9116 
 
9117 
  def write(self, oprot):
9118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9120 
      return
9121 
    oprot.writeStructBegin('addCategory_args')
9122 
    if self.category is not None:
9123 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9124 
      self.category.write(oprot)
9125 
      oprot.writeFieldEnd()
9126 
    oprot.writeFieldStop()
9127 
    oprot.writeStructEnd()
9128 
 
9129 
  def validate(self):
9130 
    return
9131 
 
9132 
 
9133 
  def __repr__(self):
9134 
    L = ['%s=%r' % (key, value)
9135 
      for key, value in self.__dict__.iteritems()]
9136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9137 
 
9138 
  def __eq__(self, other):
9139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9140 
 
9141 
  def __ne__(self, other):
9142 
    return not (self == other)
9143 
 
9144 
class addCategory_result:
9145 
  """
9146 
  Attributes:
9147 
   - success
9148 
  """
9149 
 
9150 
  thrift_spec = (
9151 
    (0, TType.BOOL, 'success', None, None, ), # 0
9152 
  )
9153 
 
9154 
  def __init__(self, success=None,):
9155 
    self.success = success
9156 
 
9157 
  def read(self, iprot):
9158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9160 
      return
9161 
    iprot.readStructBegin()
9162 
    while True:
9163 
      (fname, ftype, fid) = iprot.readFieldBegin()
9164 
      if ftype == TType.STOP:
9165 
        break
9166 
      if fid == 0:
9167 
        if ftype == TType.BOOL:
9168 
          self.success = iprot.readBool();
9169 
        else:
9170 
          iprot.skip(ftype)
9171 
      else:
9172 
        iprot.skip(ftype)
9173 
      iprot.readFieldEnd()
9174 
    iprot.readStructEnd()
9175 
 
9176 
  def write(self, oprot):
9177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9179 
      return
9180 
    oprot.writeStructBegin('addCategory_result')
9181 
    if self.success is not None:
9182 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9183 
      oprot.writeBool(self.success)
9184 
      oprot.writeFieldEnd()
9185 
    oprot.writeFieldStop()
9186 
    oprot.writeStructEnd()
9187 
 
9188 
  def validate(self):
9189 
    return
9190 
 
9191 
 
9192 
  def __repr__(self):
9193 
    L = ['%s=%r' % (key, value)
9194 
      for key, value in self.__dict__.iteritems()]
9195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9196 
 
9197 
  def __eq__(self, other):
9198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9199 
 
9200 
  def __ne__(self, other):
9201 
    return not (self == other)
9202 
 
9203 
class getCategory_args:
9204 
  """
9205 
  Attributes:
9206 
   - id
9207 
  """
9208 
 
9209 
  thrift_spec = (
9210 
    None, # 0
9211 
    (1, TType.I64, 'id', None, None, ), # 1
9212 
  )
9213 
 
9214 
  def __init__(self, id=None,):
9215 
    self.id = id
9216 
 
9217 
  def read(self, iprot):
9218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9220 
      return
9221 
    iprot.readStructBegin()
9222 
    while True:
9223 
      (fname, ftype, fid) = iprot.readFieldBegin()
9224 
      if ftype == TType.STOP:
9225 
        break
9226 
      if fid == 1:
9227 
        if ftype == TType.I64:
9228 
          self.id = iprot.readI64();
9229 
        else:
9230 
          iprot.skip(ftype)
9231 
      else:
9232 
        iprot.skip(ftype)
9233 
      iprot.readFieldEnd()
9234 
    iprot.readStructEnd()
9235 
 
9236 
  def write(self, oprot):
9237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9239 
      return
9240 
    oprot.writeStructBegin('getCategory_args')
9241 
    if self.id is not None:
9242 
      oprot.writeFieldBegin('id', TType.I64, 1)
9243 
      oprot.writeI64(self.id)
9244 
      oprot.writeFieldEnd()
9245 
    oprot.writeFieldStop()
9246 
    oprot.writeStructEnd()
9247 
 
9248 
  def validate(self):
9249 
    return
9250 
 
9251 
 
9252 
  def __repr__(self):
9253 
    L = ['%s=%r' % (key, value)
9254 
      for key, value in self.__dict__.iteritems()]
9255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9256 
 
9257 
  def __eq__(self, other):
9258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9259 
 
9260 
  def __ne__(self, other):
9261 
    return not (self == other)
9262 
 
9263 
class getCategory_result:
9264 
  """
9265 
  Attributes:
9266 
   - success
9267 
  """
9268 
 
9269 
  thrift_spec = (
9270 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9271 
  )
9272 
 
9273 
  def __init__(self, success=None,):
9274 
    self.success = success
9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 0:
9286 
        if ftype == TType.STRUCT:
9287 
          self.success = Category()
9288 
          self.success.read(iprot)
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      else:
9292 
        iprot.skip(ftype)
9293 
      iprot.readFieldEnd()
9294 
    iprot.readStructEnd()
9295 
 
9296 
  def write(self, oprot):
9297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9299 
      return
9300 
    oprot.writeStructBegin('getCategory_result')
9301 
    if self.success is not None:
9302 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9303 
      self.success.write(oprot)
9304 
      oprot.writeFieldEnd()
9305 
    oprot.writeFieldStop()
9306 
    oprot.writeStructEnd()
9307 
 
9308 
  def validate(self):
9309 
    return
9310 
 
9311 
 
9312 
  def __repr__(self):
9313 
    L = ['%s=%r' % (key, value)
9314 
      for key, value in self.__dict__.iteritems()]
9315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9316 
 
9317 
  def __eq__(self, other):
9318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9319 
 
9320 
  def __ne__(self, other):
9321 
    return not (self == other)
9322 
 
9323 
class getAllCategories_args:
9324 
 
9325 
  thrift_spec = (
9326 
  )
9327 
 
9328 
  def read(self, iprot):
9329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9331 
      return
9332 
    iprot.readStructBegin()
9333 
    while True:
9334 
      (fname, ftype, fid) = iprot.readFieldBegin()
9335 
      if ftype == TType.STOP:
9336 
        break
9337 
      else:
9338 
        iprot.skip(ftype)
9339 
      iprot.readFieldEnd()
9340 
    iprot.readStructEnd()
9341 
 
9342 
  def write(self, oprot):
9343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9345 
      return
9346 
    oprot.writeStructBegin('getAllCategories_args')
9347 
    oprot.writeFieldStop()
9348 
    oprot.writeStructEnd()
9349 
 
9350 
  def validate(self):
9351 
    return
9352 
 
9353 
 
9354 
  def __repr__(self):
9355 
    L = ['%s=%r' % (key, value)
9356 
      for key, value in self.__dict__.iteritems()]
9357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9358 
 
9359 
  def __eq__(self, other):
9360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9361 
 
9362 
  def __ne__(self, other):
9363 
    return not (self == other)
9364 
 
9365 
class getAllCategories_result:
9366 
  """
9367 
  Attributes:
9368 
   - success
9369 
  """
9370 
 
9371 
  thrift_spec = (
9372 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9373 
  )
9374 
 
9375 
  def __init__(self, success=None,):
9376 
    self.success = success
9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 0:
9388 
        if ftype == TType.LIST:
9389 
          self.success = []
9390 
          (_etype124, _size121) = iprot.readListBegin()
9391 
          for _i125 in xrange(_size121):
9392 
            _elem126 = Category()
9393 
            _elem126.read(iprot)
9394 
            self.success.append(_elem126)
9395 
          iprot.readListEnd()
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      else:
9399 
        iprot.skip(ftype)
9400 
      iprot.readFieldEnd()
9401 
    iprot.readStructEnd()
9402 
 
9403 
  def write(self, oprot):
9404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9406 
      return
9407 
    oprot.writeStructBegin('getAllCategories_result')
9408 
    if self.success is not None:
9409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9411 
      for iter127 in self.success:
9412 
        iter127.write(oprot)
9413 
      oprot.writeListEnd()
9414 
      oprot.writeFieldEnd()
9415 
    oprot.writeFieldStop()
9416 
    oprot.writeStructEnd()
9417 
 
9418 
  def validate(self):
9419 
    return
9420 
 
9421 
 
9422 
  def __repr__(self):
9423 
    L = ['%s=%r' % (key, value)
9424 
      for key, value in self.__dict__.iteritems()]
9425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9426 
 
9427 
  def __eq__(self, other):
9428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9429 
 
9430 
  def __ne__(self, other):
9431 
    return not (self == other)
9432 
 
9433 
class getAllSimilarItems_args:
9434 
  """
9435 
  Attributes:
9436 
   - itemId
9437 
  """
9438 
 
9439 
  thrift_spec = (
9440 
    None, # 0
9441 
    (1, TType.I64, 'itemId', None, None, ), # 1
9442 
  )
9443 
 
9444 
  def __init__(self, itemId=None,):
9445 
    self.itemId = itemId
9446 
 
9447 
  def read(self, iprot):
9448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9450 
      return
9451 
    iprot.readStructBegin()
9452 
    while True:
9453 
      (fname, ftype, fid) = iprot.readFieldBegin()
9454 
      if ftype == TType.STOP:
9455 
        break
9456 
      if fid == 1:
9457 
        if ftype == TType.I64:
9458 
          self.itemId = iprot.readI64();
9459 
        else:
9460 
          iprot.skip(ftype)
9461 
      else:
9462 
        iprot.skip(ftype)
9463 
      iprot.readFieldEnd()
9464 
    iprot.readStructEnd()
9465 
 
9466 
  def write(self, oprot):
9467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9469 
      return
9470 
    oprot.writeStructBegin('getAllSimilarItems_args')
9471 
    if self.itemId is not None:
9472 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9473 
      oprot.writeI64(self.itemId)
9474 
      oprot.writeFieldEnd()
9475 
    oprot.writeFieldStop()
9476 
    oprot.writeStructEnd()
9477 
 
9478 
  def validate(self):
9479 
    return
9480 
 
9481 
 
9482 
  def __repr__(self):
9483 
    L = ['%s=%r' % (key, value)
9484 
      for key, value in self.__dict__.iteritems()]
9485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9486 
 
9487 
  def __eq__(self, other):
9488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9489 
 
9490 
  def __ne__(self, other):
9491 
    return not (self == other)
9492 
 
9493 
class getAllSimilarItems_result:
9494 
  """
9495 
  Attributes:
9496 
   - success
9497 
  """
9498 
 
9499 
  thrift_spec = (
9500 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9501 
  )
9502 
 
9503 
  def __init__(self, success=None,):
9504 
    self.success = success
9505 
 
9506 
  def read(self, iprot):
9507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9509 
      return
9510 
    iprot.readStructBegin()
9511 
    while True:
9512 
      (fname, ftype, fid) = iprot.readFieldBegin()
9513 
      if ftype == TType.STOP:
9514 
        break
9515 
      if fid == 0:
9516 
        if ftype == TType.LIST:
9517 
          self.success = []
9518 
          (_etype131, _size128) = iprot.readListBegin()
9519 
          for _i132 in xrange(_size128):
9520 
            _elem133 = Item()
9521 
            _elem133.read(iprot)
9522 
            self.success.append(_elem133)
9523 
          iprot.readListEnd()
9524 
        else:
9525 
          iprot.skip(ftype)
9526 
      else:
9527 
        iprot.skip(ftype)
9528 
      iprot.readFieldEnd()
9529 
    iprot.readStructEnd()
9530 
 
9531 
  def write(self, oprot):
9532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9534 
      return
9535 
    oprot.writeStructBegin('getAllSimilarItems_result')
9536 
    if self.success is not None:
9537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9539 
      for iter134 in self.success:
9540 
        iter134.write(oprot)
9541 
      oprot.writeListEnd()
9542 
      oprot.writeFieldEnd()
9543 
    oprot.writeFieldStop()
9544 
    oprot.writeStructEnd()
9545 
 
9546 
  def validate(self):
9547 
    return
9548 
 
9549 
 
9550 
  def __repr__(self):
9551 
    L = ['%s=%r' % (key, value)
9552 
      for key, value in self.__dict__.iteritems()]
9553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9554 
 
9555 
  def __eq__(self, other):
9556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9557 
 
9558 
  def __ne__(self, other):
9559 
    return not (self == other)
9560 
 
9561 
class addSimilarItem_args:
9562 
  """
9563 
  Attributes:
9564 
   - itemId
9565 
   - catalogItemId
9566 
  """
9567 
 
9568 
  thrift_spec = (
9569 
    None, # 0
9570 
    (1, TType.I64, 'itemId', None, None, ), # 1
9571 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9572 
  )
9573 
 
9574 
  def __init__(self, itemId=None, catalogItemId=None,):
9575 
    self.itemId = itemId
9576 
    self.catalogItemId = catalogItemId
9577 
 
9578 
  def read(self, iprot):
9579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9581 
      return
9582 
    iprot.readStructBegin()
9583 
    while True:
9584 
      (fname, ftype, fid) = iprot.readFieldBegin()
9585 
      if ftype == TType.STOP:
9586 
        break
9587 
      if fid == 1:
9588 
        if ftype == TType.I64:
9589 
          self.itemId = iprot.readI64();
9590 
        else:
9591 
          iprot.skip(ftype)
9592 
      elif fid == 2:
9593 
        if ftype == TType.I64:
9594 
          self.catalogItemId = iprot.readI64();
9595 
        else:
9596 
          iprot.skip(ftype)
9597 
      else:
9598 
        iprot.skip(ftype)
9599 
      iprot.readFieldEnd()
9600 
    iprot.readStructEnd()
9601 
 
9602 
  def write(self, oprot):
9603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9605 
      return
9606 
    oprot.writeStructBegin('addSimilarItem_args')
9607 
    if self.itemId is not None:
9608 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9609 
      oprot.writeI64(self.itemId)
9610 
      oprot.writeFieldEnd()
9611 
    if self.catalogItemId is not None:
9612 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9613 
      oprot.writeI64(self.catalogItemId)
9614 
      oprot.writeFieldEnd()
9615 
    oprot.writeFieldStop()
9616 
    oprot.writeStructEnd()
9617 
 
9618 
  def validate(self):
9619 
    return
9620 
 
9621 
 
9622 
  def __repr__(self):
9623 
    L = ['%s=%r' % (key, value)
9624 
      for key, value in self.__dict__.iteritems()]
9625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9626 
 
9627 
  def __eq__(self, other):
9628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9629 
 
9630 
  def __ne__(self, other):
9631 
    return not (self == other)
9632 
 
9633 
class addSimilarItem_result:
9634 
  """
9635 
  Attributes:
9636 
   - success
9637 
   - cex
9638 
  """
9639 
 
9640 
  thrift_spec = (
9641 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9642 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9643 
  )
9644 
 
9645 
  def __init__(self, success=None, cex=None,):
9646 
    self.success = success
9647 
    self.cex = cex
9648 
 
9649 
  def read(self, iprot):
9650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9652 
      return
9653 
    iprot.readStructBegin()
9654 
    while True:
9655 
      (fname, ftype, fid) = iprot.readFieldBegin()
9656 
      if ftype == TType.STOP:
9657 
        break
9658 
      if fid == 0:
9659 
        if ftype == TType.STRUCT:
9660 
          self.success = Item()
9661 
          self.success.read(iprot)
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 1:
9665 
        if ftype == TType.STRUCT:
9666 
          self.cex = CatalogServiceException()
9667 
          self.cex.read(iprot)
9668 
        else:
9669 
          iprot.skip(ftype)
9670 
      else:
9671 
        iprot.skip(ftype)
9672 
      iprot.readFieldEnd()
9673 
    iprot.readStructEnd()
9674 
 
9675 
  def write(self, oprot):
9676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9678 
      return
9679 
    oprot.writeStructBegin('addSimilarItem_result')
9680 
    if self.success is not None:
9681 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9682 
      self.success.write(oprot)
9683 
      oprot.writeFieldEnd()
9684 
    if self.cex is not None:
9685 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9686 
      self.cex.write(oprot)
9687 
      oprot.writeFieldEnd()
9688 
    oprot.writeFieldStop()
9689 
    oprot.writeStructEnd()
9690 
 
9691 
  def validate(self):
9692 
    return
9693 
 
9694 
 
9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
6512 kshitij.so 9706 
class addTag_args:
9707 
  """
9708 
  Attributes:
9709 
   - displayName
9710 
   - itemId
9711 
  """
9712 
 
9713 
  thrift_spec = (
9714 
    None, # 0
9715 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9716 
    (2, TType.I64, 'itemId', None, None, ), # 2
9717 
  )
9718 
 
9719 
  def __init__(self, displayName=None, itemId=None,):
9720 
    self.displayName = displayName
9721 
    self.itemId = itemId
9722 
 
9723 
  def read(self, iprot):
9724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9726 
      return
9727 
    iprot.readStructBegin()
9728 
    while True:
9729 
      (fname, ftype, fid) = iprot.readFieldBegin()
9730 
      if ftype == TType.STOP:
9731 
        break
9732 
      if fid == 1:
9733 
        if ftype == TType.STRING:
9734 
          self.displayName = iprot.readString();
9735 
        else:
9736 
          iprot.skip(ftype)
9737 
      elif fid == 2:
9738 
        if ftype == TType.I64:
9739 
          self.itemId = iprot.readI64();
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      else:
9743 
        iprot.skip(ftype)
9744 
      iprot.readFieldEnd()
9745 
    iprot.readStructEnd()
9746 
 
9747 
  def write(self, oprot):
9748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9750 
      return
9751 
    oprot.writeStructBegin('addTag_args')
9752 
    if self.displayName is not None:
9753 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9754 
      oprot.writeString(self.displayName)
9755 
      oprot.writeFieldEnd()
9756 
    if self.itemId is not None:
9757 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9758 
      oprot.writeI64(self.itemId)
9759 
      oprot.writeFieldEnd()
9760 
    oprot.writeFieldStop()
9761 
    oprot.writeStructEnd()
9762 
 
9763 
  def validate(self):
9764 
    return
9765 
 
9766 
 
9767 
  def __repr__(self):
9768 
    L = ['%s=%r' % (key, value)
9769 
      for key, value in self.__dict__.iteritems()]
9770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9771 
 
9772 
  def __eq__(self, other):
9773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9774 
 
9775 
  def __ne__(self, other):
9776 
    return not (self == other)
9777 
 
9778 
class addTag_result:
9779 
  """
9780 
  Attributes:
9781 
   - success
9782 
  """
9783 
 
9784 
  thrift_spec = (
9785 
    (0, TType.BOOL, 'success', None, None, ), # 0
9786 
  )
9787 
 
9788 
  def __init__(self, success=None,):
9789 
    self.success = success
9790 
 
9791 
  def read(self, iprot):
9792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9794 
      return
9795 
    iprot.readStructBegin()
9796 
    while True:
9797 
      (fname, ftype, fid) = iprot.readFieldBegin()
9798 
      if ftype == TType.STOP:
9799 
        break
9800 
      if fid == 0:
9801 
        if ftype == TType.BOOL:
9802 
          self.success = iprot.readBool();
9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      else:
9806 
        iprot.skip(ftype)
9807 
      iprot.readFieldEnd()
9808 
    iprot.readStructEnd()
9809 
 
9810 
  def write(self, oprot):
9811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9813 
      return
9814 
    oprot.writeStructBegin('addTag_result')
9815 
    if self.success is not None:
9816 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9817 
      oprot.writeBool(self.success)
9818 
      oprot.writeFieldEnd()
9819 
    oprot.writeFieldStop()
9820 
    oprot.writeStructEnd()
9821 
 
9822 
  def validate(self):
9823 
    return
9824 
 
9825 
 
9826 
  def __repr__(self):
9827 
    L = ['%s=%r' % (key, value)
9828 
      for key, value in self.__dict__.iteritems()]
9829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9830 
 
9831 
  def __eq__(self, other):
9832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9833 
 
9834 
  def __ne__(self, other):
9835 
    return not (self == other)
9836 
 
9837 
class deleteEntityTag_args:
9838 
  """
9839 
  Attributes:
9840 
   - displayName
9841 
   - itemId
9842 
  """
9843 
 
9844 
  thrift_spec = (
9845 
    None, # 0
9846 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9847 
    (2, TType.I64, 'itemId', None, None, ), # 2
9848 
  )
9849 
 
9850 
  def __init__(self, displayName=None, itemId=None,):
9851 
    self.displayName = displayName
9852 
    self.itemId = itemId
9853 
 
9854 
  def read(self, iprot):
9855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9857 
      return
9858 
    iprot.readStructBegin()
9859 
    while True:
9860 
      (fname, ftype, fid) = iprot.readFieldBegin()
9861 
      if ftype == TType.STOP:
9862 
        break
9863 
      if fid == 1:
9864 
        if ftype == TType.STRING:
9865 
          self.displayName = iprot.readString();
9866 
        else:
9867 
          iprot.skip(ftype)
9868 
      elif fid == 2:
9869 
        if ftype == TType.I64:
9870 
          self.itemId = iprot.readI64();
9871 
        else:
9872 
          iprot.skip(ftype)
9873 
      else:
9874 
        iprot.skip(ftype)
9875 
      iprot.readFieldEnd()
9876 
    iprot.readStructEnd()
9877 
 
9878 
  def write(self, oprot):
9879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9881 
      return
9882 
    oprot.writeStructBegin('deleteEntityTag_args')
9883 
    if self.displayName is not None:
9884 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9885 
      oprot.writeString(self.displayName)
9886 
      oprot.writeFieldEnd()
9887 
    if self.itemId is not None:
9888 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9889 
      oprot.writeI64(self.itemId)
9890 
      oprot.writeFieldEnd()
9891 
    oprot.writeFieldStop()
9892 
    oprot.writeStructEnd()
9893 
 
9894 
  def validate(self):
9895 
    return
9896 
 
9897 
 
9898 
  def __repr__(self):
9899 
    L = ['%s=%r' % (key, value)
9900 
      for key, value in self.__dict__.iteritems()]
9901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9902 
 
9903 
  def __eq__(self, other):
9904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9905 
 
9906 
  def __ne__(self, other):
9907 
    return not (self == other)
9908 
 
9909 
class deleteEntityTag_result:
9910 
  """
9911 
  Attributes:
9912 
   - success
9913 
  """
9914 
 
9915 
  thrift_spec = (
9916 
    (0, TType.BOOL, 'success', None, None, ), # 0
9917 
  )
9918 
 
9919 
  def __init__(self, success=None,):
9920 
    self.success = success
9921 
 
9922 
  def read(self, iprot):
9923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9925 
      return
9926 
    iprot.readStructBegin()
9927 
    while True:
9928 
      (fname, ftype, fid) = iprot.readFieldBegin()
9929 
      if ftype == TType.STOP:
9930 
        break
9931 
      if fid == 0:
9932 
        if ftype == TType.BOOL:
9933 
          self.success = iprot.readBool();
9934 
        else:
9935 
          iprot.skip(ftype)
9936 
      else:
9937 
        iprot.skip(ftype)
9938 
      iprot.readFieldEnd()
9939 
    iprot.readStructEnd()
9940 
 
9941 
  def write(self, oprot):
9942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9944 
      return
9945 
    oprot.writeStructBegin('deleteEntityTag_result')
9946 
    if self.success is not None:
9947 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9948 
      oprot.writeBool(self.success)
9949 
      oprot.writeFieldEnd()
9950 
    oprot.writeFieldStop()
9951 
    oprot.writeStructEnd()
9952 
 
9953 
  def validate(self):
9954 
    return
9955 
 
9956 
 
9957 
  def __repr__(self):
9958 
    L = ['%s=%r' % (key, value)
9959 
      for key, value in self.__dict__.iteritems()]
9960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9961 
 
9962 
  def __eq__(self, other):
9963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9964 
 
9965 
  def __ne__(self, other):
9966 
    return not (self == other)
9967 
 
9968 
class deleteTag_args:
9969 
  """
9970 
  Attributes:
9971 
   - displayName
9972 
  """
9973 
 
9974 
  thrift_spec = (
9975 
    None, # 0
9976 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9977 
  )
9978 
 
9979 
  def __init__(self, displayName=None,):
9980 
    self.displayName = displayName
9981 
 
9982 
  def read(self, iprot):
9983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9985 
      return
9986 
    iprot.readStructBegin()
9987 
    while True:
9988 
      (fname, ftype, fid) = iprot.readFieldBegin()
9989 
      if ftype == TType.STOP:
9990 
        break
9991 
      if fid == 1:
9992 
        if ftype == TType.STRING:
9993 
          self.displayName = iprot.readString();
9994 
        else:
9995 
          iprot.skip(ftype)
9996 
      else:
9997 
        iprot.skip(ftype)
9998 
      iprot.readFieldEnd()
9999 
    iprot.readStructEnd()
10000 
 
10001 
  def write(self, oprot):
10002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10004 
      return
10005 
    oprot.writeStructBegin('deleteTag_args')
10006 
    if self.displayName is not None:
10007 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10008 
      oprot.writeString(self.displayName)
10009 
      oprot.writeFieldEnd()
10010 
    oprot.writeFieldStop()
10011 
    oprot.writeStructEnd()
10012 
 
10013 
  def validate(self):
10014 
    return
10015 
 
10016 
 
10017 
  def __repr__(self):
10018 
    L = ['%s=%r' % (key, value)
10019 
      for key, value in self.__dict__.iteritems()]
10020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10021 
 
10022 
  def __eq__(self, other):
10023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10024 
 
10025 
  def __ne__(self, other):
10026 
    return not (self == other)
10027 
 
10028 
class deleteTag_result:
10029 
  """
10030 
  Attributes:
10031 
   - success
10032 
  """
10033 
 
10034 
  thrift_spec = (
10035 
    (0, TType.BOOL, 'success', None, None, ), # 0
10036 
  )
10037 
 
10038 
  def __init__(self, success=None,):
10039 
    self.success = success
10040 
 
10041 
  def read(self, iprot):
10042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10044 
      return
10045 
    iprot.readStructBegin()
10046 
    while True:
10047 
      (fname, ftype, fid) = iprot.readFieldBegin()
10048 
      if ftype == TType.STOP:
10049 
        break
10050 
      if fid == 0:
10051 
        if ftype == TType.BOOL:
10052 
          self.success = iprot.readBool();
10053 
        else:
10054 
          iprot.skip(ftype)
10055 
      else:
10056 
        iprot.skip(ftype)
10057 
      iprot.readFieldEnd()
10058 
    iprot.readStructEnd()
10059 
 
10060 
  def write(self, oprot):
10061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10063 
      return
10064 
    oprot.writeStructBegin('deleteTag_result')
10065 
    if self.success is not None:
10066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10067 
      oprot.writeBool(self.success)
10068 
      oprot.writeFieldEnd()
10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
10072 
  def validate(self):
10073 
    return
10074 
 
10075 
 
10076 
  def __repr__(self):
10077 
    L = ['%s=%r' % (key, value)
10078 
      for key, value in self.__dict__.iteritems()]
10079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10080 
 
10081 
  def __eq__(self, other):
10082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10083 
 
10084 
  def __ne__(self, other):
10085 
    return not (self == other)
10086 
 
10087 
class getAllTags_args:
10088 
 
10089 
  thrift_spec = (
10090 
  )
10091 
 
10092 
  def read(self, iprot):
10093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10095 
      return
10096 
    iprot.readStructBegin()
10097 
    while True:
10098 
      (fname, ftype, fid) = iprot.readFieldBegin()
10099 
      if ftype == TType.STOP:
10100 
        break
10101 
      else:
10102 
        iprot.skip(ftype)
10103 
      iprot.readFieldEnd()
10104 
    iprot.readStructEnd()
10105 
 
10106 
  def write(self, oprot):
10107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10109 
      return
10110 
    oprot.writeStructBegin('getAllTags_args')
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
10129 
class getAllTags_result:
10130 
  """
10131 
  Attributes:
10132 
   - success
10133 
  """
10134 
 
10135 
  thrift_spec = (
10136 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10137 
  )
10138 
 
10139 
  def __init__(self, success=None,):
10140 
    self.success = success
10141 
 
10142 
  def read(self, iprot):
10143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10145 
      return
10146 
    iprot.readStructBegin()
10147 
    while True:
10148 
      (fname, ftype, fid) = iprot.readFieldBegin()
10149 
      if ftype == TType.STOP:
10150 
        break
10151 
      if fid == 0:
10152 
        if ftype == TType.LIST:
10153 
          self.success = []
10154 
          (_etype138, _size135) = iprot.readListBegin()
10155 
          for _i139 in xrange(_size135):
10156 
            _elem140 = iprot.readString();
10157 
            self.success.append(_elem140)
10158 
          iprot.readListEnd()
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      else:
10162 
        iprot.skip(ftype)
10163 
      iprot.readFieldEnd()
10164 
    iprot.readStructEnd()
10165 
 
10166 
  def write(self, oprot):
10167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10169 
      return
10170 
    oprot.writeStructBegin('getAllTags_result')
10171 
    if self.success is not None:
10172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10173 
      oprot.writeListBegin(TType.STRING, len(self.success))
10174 
      for iter141 in self.success:
10175 
        oprot.writeString(iter141)
10176 
      oprot.writeListEnd()
10177 
      oprot.writeFieldEnd()
10178 
    oprot.writeFieldStop()
10179 
    oprot.writeStructEnd()
10180 
 
10181 
  def validate(self):
10182 
    return
10183 
 
10184 
 
10185 
  def __repr__(self):
10186 
    L = ['%s=%r' % (key, value)
10187 
      for key, value in self.__dict__.iteritems()]
10188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10189 
 
10190 
  def __eq__(self, other):
10191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10192 
 
10193 
  def __ne__(self, other):
10194 
    return not (self == other)
10195 
 
10196 
class getAllEntitiesByTagName_args:
10197 
  """
10198 
  Attributes:
10199 
   - displayName
10200 
  """
10201 
 
10202 
  thrift_spec = (
10203 
    None, # 0
10204 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10205 
  )
10206 
 
10207 
  def __init__(self, displayName=None,):
10208 
    self.displayName = displayName
10209 
 
10210 
  def read(self, iprot):
10211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10213 
      return
10214 
    iprot.readStructBegin()
10215 
    while True:
10216 
      (fname, ftype, fid) = iprot.readFieldBegin()
10217 
      if ftype == TType.STOP:
10218 
        break
10219 
      if fid == 1:
10220 
        if ftype == TType.STRING:
10221 
          self.displayName = iprot.readString();
10222 
        else:
10223 
          iprot.skip(ftype)
10224 
      else:
10225 
        iprot.skip(ftype)
10226 
      iprot.readFieldEnd()
10227 
    iprot.readStructEnd()
10228 
 
10229 
  def write(self, oprot):
10230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10232 
      return
10233 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10234 
    if self.displayName is not None:
10235 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10236 
      oprot.writeString(self.displayName)
10237 
      oprot.writeFieldEnd()
10238 
    oprot.writeFieldStop()
10239 
    oprot.writeStructEnd()
10240 
 
10241 
  def validate(self):
10242 
    return
10243 
 
10244 
 
10245 
  def __repr__(self):
10246 
    L = ['%s=%r' % (key, value)
10247 
      for key, value in self.__dict__.iteritems()]
10248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10249 
 
10250 
  def __eq__(self, other):
10251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10252 
 
10253 
  def __ne__(self, other):
10254 
    return not (self == other)
10255 
 
10256 
class getAllEntitiesByTagName_result:
10257 
  """
10258 
  Attributes:
10259 
   - success
10260 
  """
10261 
 
10262 
  thrift_spec = (
10263 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10264 
  )
10265 
 
10266 
  def __init__(self, success=None,):
10267 
    self.success = success
10268 
 
10269 
  def read(self, iprot):
10270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10272 
      return
10273 
    iprot.readStructBegin()
10274 
    while True:
10275 
      (fname, ftype, fid) = iprot.readFieldBegin()
10276 
      if ftype == TType.STOP:
10277 
        break
10278 
      if fid == 0:
10279 
        if ftype == TType.LIST:
10280 
          self.success = []
10281 
          (_etype145, _size142) = iprot.readListBegin()
10282 
          for _i146 in xrange(_size142):
10283 
            _elem147 = iprot.readI64();
10284 
            self.success.append(_elem147)
10285 
          iprot.readListEnd()
10286 
        else:
10287 
          iprot.skip(ftype)
10288 
      else:
10289 
        iprot.skip(ftype)
10290 
      iprot.readFieldEnd()
10291 
    iprot.readStructEnd()
10292 
 
10293 
  def write(self, oprot):
10294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10296 
      return
10297 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10298 
    if self.success is not None:
10299 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10300 
      oprot.writeListBegin(TType.I64, len(self.success))
10301 
      for iter148 in self.success:
10302 
        oprot.writeI64(iter148)
10303 
      oprot.writeListEnd()
10304 
      oprot.writeFieldEnd()
10305 
    oprot.writeFieldStop()
10306 
    oprot.writeStructEnd()
10307 
 
10308 
  def validate(self):
10309 
    return
10310 
 
10311 
 
10312 
  def __repr__(self):
10313 
    L = ['%s=%r' % (key, value)
10314 
      for key, value in self.__dict__.iteritems()]
10315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10316 
 
10317 
  def __eq__(self, other):
10318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10319 
 
10320 
  def __ne__(self, other):
10321 
    return not (self == other)
10322 
 
6845 amit.gupta 10323 
class getAllEntityTags_args:
10324 
 
10325 
  thrift_spec = (
10326 
  )
10327 
 
10328 
  def read(self, iprot):
10329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10331 
      return
10332 
    iprot.readStructBegin()
10333 
    while True:
10334 
      (fname, ftype, fid) = iprot.readFieldBegin()
10335 
      if ftype == TType.STOP:
10336 
        break
10337 
      else:
10338 
        iprot.skip(ftype)
10339 
      iprot.readFieldEnd()
10340 
    iprot.readStructEnd()
10341 
 
10342 
  def write(self, oprot):
10343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10345 
      return
10346 
    oprot.writeStructBegin('getAllEntityTags_args')
10347 
    oprot.writeFieldStop()
10348 
    oprot.writeStructEnd()
10349 
 
10350 
  def validate(self):
10351 
    return
10352 
 
10353 
 
10354 
  def __repr__(self):
10355 
    L = ['%s=%r' % (key, value)
10356 
      for key, value in self.__dict__.iteritems()]
10357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10358 
 
10359 
  def __eq__(self, other):
10360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10361 
 
10362 
  def __ne__(self, other):
10363 
    return not (self == other)
10364 
 
10365 
class getAllEntityTags_result:
10366 
  """
10367 
  Attributes:
10368 
   - success
10369 
  """
10370 
 
10371 
  thrift_spec = (
10372 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10373 
  )
10374 
 
10375 
  def __init__(self, success=None,):
10376 
    self.success = success
10377 
 
10378 
  def read(self, iprot):
10379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10381 
      return
10382 
    iprot.readStructBegin()
10383 
    while True:
10384 
      (fname, ftype, fid) = iprot.readFieldBegin()
10385 
      if ftype == TType.STOP:
10386 
        break
10387 
      if fid == 0:
10388 
        if ftype == TType.MAP:
10389 
          self.success = {}
10390 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10391 
          for _i153 in xrange(_size149):
10392 
            _key154 = iprot.readI64();
10393 
            _val155 = []
10394 
            (_etype159, _size156) = iprot.readListBegin()
10395 
            for _i160 in xrange(_size156):
10396 
              _elem161 = iprot.readString();
10397 
              _val155.append(_elem161)
10398 
            iprot.readListEnd()
10399 
            self.success[_key154] = _val155
10400 
          iprot.readMapEnd()
10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
10412 
    oprot.writeStructBegin('getAllEntityTags_result')
10413 
    if self.success is not None:
10414 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10415 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10416 
      for kiter162,viter163 in self.success.items():
10417 
        oprot.writeI64(kiter162)
10418 
        oprot.writeListBegin(TType.STRING, len(viter163))
10419 
        for iter164 in viter163:
10420 
          oprot.writeString(iter164)
10421 
        oprot.writeListEnd()
10422 
      oprot.writeMapEnd()
10423 
      oprot.writeFieldEnd()
10424 
    oprot.writeFieldStop()
10425 
    oprot.writeStructEnd()
10426 
 
10427 
  def validate(self):
10428 
    return
10429 
 
10430 
 
10431 
  def __repr__(self):
10432 
    L = ['%s=%r' % (key, value)
10433 
      for key, value in self.__dict__.iteritems()]
10434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10435 
 
10436 
  def __eq__(self, other):
10437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10438 
 
10439 
  def __ne__(self, other):
10440 
    return not (self == other)
10441 
 
6850 kshitij.so 10442 
class addBanner_args:
10443 
  """
10444 
  Attributes:
10445 
   - bannerName
10446 
   - imageName
10447 
   - link
10448 
   - priority
10449 
   - isActive
10450 
   - hasMap
10451 
  """
10452 
 
10453 
  thrift_spec = (
10454 
    None, # 0
10455 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10456 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10457 
    (3, TType.STRING, 'link', None, None, ), # 3
10458 
    (4, TType.I64, 'priority', None, None, ), # 4
10459 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10460 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10461 
  )
10462 
 
10463 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10464 
    self.bannerName = bannerName
10465 
    self.imageName = imageName
10466 
    self.link = link
10467 
    self.priority = priority
10468 
    self.isActive = isActive
10469 
    self.hasMap = hasMap
10470 
 
10471 
  def read(self, iprot):
10472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10474 
      return
10475 
    iprot.readStructBegin()
10476 
    while True:
10477 
      (fname, ftype, fid) = iprot.readFieldBegin()
10478 
      if ftype == TType.STOP:
10479 
        break
10480 
      if fid == 1:
10481 
        if ftype == TType.STRING:
10482 
          self.bannerName = iprot.readString();
10483 
        else:
10484 
          iprot.skip(ftype)
10485 
      elif fid == 2:
10486 
        if ftype == TType.STRING:
10487 
          self.imageName = iprot.readString();
10488 
        else:
10489 
          iprot.skip(ftype)
10490 
      elif fid == 3:
10491 
        if ftype == TType.STRING:
10492 
          self.link = iprot.readString();
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      elif fid == 4:
10496 
        if ftype == TType.I64:
10497 
          self.priority = iprot.readI64();
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      elif fid == 5:
10501 
        if ftype == TType.BOOL:
10502 
          self.isActive = iprot.readBool();
10503 
        else:
10504 
          iprot.skip(ftype)
10505 
      elif fid == 6:
10506 
        if ftype == TType.BOOL:
10507 
          self.hasMap = iprot.readBool();
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
10519 
    oprot.writeStructBegin('addBanner_args')
10520 
    if self.bannerName is not None:
10521 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10522 
      oprot.writeString(self.bannerName)
10523 
      oprot.writeFieldEnd()
10524 
    if self.imageName is not None:
10525 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10526 
      oprot.writeString(self.imageName)
10527 
      oprot.writeFieldEnd()
10528 
    if self.link is not None:
10529 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10530 
      oprot.writeString(self.link)
10531 
      oprot.writeFieldEnd()
10532 
    if self.priority is not None:
10533 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10534 
      oprot.writeI64(self.priority)
10535 
      oprot.writeFieldEnd()
10536 
    if self.isActive is not None:
10537 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10538 
      oprot.writeBool(self.isActive)
10539 
      oprot.writeFieldEnd()
10540 
    if self.hasMap is not None:
10541 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10542 
      oprot.writeBool(self.hasMap)
10543 
      oprot.writeFieldEnd()
10544 
    oprot.writeFieldStop()
10545 
    oprot.writeStructEnd()
10546 
 
10547 
  def validate(self):
10548 
    return
10549 
 
10550 
 
10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
10562 
class addBanner_result:
10563 
  """
10564 
  Attributes:
10565 
   - success
10566 
  """
10567 
 
10568 
  thrift_spec = (
10569 
    (0, TType.BOOL, 'success', None, None, ), # 0
10570 
  )
10571 
 
10572 
  def __init__(self, success=None,):
10573 
    self.success = success
10574 
 
10575 
  def read(self, iprot):
10576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10578 
      return
10579 
    iprot.readStructBegin()
10580 
    while True:
10581 
      (fname, ftype, fid) = iprot.readFieldBegin()
10582 
      if ftype == TType.STOP:
10583 
        break
10584 
      if fid == 0:
10585 
        if ftype == TType.BOOL:
10586 
          self.success = iprot.readBool();
10587 
        else:
10588 
          iprot.skip(ftype)
10589 
      else:
10590 
        iprot.skip(ftype)
10591 
      iprot.readFieldEnd()
10592 
    iprot.readStructEnd()
10593 
 
10594 
  def write(self, oprot):
10595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10597 
      return
10598 
    oprot.writeStructBegin('addBanner_result')
10599 
    if self.success is not None:
10600 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10601 
      oprot.writeBool(self.success)
10602 
      oprot.writeFieldEnd()
10603 
    oprot.writeFieldStop()
10604 
    oprot.writeStructEnd()
10605 
 
10606 
  def validate(self):
10607 
    return
10608 
 
10609 
 
10610 
  def __repr__(self):
10611 
    L = ['%s=%r' % (key, value)
10612 
      for key, value in self.__dict__.iteritems()]
10613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10614 
 
10615 
  def __eq__(self, other):
10616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10617 
 
10618 
  def __ne__(self, other):
10619 
    return not (self == other)
10620 
 
10621 
class getAllBanners_args:
10622 
 
10623 
  thrift_spec = (
10624 
  )
10625 
 
10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
10635 
      else:
10636 
        iprot.skip(ftype)
10637 
      iprot.readFieldEnd()
10638 
    iprot.readStructEnd()
10639 
 
10640 
  def write(self, oprot):
10641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10643 
      return
10644 
    oprot.writeStructBegin('getAllBanners_args')
10645 
    oprot.writeFieldStop()
10646 
    oprot.writeStructEnd()
10647 
 
10648 
  def validate(self):
10649 
    return
10650 
 
10651 
 
10652 
  def __repr__(self):
10653 
    L = ['%s=%r' % (key, value)
10654 
      for key, value in self.__dict__.iteritems()]
10655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10656 
 
10657 
  def __eq__(self, other):
10658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10659 
 
10660 
  def __ne__(self, other):
10661 
    return not (self == other)
10662 
 
10663 
class getAllBanners_result:
10664 
  """
10665 
  Attributes:
10666 
   - success
10667 
  """
10668 
 
10669 
  thrift_spec = (
10670 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10671 
  )
10672 
 
10673 
  def __init__(self, success=None,):
10674 
    self.success = success
10675 
 
10676 
  def read(self, iprot):
10677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10679 
      return
10680 
    iprot.readStructBegin()
10681 
    while True:
10682 
      (fname, ftype, fid) = iprot.readFieldBegin()
10683 
      if ftype == TType.STOP:
10684 
        break
10685 
      if fid == 0:
10686 
        if ftype == TType.LIST:
10687 
          self.success = []
10688 
          (_etype168, _size165) = iprot.readListBegin()
10689 
          for _i169 in xrange(_size165):
10690 
            _elem170 = iprot.readString();
10691 
            self.success.append(_elem170)
10692 
          iprot.readListEnd()
10693 
        else:
10694 
          iprot.skip(ftype)
10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('getAllBanners_result')
10705 
    if self.success is not None:
10706 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10707 
      oprot.writeListBegin(TType.STRING, len(self.success))
10708 
      for iter171 in self.success:
10709 
        oprot.writeString(iter171)
10710 
      oprot.writeListEnd()
10711 
      oprot.writeFieldEnd()
10712 
    oprot.writeFieldStop()
10713 
    oprot.writeStructEnd()
10714 
 
10715 
  def validate(self):
10716 
    return
10717 
 
10718 
 
10719 
  def __repr__(self):
10720 
    L = ['%s=%r' % (key, value)
10721 
      for key, value in self.__dict__.iteritems()]
10722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10723 
 
10724 
  def __eq__(self, other):
10725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10726 
 
10727 
  def __ne__(self, other):
10728 
    return not (self == other)
10729 
 
10730 
class deleteBanner_args:
10731 
  """
10732 
  Attributes:
10733 
   - bannerName
10734 
  """
10735 
 
10736 
  thrift_spec = (
10737 
    None, # 0
10738 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10739 
  )
10740 
 
10741 
  def __init__(self, bannerName=None,):
10742 
    self.bannerName = bannerName
10743 
 
10744 
  def read(self, iprot):
10745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10747 
      return
10748 
    iprot.readStructBegin()
10749 
    while True:
10750 
      (fname, ftype, fid) = iprot.readFieldBegin()
10751 
      if ftype == TType.STOP:
10752 
        break
10753 
      if fid == 1:
10754 
        if ftype == TType.STRING:
10755 
          self.bannerName = iprot.readString();
10756 
        else:
10757 
          iprot.skip(ftype)
10758 
      else:
10759 
        iprot.skip(ftype)
10760 
      iprot.readFieldEnd()
10761 
    iprot.readStructEnd()
10762 
 
10763 
  def write(self, oprot):
10764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10766 
      return
10767 
    oprot.writeStructBegin('deleteBanner_args')
10768 
    if self.bannerName is not None:
10769 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10770 
      oprot.writeString(self.bannerName)
10771 
      oprot.writeFieldEnd()
10772 
    oprot.writeFieldStop()
10773 
    oprot.writeStructEnd()
10774 
 
10775 
  def validate(self):
10776 
    return
10777 
 
10778 
 
10779 
  def __repr__(self):
10780 
    L = ['%s=%r' % (key, value)
10781 
      for key, value in self.__dict__.iteritems()]
10782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10783 
 
10784 
  def __eq__(self, other):
10785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10786 
 
10787 
  def __ne__(self, other):
10788 
    return not (self == other)
10789 
 
10790 
class deleteBanner_result:
10791 
  """
10792 
  Attributes:
10793 
   - success
10794 
  """
10795 
 
10796 
  thrift_spec = (
10797 
    (0, TType.BOOL, 'success', None, None, ), # 0
10798 
  )
10799 
 
10800 
  def __init__(self, success=None,):
10801 
    self.success = success
10802 
 
10803 
  def read(self, iprot):
10804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10806 
      return
10807 
    iprot.readStructBegin()
10808 
    while True:
10809 
      (fname, ftype, fid) = iprot.readFieldBegin()
10810 
      if ftype == TType.STOP:
10811 
        break
10812 
      if fid == 0:
10813 
        if ftype == TType.BOOL:
10814 
          self.success = iprot.readBool();
10815 
        else:
10816 
          iprot.skip(ftype)
10817 
      else:
10818 
        iprot.skip(ftype)
10819 
      iprot.readFieldEnd()
10820 
    iprot.readStructEnd()
10821 
 
10822 
  def write(self, oprot):
10823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10825 
      return
10826 
    oprot.writeStructBegin('deleteBanner_result')
10827 
    if self.success is not None:
10828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10829 
      oprot.writeBool(self.success)
10830 
      oprot.writeFieldEnd()
10831 
    oprot.writeFieldStop()
10832 
    oprot.writeStructEnd()
10833 
 
10834 
  def validate(self):
10835 
    return
10836 
 
10837 
 
10838 
  def __repr__(self):
10839 
    L = ['%s=%r' % (key, value)
10840 
      for key, value in self.__dict__.iteritems()]
10841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10842 
 
10843 
  def __eq__(self, other):
10844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10845 
 
10846 
  def __ne__(self, other):
10847 
    return not (self == other)
10848 
 
10849 
class getBannerDetails_args:
10850 
  """
10851 
  Attributes:
10852 
   - bannerName
10853 
  """
10854 
 
10855 
  thrift_spec = (
10856 
    None, # 0
10857 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10858 
  )
10859 
 
10860 
  def __init__(self, bannerName=None,):
10861 
    self.bannerName = bannerName
10862 
 
10863 
  def read(self, iprot):
10864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10866 
      return
10867 
    iprot.readStructBegin()
10868 
    while True:
10869 
      (fname, ftype, fid) = iprot.readFieldBegin()
10870 
      if ftype == TType.STOP:
10871 
        break
10872 
      if fid == 1:
10873 
        if ftype == TType.STRING:
10874 
          self.bannerName = iprot.readString();
10875 
        else:
10876 
          iprot.skip(ftype)
10877 
      else:
10878 
        iprot.skip(ftype)
10879 
      iprot.readFieldEnd()
10880 
    iprot.readStructEnd()
10881 
 
10882 
  def write(self, oprot):
10883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10885 
      return
10886 
    oprot.writeStructBegin('getBannerDetails_args')
10887 
    if self.bannerName is not None:
10888 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10889 
      oprot.writeString(self.bannerName)
10890 
      oprot.writeFieldEnd()
10891 
    oprot.writeFieldStop()
10892 
    oprot.writeStructEnd()
10893 
 
10894 
  def validate(self):
10895 
    return
10896 
 
10897 
 
10898 
  def __repr__(self):
10899 
    L = ['%s=%r' % (key, value)
10900 
      for key, value in self.__dict__.iteritems()]
10901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10902 
 
10903 
  def __eq__(self, other):
10904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10905 
 
10906 
  def __ne__(self, other):
10907 
    return not (self == other)
10908 
 
10909 
class getBannerDetails_result:
10910 
  """
10911 
  Attributes:
10912 
   - success
10913 
  """
10914 
 
10915 
  thrift_spec = (
10916 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10917 
  )
10918 
 
10919 
  def __init__(self, success=None,):
10920 
    self.success = success
10921 
 
10922 
  def read(self, iprot):
10923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10925 
      return
10926 
    iprot.readStructBegin()
10927 
    while True:
10928 
      (fname, ftype, fid) = iprot.readFieldBegin()
10929 
      if ftype == TType.STOP:
10930 
        break
10931 
      if fid == 0:
10932 
        if ftype == TType.STRUCT:
10933 
          self.success = Banner()
10934 
          self.success.read(iprot)
10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      else:
10938 
        iprot.skip(ftype)
10939 
      iprot.readFieldEnd()
10940 
    iprot.readStructEnd()
10941 
 
10942 
  def write(self, oprot):
10943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10945 
      return
10946 
    oprot.writeStructBegin('getBannerDetails_result')
10947 
    if self.success is not None:
10948 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10949 
      self.success.write(oprot)
10950 
      oprot.writeFieldEnd()
10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
10954 
  def validate(self):
10955 
    return
10956 
 
10957 
 
10958 
  def __repr__(self):
10959 
    L = ['%s=%r' % (key, value)
10960 
      for key, value in self.__dict__.iteritems()]
10961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10962 
 
10963 
  def __eq__(self, other):
10964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10965 
 
10966 
  def __ne__(self, other):
10967 
    return not (self == other)
10968 
 
10969 
class getActiveBanners_args:
10970 
 
10971 
  thrift_spec = (
10972 
  )
10973 
 
10974 
  def read(self, iprot):
10975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10977 
      return
10978 
    iprot.readStructBegin()
10979 
    while True:
10980 
      (fname, ftype, fid) = iprot.readFieldBegin()
10981 
      if ftype == TType.STOP:
10982 
        break
10983 
      else:
10984 
        iprot.skip(ftype)
10985 
      iprot.readFieldEnd()
10986 
    iprot.readStructEnd()
10987 
 
10988 
  def write(self, oprot):
10989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10991 
      return
10992 
    oprot.writeStructBegin('getActiveBanners_args')
10993 
    oprot.writeFieldStop()
10994 
    oprot.writeStructEnd()
10995 
 
10996 
  def validate(self):
10997 
    return
10998 
 
10999 
 
11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
11011 
class getActiveBanners_result:
11012 
  """
11013 
  Attributes:
11014 
   - success
11015 
  """
11016 
 
11017 
  thrift_spec = (
11018 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11019 
  )
11020 
 
11021 
  def __init__(self, success=None,):
11022 
    self.success = success
11023 
 
11024 
  def read(self, iprot):
11025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11027 
      return
11028 
    iprot.readStructBegin()
11029 
    while True:
11030 
      (fname, ftype, fid) = iprot.readFieldBegin()
11031 
      if ftype == TType.STOP:
11032 
        break
11033 
      if fid == 0:
11034 
        if ftype == TType.LIST:
11035 
          self.success = []
11036 
          (_etype175, _size172) = iprot.readListBegin()
11037 
          for _i176 in xrange(_size172):
11038 
            _elem177 = Banner()
11039 
            _elem177.read(iprot)
11040 
            self.success.append(_elem177)
11041 
          iprot.readListEnd()
11042 
        else:
11043 
          iprot.skip(ftype)
11044 
      else:
11045 
        iprot.skip(ftype)
11046 
      iprot.readFieldEnd()
11047 
    iprot.readStructEnd()
11048 
 
11049 
  def write(self, oprot):
11050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11052 
      return
11053 
    oprot.writeStructBegin('getActiveBanners_result')
11054 
    if self.success is not None:
11055 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11056 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11057 
      for iter178 in self.success:
11058 
        iter178.write(oprot)
11059 
      oprot.writeListEnd()
11060 
      oprot.writeFieldEnd()
11061 
    oprot.writeFieldStop()
11062 
    oprot.writeStructEnd()
11063 
 
11064 
  def validate(self):
11065 
    return
11066 
 
11067 
 
11068 
  def __repr__(self):
11069 
    L = ['%s=%r' % (key, value)
11070 
      for key, value in self.__dict__.iteritems()]
11071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11072 
 
11073 
  def __eq__(self, other):
11074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11075 
 
11076 
  def __ne__(self, other):
11077 
    return not (self == other)
11078 
 
6849 kshitij.so 11079 
class addBannerMap_args:
11080 
  """
11081 
  Attributes:
11082 
   - bannerName
11083 
   - mapLink
11084 
   - coordinates
11085 
  """
11086 
 
11087 
  thrift_spec = (
11088 
    None, # 0
11089 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11090 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11091 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11092 
  )
11093 
 
11094 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11095 
    self.bannerName = bannerName
11096 
    self.mapLink = mapLink
11097 
    self.coordinates = coordinates
11098 
 
11099 
  def read(self, iprot):
11100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11102 
      return
11103 
    iprot.readStructBegin()
11104 
    while True:
11105 
      (fname, ftype, fid) = iprot.readFieldBegin()
11106 
      if ftype == TType.STOP:
11107 
        break
11108 
      if fid == 1:
11109 
        if ftype == TType.STRING:
11110 
          self.bannerName = iprot.readString();
11111 
        else:
11112 
          iprot.skip(ftype)
11113 
      elif fid == 2:
11114 
        if ftype == TType.STRING:
11115 
          self.mapLink = iprot.readString();
11116 
        else:
11117 
          iprot.skip(ftype)
11118 
      elif fid == 3:
11119 
        if ftype == TType.STRING:
11120 
          self.coordinates = iprot.readString();
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
11132 
    oprot.writeStructBegin('addBannerMap_args')
11133 
    if self.bannerName is not None:
11134 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11135 
      oprot.writeString(self.bannerName)
11136 
      oprot.writeFieldEnd()
11137 
    if self.mapLink is not None:
11138 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11139 
      oprot.writeString(self.mapLink)
11140 
      oprot.writeFieldEnd()
11141 
    if self.coordinates is not None:
11142 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11143 
      oprot.writeString(self.coordinates)
11144 
      oprot.writeFieldEnd()
11145 
    oprot.writeFieldStop()
11146 
    oprot.writeStructEnd()
11147 
 
11148 
  def validate(self):
11149 
    return
11150 
 
11151 
 
11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
11163 
class addBannerMap_result:
11164 
  """
11165 
  Attributes:
11166 
   - success
11167 
  """
11168 
 
11169 
  thrift_spec = (
11170 
    (0, TType.BOOL, 'success', None, None, ), # 0
11171 
  )
11172 
 
11173 
  def __init__(self, success=None,):
11174 
    self.success = success
11175 
 
11176 
  def read(self, iprot):
11177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11179 
      return
11180 
    iprot.readStructBegin()
11181 
    while True:
11182 
      (fname, ftype, fid) = iprot.readFieldBegin()
11183 
      if ftype == TType.STOP:
11184 
        break
11185 
      if fid == 0:
11186 
        if ftype == TType.BOOL:
11187 
          self.success = iprot.readBool();
11188 
        else:
11189 
          iprot.skip(ftype)
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('addBannerMap_result')
11200 
    if self.success is not None:
11201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11202 
      oprot.writeBool(self.success)
11203 
      oprot.writeFieldEnd()
11204 
    oprot.writeFieldStop()
11205 
    oprot.writeStructEnd()
11206 
 
11207 
  def validate(self):
11208 
    return
11209 
 
11210 
 
11211 
  def __repr__(self):
11212 
    L = ['%s=%r' % (key, value)
11213 
      for key, value in self.__dict__.iteritems()]
11214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11215 
 
11216 
  def __eq__(self, other):
11217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11218 
 
11219 
  def __ne__(self, other):
11220 
    return not (self == other)
11221 
 
11222 
class deleteBannerMap_args:
11223 
  """
11224 
  Attributes:
11225 
   - bannerName
11226 
  """
11227 
 
11228 
  thrift_spec = (
11229 
    None, # 0
11230 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11231 
  )
11232 
 
11233 
  def __init__(self, bannerName=None,):
11234 
    self.bannerName = bannerName
11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.STRING:
11247 
          self.bannerName = iprot.readString();
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      else:
11251 
        iprot.skip(ftype)
11252 
      iprot.readFieldEnd()
11253 
    iprot.readStructEnd()
11254 
 
11255 
  def write(self, oprot):
11256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11258 
      return
11259 
    oprot.writeStructBegin('deleteBannerMap_args')
11260 
    if self.bannerName is not None:
11261 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11262 
      oprot.writeString(self.bannerName)
11263 
      oprot.writeFieldEnd()
11264 
    oprot.writeFieldStop()
11265 
    oprot.writeStructEnd()
11266 
 
11267 
  def validate(self):
11268 
    return
11269 
 
11270 
 
11271 
  def __repr__(self):
11272 
    L = ['%s=%r' % (key, value)
11273 
      for key, value in self.__dict__.iteritems()]
11274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11275 
 
11276 
  def __eq__(self, other):
11277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11278 
 
11279 
  def __ne__(self, other):
11280 
    return not (self == other)
11281 
 
11282 
class deleteBannerMap_result:
11283 
  """
11284 
  Attributes:
11285 
   - success
11286 
  """
11287 
 
11288 
  thrift_spec = (
11289 
    (0, TType.BOOL, 'success', None, None, ), # 0
11290 
  )
11291 
 
11292 
  def __init__(self, success=None,):
11293 
    self.success = success
11294 
 
11295 
  def read(self, iprot):
11296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11298 
      return
11299 
    iprot.readStructBegin()
11300 
    while True:
11301 
      (fname, ftype, fid) = iprot.readFieldBegin()
11302 
      if ftype == TType.STOP:
11303 
        break
11304 
      if fid == 0:
11305 
        if ftype == TType.BOOL:
11306 
          self.success = iprot.readBool();
11307 
        else:
11308 
          iprot.skip(ftype)
11309 
      else:
11310 
        iprot.skip(ftype)
11311 
      iprot.readFieldEnd()
11312 
    iprot.readStructEnd()
11313 
 
11314 
  def write(self, oprot):
11315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11317 
      return
11318 
    oprot.writeStructBegin('deleteBannerMap_result')
11319 
    if self.success is not None:
11320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11321 
      oprot.writeBool(self.success)
11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
11341 
class getBannerMapDetails_args:
11342 
  """
11343 
  Attributes:
11344 
   - bannerName
11345 
  """
11346 
 
11347 
  thrift_spec = (
11348 
    None, # 0
11349 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11350 
  )
11351 
 
11352 
  def __init__(self, bannerName=None,):
11353 
    self.bannerName = bannerName
11354 
 
11355 
  def read(self, iprot):
11356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11358 
      return
11359 
    iprot.readStructBegin()
11360 
    while True:
11361 
      (fname, ftype, fid) = iprot.readFieldBegin()
11362 
      if ftype == TType.STOP:
11363 
        break
11364 
      if fid == 1:
11365 
        if ftype == TType.STRING:
11366 
          self.bannerName = iprot.readString();
11367 
        else:
11368 
          iprot.skip(ftype)
11369 
      else:
11370 
        iprot.skip(ftype)
11371 
      iprot.readFieldEnd()
11372 
    iprot.readStructEnd()
11373 
 
11374 
  def write(self, oprot):
11375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11377 
      return
11378 
    oprot.writeStructBegin('getBannerMapDetails_args')
11379 
    if self.bannerName is not None:
11380 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11381 
      oprot.writeString(self.bannerName)
11382 
      oprot.writeFieldEnd()
11383 
    oprot.writeFieldStop()
11384 
    oprot.writeStructEnd()
11385 
 
11386 
  def validate(self):
11387 
    return
11388 
 
11389 
 
11390 
  def __repr__(self):
11391 
    L = ['%s=%r' % (key, value)
11392 
      for key, value in self.__dict__.iteritems()]
11393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11394 
 
11395 
  def __eq__(self, other):
11396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11397 
 
11398 
  def __ne__(self, other):
11399 
    return not (self == other)
11400 
 
11401 
class getBannerMapDetails_result:
11402 
  """
11403 
  Attributes:
11404 
   - success
11405 
  """
11406 
 
11407 
  thrift_spec = (
11408 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11409 
  )
11410 
 
11411 
  def __init__(self, success=None,):
11412 
    self.success = success
11413 
 
11414 
  def read(self, iprot):
11415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11417 
      return
11418 
    iprot.readStructBegin()
11419 
    while True:
11420 
      (fname, ftype, fid) = iprot.readFieldBegin()
11421 
      if ftype == TType.STOP:
11422 
        break
11423 
      if fid == 0:
11424 
        if ftype == TType.LIST:
11425 
          self.success = []
6850 kshitij.so 11426 
          (_etype182, _size179) = iprot.readListBegin()
11427 
          for _i183 in xrange(_size179):
11428 
            _elem184 = BannerMap()
11429 
            _elem184.read(iprot)
11430 
            self.success.append(_elem184)
6849 kshitij.so 11431 
          iprot.readListEnd()
11432 
        else:
11433 
          iprot.skip(ftype)
11434 
      else:
11435 
        iprot.skip(ftype)
11436 
      iprot.readFieldEnd()
11437 
    iprot.readStructEnd()
11438 
 
11439 
  def write(self, oprot):
11440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11442 
      return
11443 
    oprot.writeStructBegin('getBannerMapDetails_result')
11444 
    if self.success is not None:
11445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11447 
      for iter185 in self.success:
11448 
        iter185.write(oprot)
6849 kshitij.so 11449 
      oprot.writeListEnd()
11450 
      oprot.writeFieldEnd()
11451 
    oprot.writeFieldStop()
11452 
    oprot.writeStructEnd()
11453 
 
11454 
  def validate(self):
11455 
    return
11456 
 
11457 
 
11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
5944 mandeep.dh 11469 
class deleteSimilarItem_args:
11470 
  """
11471 
  Attributes:
11472 
   - itemId
11473 
   - catalogItemId
11474 
  """
11475 
 
11476 
  thrift_spec = (
11477 
    None, # 0
11478 
    (1, TType.I64, 'itemId', None, None, ), # 1
11479 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11480 
  )
11481 
 
11482 
  def __init__(self, itemId=None, catalogItemId=None,):
11483 
    self.itemId = itemId
11484 
    self.catalogItemId = catalogItemId
11485 
 
11486 
  def read(self, iprot):
11487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11489 
      return
11490 
    iprot.readStructBegin()
11491 
    while True:
11492 
      (fname, ftype, fid) = iprot.readFieldBegin()
11493 
      if ftype == TType.STOP:
11494 
        break
11495 
      if fid == 1:
11496 
        if ftype == TType.I64:
11497 
          self.itemId = iprot.readI64();
11498 
        else:
11499 
          iprot.skip(ftype)
11500 
      elif fid == 2:
11501 
        if ftype == TType.I64:
11502 
          self.catalogItemId = iprot.readI64();
11503 
        else:
11504 
          iprot.skip(ftype)
11505 
      else:
11506 
        iprot.skip(ftype)
11507 
      iprot.readFieldEnd()
11508 
    iprot.readStructEnd()
11509 
 
11510 
  def write(self, oprot):
11511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11513 
      return
11514 
    oprot.writeStructBegin('deleteSimilarItem_args')
11515 
    if self.itemId is not None:
11516 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11517 
      oprot.writeI64(self.itemId)
11518 
      oprot.writeFieldEnd()
11519 
    if self.catalogItemId is not None:
11520 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11521 
      oprot.writeI64(self.catalogItemId)
11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
11541 
class deleteSimilarItem_result:
11542 
  """
11543 
  Attributes:
11544 
   - success
11545 
   - cex
11546 
  """
11547 
 
11548 
  thrift_spec = (
11549 
    (0, TType.BOOL, 'success', None, None, ), # 0
11550 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, success=None, cex=None,):
11554 
    self.success = success
11555 
    self.cex = cex
11556 
 
11557 
  def read(self, iprot):
11558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11560 
      return
11561 
    iprot.readStructBegin()
11562 
    while True:
11563 
      (fname, ftype, fid) = iprot.readFieldBegin()
11564 
      if ftype == TType.STOP:
11565 
        break
11566 
      if fid == 0:
11567 
        if ftype == TType.BOOL:
11568 
          self.success = iprot.readBool();
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      elif fid == 1:
11572 
        if ftype == TType.STRUCT:
11573 
          self.cex = CatalogServiceException()
11574 
          self.cex.read(iprot)
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
11586 
    oprot.writeStructBegin('deleteSimilarItem_result')
11587 
    if self.success is not None:
11588 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11589 
      oprot.writeBool(self.success)
11590 
      oprot.writeFieldEnd()
11591 
    if self.cex is not None:
11592 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11593 
      self.cex.write(oprot)
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
11613 
class checkSimilarItem_args:
11614 
  """
11615 
  Attributes:
11616 
   - brand
11617 
   - modelNumber
11618 
   - modelName
11619 
   - color
11620 
  """
11621 
 
11622 
  thrift_spec = (
11623 
    None, # 0
11624 
    (1, TType.STRING, 'brand', None, None, ), # 1
11625 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11626 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11627 
    (4, TType.STRING, 'color', None, None, ), # 4
11628 
  )
11629 
 
11630 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11631 
    self.brand = brand
11632 
    self.modelNumber = modelNumber
11633 
    self.modelName = modelName
11634 
    self.color = color
11635 
 
11636 
  def read(self, iprot):
11637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11639 
      return
11640 
    iprot.readStructBegin()
11641 
    while True:
11642 
      (fname, ftype, fid) = iprot.readFieldBegin()
11643 
      if ftype == TType.STOP:
11644 
        break
11645 
      if fid == 1:
11646 
        if ftype == TType.STRING:
11647 
          self.brand = iprot.readString();
11648 
        else:
11649 
          iprot.skip(ftype)
11650 
      elif fid == 2:
11651 
        if ftype == TType.STRING:
11652 
          self.modelNumber = iprot.readString();
11653 
        else:
11654 
          iprot.skip(ftype)
11655 
      elif fid == 3:
11656 
        if ftype == TType.STRING:
11657 
          self.modelName = iprot.readString();
11658 
        else:
11659 
          iprot.skip(ftype)
11660 
      elif fid == 4:
11661 
        if ftype == TType.STRING:
11662 
          self.color = iprot.readString();
11663 
        else:
11664 
          iprot.skip(ftype)
11665 
      else:
11666 
        iprot.skip(ftype)
11667 
      iprot.readFieldEnd()
11668 
    iprot.readStructEnd()
11669 
 
11670 
  def write(self, oprot):
11671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11673 
      return
11674 
    oprot.writeStructBegin('checkSimilarItem_args')
11675 
    if self.brand is not None:
11676 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11677 
      oprot.writeString(self.brand)
11678 
      oprot.writeFieldEnd()
11679 
    if self.modelNumber is not None:
11680 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11681 
      oprot.writeString(self.modelNumber)
11682 
      oprot.writeFieldEnd()
11683 
    if self.modelName is not None:
11684 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11685 
      oprot.writeString(self.modelName)
11686 
      oprot.writeFieldEnd()
11687 
    if self.color is not None:
11688 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11689 
      oprot.writeString(self.color)
11690 
      oprot.writeFieldEnd()
11691 
    oprot.writeFieldStop()
11692 
    oprot.writeStructEnd()
11693 
 
11694 
  def validate(self):
11695 
    return
11696 
 
11697 
 
11698 
  def __repr__(self):
11699 
    L = ['%s=%r' % (key, value)
11700 
      for key, value in self.__dict__.iteritems()]
11701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11702 
 
11703 
  def __eq__(self, other):
11704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11705 
 
11706 
  def __ne__(self, other):
11707 
    return not (self == other)
11708 
 
11709 
class checkSimilarItem_result:
11710 
  """
11711 
  Attributes:
11712 
   - success
11713 
  """
11714 
 
11715 
  thrift_spec = (
11716 
    (0, TType.I64, 'success', None, None, ), # 0
11717 
  )
11718 
 
11719 
  def __init__(self, success=None,):
11720 
    self.success = success
11721 
 
11722 
  def read(self, iprot):
11723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11725 
      return
11726 
    iprot.readStructBegin()
11727 
    while True:
11728 
      (fname, ftype, fid) = iprot.readFieldBegin()
11729 
      if ftype == TType.STOP:
11730 
        break
11731 
      if fid == 0:
11732 
        if ftype == TType.I64:
11733 
          self.success = iprot.readI64();
11734 
        else:
11735 
          iprot.skip(ftype)
11736 
      else:
11737 
        iprot.skip(ftype)
11738 
      iprot.readFieldEnd()
11739 
    iprot.readStructEnd()
11740 
 
11741 
  def write(self, oprot):
11742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11744 
      return
11745 
    oprot.writeStructBegin('checkSimilarItem_result')
11746 
    if self.success is not None:
11747 
      oprot.writeFieldBegin('success', TType.I64, 0)
11748 
      oprot.writeI64(self.success)
11749 
      oprot.writeFieldEnd()
11750 
    oprot.writeFieldStop()
11751 
    oprot.writeStructEnd()
11752 
 
11753 
  def validate(self):
11754 
    return
11755 
 
11756 
 
11757 
  def __repr__(self):
11758 
    L = ['%s=%r' % (key, value)
11759 
      for key, value in self.__dict__.iteritems()]
11760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11761 
 
11762 
  def __eq__(self, other):
11763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11764 
 
11765 
  def __ne__(self, other):
11766 
    return not (self == other)
11767 
 
11768 
class validateRiskyStatus_args:
11769 
  """
11770 
  Attributes:
11771 
   - itemId
11772 
  """
11773 
 
11774 
  thrift_spec = (
11775 
    None, # 0
11776 
    (1, TType.I64, 'itemId', None, None, ), # 1
11777 
  )
11778 
 
11779 
  def __init__(self, itemId=None,):
11780 
    self.itemId = itemId
11781 
 
11782 
  def read(self, iprot):
11783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11785 
      return
11786 
    iprot.readStructBegin()
11787 
    while True:
11788 
      (fname, ftype, fid) = iprot.readFieldBegin()
11789 
      if ftype == TType.STOP:
11790 
        break
11791 
      if fid == 1:
11792 
        if ftype == TType.I64:
11793 
          self.itemId = iprot.readI64();
11794 
        else:
11795 
          iprot.skip(ftype)
11796 
      else:
11797 
        iprot.skip(ftype)
11798 
      iprot.readFieldEnd()
11799 
    iprot.readStructEnd()
11800 
 
11801 
  def write(self, oprot):
11802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11804 
      return
11805 
    oprot.writeStructBegin('validateRiskyStatus_args')
11806 
    if self.itemId is not None:
11807 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11808 
      oprot.writeI64(self.itemId)
11809 
      oprot.writeFieldEnd()
11810 
    oprot.writeFieldStop()
11811 
    oprot.writeStructEnd()
11812 
 
11813 
  def validate(self):
11814 
    return
11815 
 
11816 
 
11817 
  def __repr__(self):
11818 
    L = ['%s=%r' % (key, value)
11819 
      for key, value in self.__dict__.iteritems()]
11820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11821 
 
11822 
  def __eq__(self, other):
11823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11824 
 
11825 
  def __ne__(self, other):
11826 
    return not (self == other)
11827 
 
11828 
class validateRiskyStatus_result:
11829 
 
11830 
  thrift_spec = (
11831 
  )
11832 
 
11833 
  def read(self, iprot):
11834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11836 
      return
11837 
    iprot.readStructBegin()
11838 
    while True:
11839 
      (fname, ftype, fid) = iprot.readFieldBegin()
11840 
      if ftype == TType.STOP:
11841 
        break
11842 
      else:
11843 
        iprot.skip(ftype)
11844 
      iprot.readFieldEnd()
11845 
    iprot.readStructEnd()
11846 
 
11847 
  def write(self, oprot):
11848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11850 
      return
11851 
    oprot.writeStructBegin('validateRiskyStatus_result')
11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
11855 
  def validate(self):
11856 
    return
11857 
 
11858 
 
11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
11870 
class changeItemRiskyFlag_args:
11871 
  """
11872 
  Attributes:
11873 
   - itemId
11874 
   - risky
11875 
  """
11876 
 
11877 
  thrift_spec = (
11878 
    None, # 0
11879 
    (1, TType.I64, 'itemId', None, None, ), # 1
11880 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11881 
  )
11882 
 
11883 
  def __init__(self, itemId=None, risky=None,):
11884 
    self.itemId = itemId
11885 
    self.risky = risky
11886 
 
11887 
  def read(self, iprot):
11888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11890 
      return
11891 
    iprot.readStructBegin()
11892 
    while True:
11893 
      (fname, ftype, fid) = iprot.readFieldBegin()
11894 
      if ftype == TType.STOP:
11895 
        break
11896 
      if fid == 1:
11897 
        if ftype == TType.I64:
11898 
          self.itemId = iprot.readI64();
11899 
        else:
11900 
          iprot.skip(ftype)
11901 
      elif fid == 2:
11902 
        if ftype == TType.BOOL:
11903 
          self.risky = iprot.readBool();
11904 
        else:
11905 
          iprot.skip(ftype)
11906 
      else:
11907 
        iprot.skip(ftype)
11908 
      iprot.readFieldEnd()
11909 
    iprot.readStructEnd()
11910 
 
11911 
  def write(self, oprot):
11912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11914 
      return
11915 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11916 
    if self.itemId is not None:
11917 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11918 
      oprot.writeI64(self.itemId)
11919 
      oprot.writeFieldEnd()
11920 
    if self.risky is not None:
11921 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11922 
      oprot.writeBool(self.risky)
11923 
      oprot.writeFieldEnd()
11924 
    oprot.writeFieldStop()
11925 
    oprot.writeStructEnd()
11926 
 
11927 
  def validate(self):
11928 
    return
11929 
 
11930 
 
11931 
  def __repr__(self):
11932 
    L = ['%s=%r' % (key, value)
11933 
      for key, value in self.__dict__.iteritems()]
11934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11935 
 
11936 
  def __eq__(self, other):
11937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11938 
 
11939 
  def __ne__(self, other):
11940 
    return not (self == other)
11941 
 
11942 
class changeItemRiskyFlag_result:
11943 
 
11944 
  thrift_spec = (
11945 
  )
11946 
 
11947 
  def read(self, iprot):
11948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11950 
      return
11951 
    iprot.readStructBegin()
11952 
    while True:
11953 
      (fname, ftype, fid) = iprot.readFieldBegin()
11954 
      if ftype == TType.STOP:
11955 
        break
11956 
      else:
11957 
        iprot.skip(ftype)
11958 
      iprot.readFieldEnd()
11959 
    iprot.readStructEnd()
11960 
 
11961 
  def write(self, oprot):
11962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11964 
      return
11965 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11966 
    oprot.writeFieldStop()
11967 
    oprot.writeStructEnd()
11968 
 
11969 
  def validate(self):
11970 
    return
11971 
 
11972 
 
11973 
  def __repr__(self):
11974 
    L = ['%s=%r' % (key, value)
11975 
      for key, value in self.__dict__.iteritems()]
11976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11977 
 
11978 
  def __eq__(self, other):
11979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11980 
 
11981 
  def __ne__(self, other):
11982 
    return not (self == other)
11983 
 
11984 
class getItemsByRiskyFlag_args:
11985 
 
11986 
  thrift_spec = (
11987 
  )
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 
      else:
11999 
        iprot.skip(ftype)
12000 
      iprot.readFieldEnd()
12001 
    iprot.readStructEnd()
12002 
 
12003 
  def write(self, oprot):
12004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12006 
      return
12007 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12008 
    oprot.writeFieldStop()
12009 
    oprot.writeStructEnd()
12010 
 
12011 
  def validate(self):
12012 
    return
12013 
 
12014 
 
12015 
  def __repr__(self):
12016 
    L = ['%s=%r' % (key, value)
12017 
      for key, value in self.__dict__.iteritems()]
12018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12019 
 
12020 
  def __eq__(self, other):
12021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12022 
 
12023 
  def __ne__(self, other):
12024 
    return not (self == other)
12025 
 
12026 
class getItemsByRiskyFlag_result:
12027 
  """
12028 
  Attributes:
12029 
   - success
12030 
  """
12031 
 
12032 
  thrift_spec = (
12033 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12034 
  )
12035 
 
12036 
  def __init__(self, success=None,):
12037 
    self.success = success
12038 
 
12039 
  def read(self, iprot):
12040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12042 
      return
12043 
    iprot.readStructBegin()
12044 
    while True:
12045 
      (fname, ftype, fid) = iprot.readFieldBegin()
12046 
      if ftype == TType.STOP:
12047 
        break
12048 
      if fid == 0:
12049 
        if ftype == TType.LIST:
12050 
          self.success = []
6850 kshitij.so 12051 
          (_etype189, _size186) = iprot.readListBegin()
12052 
          for _i190 in xrange(_size186):
12053 
            _elem191 = Item()
12054 
            _elem191.read(iprot)
12055 
            self.success.append(_elem191)
5944 mandeep.dh 12056 
          iprot.readListEnd()
12057 
        else:
12058 
          iprot.skip(ftype)
12059 
      else:
12060 
        iprot.skip(ftype)
12061 
      iprot.readFieldEnd()
12062 
    iprot.readStructEnd()
12063 
 
12064 
  def write(self, oprot):
12065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12067 
      return
12068 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12069 
    if self.success is not None:
12070 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12071 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12072 
      for iter192 in self.success:
12073 
        iter192.write(oprot)
5944 mandeep.dh 12074 
      oprot.writeListEnd()
12075 
      oprot.writeFieldEnd()
12076 
    oprot.writeFieldStop()
12077 
    oprot.writeStructEnd()
12078 
 
12079 
  def validate(self):
12080 
    return
12081 
 
12082 
 
12083 
  def __repr__(self):
12084 
    L = ['%s=%r' % (key, value)
12085 
      for key, value in self.__dict__.iteritems()]
12086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12087 
 
12088 
  def __eq__(self, other):
12089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12090 
 
12091 
  def __ne__(self, other):
12092 
    return not (self == other)
12093 
 
12094 
class getItemsForMasterSheet_args:
12095 
  """
12096 
  Attributes:
12097 
   - category
12098 
   - brand
12099 
  """
12100 
 
12101 
  thrift_spec = (
12102 
    None, # 0
12103 
    (1, TType.STRING, 'category', None, None, ), # 1
12104 
    (2, TType.STRING, 'brand', None, None, ), # 2
12105 
  )
12106 
 
12107 
  def __init__(self, category=None, brand=None,):
12108 
    self.category = category
12109 
    self.brand = brand
12110 
 
12111 
  def read(self, iprot):
12112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12114 
      return
12115 
    iprot.readStructBegin()
12116 
    while True:
12117 
      (fname, ftype, fid) = iprot.readFieldBegin()
12118 
      if ftype == TType.STOP:
12119 
        break
12120 
      if fid == 1:
12121 
        if ftype == TType.STRING:
12122 
          self.category = iprot.readString();
12123 
        else:
12124 
          iprot.skip(ftype)
12125 
      elif fid == 2:
12126 
        if ftype == TType.STRING:
12127 
          self.brand = iprot.readString();
12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      else:
12131 
        iprot.skip(ftype)
12132 
      iprot.readFieldEnd()
12133 
    iprot.readStructEnd()
12134 
 
12135 
  def write(self, oprot):
12136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12138 
      return
12139 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12140 
    if self.category is not None:
12141 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12142 
      oprot.writeString(self.category)
12143 
      oprot.writeFieldEnd()
12144 
    if self.brand is not None:
12145 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12146 
      oprot.writeString(self.brand)
12147 
      oprot.writeFieldEnd()
12148 
    oprot.writeFieldStop()
12149 
    oprot.writeStructEnd()
12150 
 
12151 
  def validate(self):
12152 
    return
12153 
 
12154 
 
12155 
  def __repr__(self):
12156 
    L = ['%s=%r' % (key, value)
12157 
      for key, value in self.__dict__.iteritems()]
12158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12159 
 
12160 
  def __eq__(self, other):
12161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12162 
 
12163 
  def __ne__(self, other):
12164 
    return not (self == other)
12165 
 
12166 
class getItemsForMasterSheet_result:
12167 
  """
12168 
  Attributes:
12169 
   - success
12170 
  """
12171 
 
12172 
  thrift_spec = (
12173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12174 
  )
12175 
 
12176 
  def __init__(self, success=None,):
12177 
    self.success = success
12178 
 
12179 
  def read(self, iprot):
12180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12182 
      return
12183 
    iprot.readStructBegin()
12184 
    while True:
12185 
      (fname, ftype, fid) = iprot.readFieldBegin()
12186 
      if ftype == TType.STOP:
12187 
        break
12188 
      if fid == 0:
12189 
        if ftype == TType.LIST:
12190 
          self.success = []
6850 kshitij.so 12191 
          (_etype196, _size193) = iprot.readListBegin()
12192 
          for _i197 in xrange(_size193):
12193 
            _elem198 = Item()
12194 
            _elem198.read(iprot)
12195 
            self.success.append(_elem198)
5944 mandeep.dh 12196 
          iprot.readListEnd()
12197 
        else:
12198 
          iprot.skip(ftype)
12199 
      else:
12200 
        iprot.skip(ftype)
12201 
      iprot.readFieldEnd()
12202 
    iprot.readStructEnd()
12203 
 
12204 
  def write(self, oprot):
12205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12207 
      return
12208 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12209 
    if self.success is not None:
12210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12212 
      for iter199 in self.success:
12213 
        iter199.write(oprot)
5944 mandeep.dh 12214 
      oprot.writeListEnd()
12215 
      oprot.writeFieldEnd()
12216 
    oprot.writeFieldStop()
12217 
    oprot.writeStructEnd()
12218 
 
12219 
  def validate(self):
12220 
    return
12221 
 
12222 
 
12223 
  def __repr__(self):
12224 
    L = ['%s=%r' % (key, value)
12225 
      for key, value in self.__dict__.iteritems()]
12226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12227 
 
12228 
  def __eq__(self, other):
12229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12230 
 
12231 
  def __ne__(self, other):
12232 
    return not (self == other)
12233 
 
12234 
class getSimilarItemsCatalogIds_args:
12235 
  """
12236 
  Attributes:
12237 
   - beginIndex
12238 
   - totalItems
12239 
   - itemId
12240 
  """
12241 
 
12242 
  thrift_spec = (
12243 
    None, # 0
12244 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12245 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12246 
    (3, TType.I64, 'itemId', None, None, ), # 3
12247 
  )
12248 
 
12249 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12250 
    self.beginIndex = beginIndex
12251 
    self.totalItems = totalItems
12252 
    self.itemId = itemId
12253 
 
12254 
  def read(self, iprot):
12255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12257 
      return
12258 
    iprot.readStructBegin()
12259 
    while True:
12260 
      (fname, ftype, fid) = iprot.readFieldBegin()
12261 
      if ftype == TType.STOP:
12262 
        break
12263 
      if fid == 1:
12264 
        if ftype == TType.I64:
12265 
          self.beginIndex = iprot.readI64();
12266 
        else:
12267 
          iprot.skip(ftype)
12268 
      elif fid == 2:
12269 
        if ftype == TType.I64:
12270 
          self.totalItems = iprot.readI64();
12271 
        else:
12272 
          iprot.skip(ftype)
12273 
      elif fid == 3:
12274 
        if ftype == TType.I64:
12275 
          self.itemId = iprot.readI64();
12276 
        else:
12277 
          iprot.skip(ftype)
12278 
      else:
12279 
        iprot.skip(ftype)
12280 
      iprot.readFieldEnd()
12281 
    iprot.readStructEnd()
12282 
 
12283 
  def write(self, oprot):
12284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12286 
      return
12287 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12288 
    if self.beginIndex is not None:
12289 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12290 
      oprot.writeI64(self.beginIndex)
12291 
      oprot.writeFieldEnd()
12292 
    if self.totalItems is not None:
12293 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12294 
      oprot.writeI64(self.totalItems)
12295 
      oprot.writeFieldEnd()
12296 
    if self.itemId is not None:
12297 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12298 
      oprot.writeI64(self.itemId)
12299 
      oprot.writeFieldEnd()
12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
12303 
  def validate(self):
12304 
    return
12305 
 
12306 
 
12307 
  def __repr__(self):
12308 
    L = ['%s=%r' % (key, value)
12309 
      for key, value in self.__dict__.iteritems()]
12310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12311 
 
12312 
  def __eq__(self, other):
12313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12314 
 
12315 
  def __ne__(self, other):
12316 
    return not (self == other)
12317 
 
12318 
class getSimilarItemsCatalogIds_result:
12319 
  """
12320 
  Attributes:
12321 
   - success
12322 
  """
12323 
 
12324 
  thrift_spec = (
12325 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12326 
  )
12327 
 
12328 
  def __init__(self, success=None,):
12329 
    self.success = success
12330 
 
12331 
  def read(self, iprot):
12332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12334 
      return
12335 
    iprot.readStructBegin()
12336 
    while True:
12337 
      (fname, ftype, fid) = iprot.readFieldBegin()
12338 
      if ftype == TType.STOP:
12339 
        break
12340 
      if fid == 0:
12341 
        if ftype == TType.LIST:
12342 
          self.success = []
6850 kshitij.so 12343 
          (_etype203, _size200) = iprot.readListBegin()
12344 
          for _i204 in xrange(_size200):
12345 
            _elem205 = iprot.readI64();
12346 
            self.success.append(_elem205)
5944 mandeep.dh 12347 
          iprot.readListEnd()
12348 
        else:
12349 
          iprot.skip(ftype)
12350 
      else:
12351 
        iprot.skip(ftype)
12352 
      iprot.readFieldEnd()
12353 
    iprot.readStructEnd()
12354 
 
12355 
  def write(self, oprot):
12356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12358 
      return
12359 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12360 
    if self.success is not None:
12361 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12362 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12363 
      for iter206 in self.success:
12364 
        oprot.writeI64(iter206)
5944 mandeep.dh 12365 
      oprot.writeListEnd()
12366 
      oprot.writeFieldEnd()
12367 
    oprot.writeFieldStop()
12368 
    oprot.writeStructEnd()
12369 
 
12370 
  def validate(self):
12371 
    return
12372 
 
12373 
 
12374 
  def __repr__(self):
12375 
    L = ['%s=%r' % (key, value)
12376 
      for key, value in self.__dict__.iteritems()]
12377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12378 
 
12379 
  def __eq__(self, other):
12380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12381 
 
12382 
  def __ne__(self, other):
12383 
    return not (self == other)
12384 
 
12385 
class addProductNotification_args:
12386 
  """
12387 
  Attributes:
12388 
   - itemId
12389 
   - email
12390 
  """
12391 
 
12392 
  thrift_spec = None
12393 
  def __init__(self, itemId=None, email=None,):
12394 
    self.itemId = itemId
12395 
    self.email = email
12396 
 
12397 
  def read(self, iprot):
12398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12400 
      return
12401 
    iprot.readStructBegin()
12402 
    while True:
12403 
      (fname, ftype, fid) = iprot.readFieldBegin()
12404 
      if ftype == TType.STOP:
12405 
        break
12406 
      if fid == -1:
12407 
        if ftype == TType.I64:
12408 
          self.itemId = iprot.readI64();
12409 
        else:
12410 
          iprot.skip(ftype)
12411 
      elif fid == -2:
12412 
        if ftype == TType.STRING:
12413 
          self.email = iprot.readString();
12414 
        else:
12415 
          iprot.skip(ftype)
12416 
      else:
12417 
        iprot.skip(ftype)
12418 
      iprot.readFieldEnd()
12419 
    iprot.readStructEnd()
12420 
 
12421 
  def write(self, oprot):
12422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12424 
      return
12425 
    oprot.writeStructBegin('addProductNotification_args')
12426 
    if self.email is not None:
12427 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12428 
      oprot.writeString(self.email)
12429 
      oprot.writeFieldEnd()
12430 
    if self.itemId is not None:
12431 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12432 
      oprot.writeI64(self.itemId)
12433 
      oprot.writeFieldEnd()
12434 
    oprot.writeFieldStop()
12435 
    oprot.writeStructEnd()
12436 
 
12437 
  def validate(self):
12438 
    return
12439 
 
12440 
 
12441 
  def __repr__(self):
12442 
    L = ['%s=%r' % (key, value)
12443 
      for key, value in self.__dict__.iteritems()]
12444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12445 
 
12446 
  def __eq__(self, other):
12447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12448 
 
12449 
  def __ne__(self, other):
12450 
    return not (self == other)
12451 
 
12452 
class addProductNotification_result:
12453 
  """
12454 
  Attributes:
12455 
   - success
12456 
  """
12457 
 
12458 
  thrift_spec = (
12459 
    (0, TType.BOOL, 'success', None, None, ), # 0
12460 
  )
12461 
 
12462 
  def __init__(self, success=None,):
12463 
    self.success = success
12464 
 
12465 
  def read(self, iprot):
12466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12468 
      return
12469 
    iprot.readStructBegin()
12470 
    while True:
12471 
      (fname, ftype, fid) = iprot.readFieldBegin()
12472 
      if ftype == TType.STOP:
12473 
        break
12474 
      if fid == 0:
12475 
        if ftype == TType.BOOL:
12476 
          self.success = iprot.readBool();
12477 
        else:
12478 
          iprot.skip(ftype)
12479 
      else:
12480 
        iprot.skip(ftype)
12481 
      iprot.readFieldEnd()
12482 
    iprot.readStructEnd()
12483 
 
12484 
  def write(self, oprot):
12485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12487 
      return
12488 
    oprot.writeStructBegin('addProductNotification_result')
12489 
    if self.success is not None:
12490 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12491 
      oprot.writeBool(self.success)
12492 
      oprot.writeFieldEnd()
12493 
    oprot.writeFieldStop()
12494 
    oprot.writeStructEnd()
12495 
 
12496 
  def validate(self):
12497 
    return
12498 
 
12499 
 
12500 
  def __repr__(self):
12501 
    L = ['%s=%r' % (key, value)
12502 
      for key, value in self.__dict__.iteritems()]
12503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12504 
 
12505 
  def __eq__(self, other):
12506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12507 
 
12508 
  def __ne__(self, other):
12509 
    return not (self == other)
12510 
 
12511 
class sendProductNotifications_args:
12512 
 
12513 
  thrift_spec = (
12514 
  )
12515 
 
12516 
  def read(self, iprot):
12517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12519 
      return
12520 
    iprot.readStructBegin()
12521 
    while True:
12522 
      (fname, ftype, fid) = iprot.readFieldBegin()
12523 
      if ftype == TType.STOP:
12524 
        break
12525 
      else:
12526 
        iprot.skip(ftype)
12527 
      iprot.readFieldEnd()
12528 
    iprot.readStructEnd()
12529 
 
12530 
  def write(self, oprot):
12531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12533 
      return
12534 
    oprot.writeStructBegin('sendProductNotifications_args')
12535 
    oprot.writeFieldStop()
12536 
    oprot.writeStructEnd()
12537 
 
12538 
  def validate(self):
12539 
    return
12540 
 
12541 
 
12542 
  def __repr__(self):
12543 
    L = ['%s=%r' % (key, value)
12544 
      for key, value in self.__dict__.iteritems()]
12545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12546 
 
12547 
  def __eq__(self, other):
12548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12549 
 
12550 
  def __ne__(self, other):
12551 
    return not (self == other)
12552 
 
12553 
class sendProductNotifications_result:
12554 
  """
12555 
  Attributes:
12556 
   - success
12557 
  """
12558 
 
12559 
  thrift_spec = (
12560 
    (0, TType.BOOL, 'success', None, None, ), # 0
12561 
  )
12562 
 
12563 
  def __init__(self, success=None,):
12564 
    self.success = success
12565 
 
12566 
  def read(self, iprot):
12567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12569 
      return
12570 
    iprot.readStructBegin()
12571 
    while True:
12572 
      (fname, ftype, fid) = iprot.readFieldBegin()
12573 
      if ftype == TType.STOP:
12574 
        break
12575 
      if fid == 0:
12576 
        if ftype == TType.BOOL:
12577 
          self.success = iprot.readBool();
12578 
        else:
12579 
          iprot.skip(ftype)
12580 
      else:
12581 
        iprot.skip(ftype)
12582 
      iprot.readFieldEnd()
12583 
    iprot.readStructEnd()
12584 
 
12585 
  def write(self, oprot):
12586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12588 
      return
12589 
    oprot.writeStructBegin('sendProductNotifications_result')
12590 
    if self.success is not None:
12591 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12592 
      oprot.writeBool(self.success)
12593 
      oprot.writeFieldEnd()
12594 
    oprot.writeFieldStop()
12595 
    oprot.writeStructEnd()
12596 
 
12597 
  def validate(self):
12598 
    return
12599 
 
12600 
 
12601 
  def __repr__(self):
12602 
    L = ['%s=%r' % (key, value)
12603 
      for key, value in self.__dict__.iteritems()]
12604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12605 
 
12606 
  def __eq__(self, other):
12607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12608 
 
12609 
  def __ne__(self, other):
12610 
    return not (self == other)
12611 
 
12612 
class getAllBrandsByCategory_args:
12613 
  """
12614 
  Attributes:
12615 
   - categoryId
12616 
  """
12617 
 
12618 
  thrift_spec = (
12619 
    None, # 0
12620 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12621 
  )
12622 
 
12623 
  def __init__(self, categoryId=None,):
12624 
    self.categoryId = categoryId
12625 
 
12626 
  def read(self, iprot):
12627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12629 
      return
12630 
    iprot.readStructBegin()
12631 
    while True:
12632 
      (fname, ftype, fid) = iprot.readFieldBegin()
12633 
      if ftype == TType.STOP:
12634 
        break
12635 
      if fid == 1:
12636 
        if ftype == TType.I64:
12637 
          self.categoryId = iprot.readI64();
12638 
        else:
12639 
          iprot.skip(ftype)
12640 
      else:
12641 
        iprot.skip(ftype)
12642 
      iprot.readFieldEnd()
12643 
    iprot.readStructEnd()
12644 
 
12645 
  def write(self, oprot):
12646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12648 
      return
12649 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12650 
    if self.categoryId is not None:
12651 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12652 
      oprot.writeI64(self.categoryId)
12653 
      oprot.writeFieldEnd()
12654 
    oprot.writeFieldStop()
12655 
    oprot.writeStructEnd()
12656 
 
12657 
  def validate(self):
12658 
    return
12659 
 
12660 
 
12661 
  def __repr__(self):
12662 
    L = ['%s=%r' % (key, value)
12663 
      for key, value in self.__dict__.iteritems()]
12664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12665 
 
12666 
  def __eq__(self, other):
12667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12668 
 
12669 
  def __ne__(self, other):
12670 
    return not (self == other)
12671 
 
12672 
class getAllBrandsByCategory_result:
12673 
  """
12674 
  Attributes:
12675 
   - success
12676 
  """
12677 
 
12678 
  thrift_spec = (
12679 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12680 
  )
12681 
 
12682 
  def __init__(self, success=None,):
12683 
    self.success = success
12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 0:
12695 
        if ftype == TType.LIST:
12696 
          self.success = []
6850 kshitij.so 12697 
          (_etype210, _size207) = iprot.readListBegin()
12698 
          for _i211 in xrange(_size207):
12699 
            _elem212 = iprot.readString();
12700 
            self.success.append(_elem212)
5944 mandeep.dh 12701 
          iprot.readListEnd()
12702 
        else:
12703 
          iprot.skip(ftype)
12704 
      else:
12705 
        iprot.skip(ftype)
12706 
      iprot.readFieldEnd()
12707 
    iprot.readStructEnd()
12708 
 
12709 
  def write(self, oprot):
12710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12712 
      return
12713 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12714 
    if self.success is not None:
12715 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12716 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12717 
      for iter213 in self.success:
12718 
        oprot.writeString(iter213)
5944 mandeep.dh 12719 
      oprot.writeListEnd()
12720 
      oprot.writeFieldEnd()
12721 
    oprot.writeFieldStop()
12722 
    oprot.writeStructEnd()
12723 
 
12724 
  def validate(self):
12725 
    return
12726 
 
12727 
 
12728 
  def __repr__(self):
12729 
    L = ['%s=%r' % (key, value)
12730 
      for key, value in self.__dict__.iteritems()]
12731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12732 
 
12733 
  def __eq__(self, other):
12734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12735 
 
12736 
  def __ne__(self, other):
12737 
    return not (self == other)
12738 
 
12739 
class getAllBrands_args:
12740 
 
12741 
  thrift_spec = (
12742 
  )
12743 
 
12744 
  def read(self, iprot):
12745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12747 
      return
12748 
    iprot.readStructBegin()
12749 
    while True:
12750 
      (fname, ftype, fid) = iprot.readFieldBegin()
12751 
      if ftype == TType.STOP:
12752 
        break
12753 
      else:
12754 
        iprot.skip(ftype)
12755 
      iprot.readFieldEnd()
12756 
    iprot.readStructEnd()
12757 
 
12758 
  def write(self, oprot):
12759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12761 
      return
12762 
    oprot.writeStructBegin('getAllBrands_args')
12763 
    oprot.writeFieldStop()
12764 
    oprot.writeStructEnd()
12765 
 
12766 
  def validate(self):
12767 
    return
12768 
 
12769 
 
12770 
  def __repr__(self):
12771 
    L = ['%s=%r' % (key, value)
12772 
      for key, value in self.__dict__.iteritems()]
12773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12774 
 
12775 
  def __eq__(self, other):
12776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12777 
 
12778 
  def __ne__(self, other):
12779 
    return not (self == other)
12780 
 
12781 
class getAllBrands_result:
12782 
  """
12783 
  Attributes:
12784 
   - success
12785 
  """
12786 
 
12787 
  thrift_spec = (
12788 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12789 
  )
12790 
 
12791 
  def __init__(self, success=None,):
12792 
    self.success = success
12793 
 
12794 
  def read(self, iprot):
12795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12797 
      return
12798 
    iprot.readStructBegin()
12799 
    while True:
12800 
      (fname, ftype, fid) = iprot.readFieldBegin()
12801 
      if ftype == TType.STOP:
12802 
        break
12803 
      if fid == 0:
12804 
        if ftype == TType.LIST:
12805 
          self.success = []
6850 kshitij.so 12806 
          (_etype217, _size214) = iprot.readListBegin()
12807 
          for _i218 in xrange(_size214):
12808 
            _elem219 = iprot.readString();
12809 
            self.success.append(_elem219)
5944 mandeep.dh 12810 
          iprot.readListEnd()
12811 
        else:
12812 
          iprot.skip(ftype)
12813 
      else:
12814 
        iprot.skip(ftype)
12815 
      iprot.readFieldEnd()
12816 
    iprot.readStructEnd()
12817 
 
12818 
  def write(self, oprot):
12819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12821 
      return
12822 
    oprot.writeStructBegin('getAllBrands_result')
12823 
    if self.success is not None:
12824 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12825 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12826 
      for iter220 in self.success:
12827 
        oprot.writeString(iter220)
5944 mandeep.dh 12828 
      oprot.writeListEnd()
12829 
      oprot.writeFieldEnd()
12830 
    oprot.writeFieldStop()
12831 
    oprot.writeStructEnd()
12832 
 
12833 
  def validate(self):
12834 
    return
12835 
 
12836 
 
12837 
  def __repr__(self):
12838 
    L = ['%s=%r' % (key, value)
12839 
      for key, value in self.__dict__.iteritems()]
12840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12841 
 
12842 
  def __eq__(self, other):
12843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12844 
 
12845 
  def __ne__(self, other):
12846 
    return not (self == other)
12847 
 
12848 
class getAllSources_args:
12849 
 
12850 
  thrift_spec = (
12851 
  )
12852 
 
12853 
  def read(self, iprot):
12854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12856 
      return
12857 
    iprot.readStructBegin()
12858 
    while True:
12859 
      (fname, ftype, fid) = iprot.readFieldBegin()
12860 
      if ftype == TType.STOP:
12861 
        break
12862 
      else:
12863 
        iprot.skip(ftype)
12864 
      iprot.readFieldEnd()
12865 
    iprot.readStructEnd()
12866 
 
12867 
  def write(self, oprot):
12868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12870 
      return
12871 
    oprot.writeStructBegin('getAllSources_args')
12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
12875 
  def validate(self):
12876 
    return
12877 
 
12878 
 
12879 
  def __repr__(self):
12880 
    L = ['%s=%r' % (key, value)
12881 
      for key, value in self.__dict__.iteritems()]
12882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12883 
 
12884 
  def __eq__(self, other):
12885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12886 
 
12887 
  def __ne__(self, other):
12888 
    return not (self == other)
12889 
 
12890 
class getAllSources_result:
12891 
  """
12892 
  Attributes:
12893 
   - success
12894 
  """
12895 
 
12896 
  thrift_spec = (
12897 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12898 
  )
12899 
 
12900 
  def __init__(self, success=None,):
12901 
    self.success = success
12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == 0:
12913 
        if ftype == TType.LIST:
12914 
          self.success = []
6850 kshitij.so 12915 
          (_etype224, _size221) = iprot.readListBegin()
12916 
          for _i225 in xrange(_size221):
12917 
            _elem226 = Source()
12918 
            _elem226.read(iprot)
12919 
            self.success.append(_elem226)
5944 mandeep.dh 12920 
          iprot.readListEnd()
12921 
        else:
12922 
          iprot.skip(ftype)
12923 
      else:
12924 
        iprot.skip(ftype)
12925 
      iprot.readFieldEnd()
12926 
    iprot.readStructEnd()
12927 
 
12928 
  def write(self, oprot):
12929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12931 
      return
12932 
    oprot.writeStructBegin('getAllSources_result')
12933 
    if self.success is not None:
12934 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12935 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12936 
      for iter227 in self.success:
12937 
        iter227.write(oprot)
5944 mandeep.dh 12938 
      oprot.writeListEnd()
12939 
      oprot.writeFieldEnd()
12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
12958 
class getItemPricingBySource_args:
12959 
  """
12960 
  Attributes:
12961 
   - itemId
12962 
   - sourceId
12963 
  """
12964 
 
12965 
  thrift_spec = (
12966 
    None, # 0
12967 
    (1, TType.I64, 'itemId', None, None, ), # 1
12968 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12969 
  )
12970 
 
12971 
  def __init__(self, itemId=None, sourceId=None,):
12972 
    self.itemId = itemId
12973 
    self.sourceId = sourceId
12974 
 
12975 
  def read(self, iprot):
12976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12978 
      return
12979 
    iprot.readStructBegin()
12980 
    while True:
12981 
      (fname, ftype, fid) = iprot.readFieldBegin()
12982 
      if ftype == TType.STOP:
12983 
        break
12984 
      if fid == 1:
12985 
        if ftype == TType.I64:
12986 
          self.itemId = iprot.readI64();
12987 
        else:
12988 
          iprot.skip(ftype)
12989 
      elif fid == 2:
12990 
        if ftype == TType.I64:
12991 
          self.sourceId = iprot.readI64();
12992 
        else:
12993 
          iprot.skip(ftype)
12994 
      else:
12995 
        iprot.skip(ftype)
12996 
      iprot.readFieldEnd()
12997 
    iprot.readStructEnd()
12998 
 
12999 
  def write(self, oprot):
13000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13002 
      return
13003 
    oprot.writeStructBegin('getItemPricingBySource_args')
13004 
    if self.itemId is not None:
13005 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13006 
      oprot.writeI64(self.itemId)
13007 
      oprot.writeFieldEnd()
13008 
    if self.sourceId is not None:
13009 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13010 
      oprot.writeI64(self.sourceId)
13011 
      oprot.writeFieldEnd()
13012 
    oprot.writeFieldStop()
13013 
    oprot.writeStructEnd()
13014 
 
13015 
  def validate(self):
13016 
    return
13017 
 
13018 
 
13019 
  def __repr__(self):
13020 
    L = ['%s=%r' % (key, value)
13021 
      for key, value in self.__dict__.iteritems()]
13022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13023 
 
13024 
  def __eq__(self, other):
13025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13026 
 
13027 
  def __ne__(self, other):
13028 
    return not (self == other)
13029 
 
13030 
class getItemPricingBySource_result:
13031 
  """
13032 
  Attributes:
13033 
   - success
13034 
   - cex
13035 
  """
13036 
 
13037 
  thrift_spec = (
13038 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13039 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13040 
  )
13041 
 
13042 
  def __init__(self, success=None, cex=None,):
13043 
    self.success = success
13044 
    self.cex = cex
13045 
 
13046 
  def read(self, iprot):
13047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13049 
      return
13050 
    iprot.readStructBegin()
13051 
    while True:
13052 
      (fname, ftype, fid) = iprot.readFieldBegin()
13053 
      if ftype == TType.STOP:
13054 
        break
13055 
      if fid == 0:
13056 
        if ftype == TType.STRUCT:
13057 
          self.success = SourceItemPricing()
13058 
          self.success.read(iprot)
13059 
        else:
13060 
          iprot.skip(ftype)
13061 
      elif fid == 1:
13062 
        if ftype == TType.STRUCT:
13063 
          self.cex = CatalogServiceException()
13064 
          self.cex.read(iprot)
13065 
        else:
13066 
          iprot.skip(ftype)
13067 
      else:
13068 
        iprot.skip(ftype)
13069 
      iprot.readFieldEnd()
13070 
    iprot.readStructEnd()
13071 
 
13072 
  def write(self, oprot):
13073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13075 
      return
13076 
    oprot.writeStructBegin('getItemPricingBySource_result')
13077 
    if self.success is not None:
13078 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13079 
      self.success.write(oprot)
13080 
      oprot.writeFieldEnd()
13081 
    if self.cex is not None:
13082 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13083 
      self.cex.write(oprot)
13084 
      oprot.writeFieldEnd()
13085 
    oprot.writeFieldStop()
13086 
    oprot.writeStructEnd()
13087 
 
13088 
  def validate(self):
13089 
    return
13090 
 
13091 
 
13092 
  def __repr__(self):
13093 
    L = ['%s=%r' % (key, value)
13094 
      for key, value in self.__dict__.iteritems()]
13095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13096 
 
13097 
  def __eq__(self, other):
13098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13099 
 
13100 
  def __ne__(self, other):
13101 
    return not (self == other)
13102 
 
13103 
class addSourceItemPricing_args:
13104 
  """
13105 
  Attributes:
13106 
   - sourceItemPricing
13107 
  """
13108 
 
13109 
  thrift_spec = (
13110 
    None, # 0
13111 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13112 
  )
13113 
 
13114 
  def __init__(self, sourceItemPricing=None,):
13115 
    self.sourceItemPricing = sourceItemPricing
13116 
 
13117 
  def read(self, iprot):
13118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13120 
      return
13121 
    iprot.readStructBegin()
13122 
    while True:
13123 
      (fname, ftype, fid) = iprot.readFieldBegin()
13124 
      if ftype == TType.STOP:
13125 
        break
13126 
      if fid == 1:
13127 
        if ftype == TType.STRUCT:
13128 
          self.sourceItemPricing = SourceItemPricing()
13129 
          self.sourceItemPricing.read(iprot)
13130 
        else:
13131 
          iprot.skip(ftype)
13132 
      else:
13133 
        iprot.skip(ftype)
13134 
      iprot.readFieldEnd()
13135 
    iprot.readStructEnd()
13136 
 
13137 
  def write(self, oprot):
13138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13140 
      return
13141 
    oprot.writeStructBegin('addSourceItemPricing_args')
13142 
    if self.sourceItemPricing is not None:
13143 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13144 
      self.sourceItemPricing.write(oprot)
13145 
      oprot.writeFieldEnd()
13146 
    oprot.writeFieldStop()
13147 
    oprot.writeStructEnd()
13148 
 
13149 
  def validate(self):
13150 
    return
13151 
 
13152 
 
13153 
  def __repr__(self):
13154 
    L = ['%s=%r' % (key, value)
13155 
      for key, value in self.__dict__.iteritems()]
13156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13157 
 
13158 
  def __eq__(self, other):
13159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13160 
 
13161 
  def __ne__(self, other):
13162 
    return not (self == other)
13163 
 
13164 
class addSourceItemPricing_result:
13165 
  """
13166 
  Attributes:
13167 
   - cex
13168 
  """
13169 
 
13170 
  thrift_spec = (
13171 
    None, # 0
13172 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13173 
  )
13174 
 
13175 
  def __init__(self, cex=None,):
13176 
    self.cex = cex
13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 1:
13188 
        if ftype == TType.STRUCT:
13189 
          self.cex = CatalogServiceException()
13190 
          self.cex.read(iprot)
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      else:
13194 
        iprot.skip(ftype)
13195 
      iprot.readFieldEnd()
13196 
    iprot.readStructEnd()
13197 
 
13198 
  def write(self, oprot):
13199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13201 
      return
13202 
    oprot.writeStructBegin('addSourceItemPricing_result')
13203 
    if self.cex is not None:
13204 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13205 
      self.cex.write(oprot)
13206 
      oprot.writeFieldEnd()
13207 
    oprot.writeFieldStop()
13208 
    oprot.writeStructEnd()
13209 
 
13210 
  def validate(self):
13211 
    return
13212 
 
13213 
 
13214 
  def __repr__(self):
13215 
    L = ['%s=%r' % (key, value)
13216 
      for key, value in self.__dict__.iteritems()]
13217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13218 
 
13219 
  def __eq__(self, other):
13220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13221 
 
13222 
  def __ne__(self, other):
13223 
    return not (self == other)
13224 
 
13225 
class getAllSourcePricing_args:
13226 
  """
13227 
  Attributes:
13228 
   - itemId
13229 
  """
13230 
 
13231 
  thrift_spec = (
13232 
    None, # 0
13233 
    (1, TType.I64, 'itemId', None, None, ), # 1
13234 
  )
13235 
 
13236 
  def __init__(self, itemId=None,):
13237 
    self.itemId = itemId
13238 
 
13239 
  def read(self, iprot):
13240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13242 
      return
13243 
    iprot.readStructBegin()
13244 
    while True:
13245 
      (fname, ftype, fid) = iprot.readFieldBegin()
13246 
      if ftype == TType.STOP:
13247 
        break
13248 
      if fid == 1:
13249 
        if ftype == TType.I64:
13250 
          self.itemId = iprot.readI64();
13251 
        else:
13252 
          iprot.skip(ftype)
13253 
      else:
13254 
        iprot.skip(ftype)
13255 
      iprot.readFieldEnd()
13256 
    iprot.readStructEnd()
13257 
 
13258 
  def write(self, oprot):
13259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13261 
      return
13262 
    oprot.writeStructBegin('getAllSourcePricing_args')
13263 
    if self.itemId is not None:
13264 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13265 
      oprot.writeI64(self.itemId)
13266 
      oprot.writeFieldEnd()
13267 
    oprot.writeFieldStop()
13268 
    oprot.writeStructEnd()
13269 
 
13270 
  def validate(self):
13271 
    return
13272 
 
13273 
 
13274 
  def __repr__(self):
13275 
    L = ['%s=%r' % (key, value)
13276 
      for key, value in self.__dict__.iteritems()]
13277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13278 
 
13279 
  def __eq__(self, other):
13280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13281 
 
13282 
  def __ne__(self, other):
13283 
    return not (self == other)
13284 
 
13285 
class getAllSourcePricing_result:
13286 
  """
13287 
  Attributes:
13288 
   - success
13289 
   - cex
13290 
  """
13291 
 
13292 
  thrift_spec = (
13293 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13294 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13295 
  )
13296 
 
13297 
  def __init__(self, success=None, cex=None,):
13298 
    self.success = success
13299 
    self.cex = cex
13300 
 
13301 
  def read(self, iprot):
13302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13304 
      return
13305 
    iprot.readStructBegin()
13306 
    while True:
13307 
      (fname, ftype, fid) = iprot.readFieldBegin()
13308 
      if ftype == TType.STOP:
13309 
        break
13310 
      if fid == 0:
13311 
        if ftype == TType.LIST:
13312 
          self.success = []
6850 kshitij.so 13313 
          (_etype231, _size228) = iprot.readListBegin()
13314 
          for _i232 in xrange(_size228):
13315 
            _elem233 = SourceItemPricing()
13316 
            _elem233.read(iprot)
13317 
            self.success.append(_elem233)
5944 mandeep.dh 13318 
          iprot.readListEnd()
13319 
        else:
13320 
          iprot.skip(ftype)
13321 
      elif fid == 1:
13322 
        if ftype == TType.STRUCT:
13323 
          self.cex = CatalogServiceException()
13324 
          self.cex.read(iprot)
13325 
        else:
13326 
          iprot.skip(ftype)
13327 
      else:
13328 
        iprot.skip(ftype)
13329 
      iprot.readFieldEnd()
13330 
    iprot.readStructEnd()
13331 
 
13332 
  def write(self, oprot):
13333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13335 
      return
13336 
    oprot.writeStructBegin('getAllSourcePricing_result')
13337 
    if self.success is not None:
13338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13340 
      for iter234 in self.success:
13341 
        iter234.write(oprot)
5944 mandeep.dh 13342 
      oprot.writeListEnd()
13343 
      oprot.writeFieldEnd()
13344 
    if self.cex is not None:
13345 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13346 
      self.cex.write(oprot)
13347 
      oprot.writeFieldEnd()
13348 
    oprot.writeFieldStop()
13349 
    oprot.writeStructEnd()
13350 
 
13351 
  def validate(self):
13352 
    return
13353 
 
13354 
 
13355 
  def __repr__(self):
13356 
    L = ['%s=%r' % (key, value)
13357 
      for key, value in self.__dict__.iteritems()]
13358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13359 
 
13360 
  def __eq__(self, other):
13361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13362 
 
13363 
  def __ne__(self, other):
13364 
    return not (self == other)
13365 
 
13366 
class getItemForSource_args:
13367 
  """
13368 
  Attributes:
13369 
   - item_id
13370 
   - sourceId
13371 
  """
13372 
 
13373 
  thrift_spec = (
13374 
    None, # 0
13375 
    (1, TType.I64, 'item_id', None, None, ), # 1
13376 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13377 
  )
13378 
 
13379 
  def __init__(self, item_id=None, sourceId=None,):
13380 
    self.item_id = item_id
13381 
    self.sourceId = sourceId
13382 
 
13383 
  def read(self, iprot):
13384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13386 
      return
13387 
    iprot.readStructBegin()
13388 
    while True:
13389 
      (fname, ftype, fid) = iprot.readFieldBegin()
13390 
      if ftype == TType.STOP:
13391 
        break
13392 
      if fid == 1:
13393 
        if ftype == TType.I64:
13394 
          self.item_id = iprot.readI64();
13395 
        else:
13396 
          iprot.skip(ftype)
13397 
      elif fid == 2:
13398 
        if ftype == TType.I64:
13399 
          self.sourceId = iprot.readI64();
13400 
        else:
13401 
          iprot.skip(ftype)
13402 
      else:
13403 
        iprot.skip(ftype)
13404 
      iprot.readFieldEnd()
13405 
    iprot.readStructEnd()
13406 
 
13407 
  def write(self, oprot):
13408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13410 
      return
13411 
    oprot.writeStructBegin('getItemForSource_args')
13412 
    if self.item_id is not None:
13413 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13414 
      oprot.writeI64(self.item_id)
13415 
      oprot.writeFieldEnd()
13416 
    if self.sourceId is not None:
13417 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13418 
      oprot.writeI64(self.sourceId)
13419 
      oprot.writeFieldEnd()
13420 
    oprot.writeFieldStop()
13421 
    oprot.writeStructEnd()
13422 
 
13423 
  def validate(self):
13424 
    return
13425 
 
13426 
 
13427 
  def __repr__(self):
13428 
    L = ['%s=%r' % (key, value)
13429 
      for key, value in self.__dict__.iteritems()]
13430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13431 
 
13432 
  def __eq__(self, other):
13433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13434 
 
13435 
  def __ne__(self, other):
13436 
    return not (self == other)
13437 
 
13438 
class getItemForSource_result:
13439 
  """
13440 
  Attributes:
13441 
   - success
13442 
   - cex
13443 
  """
13444 
 
13445 
  thrift_spec = (
13446 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13447 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13448 
  )
13449 
 
13450 
  def __init__(self, success=None, cex=None,):
13451 
    self.success = success
13452 
    self.cex = cex
13453 
 
13454 
  def read(self, iprot):
13455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13457 
      return
13458 
    iprot.readStructBegin()
13459 
    while True:
13460 
      (fname, ftype, fid) = iprot.readFieldBegin()
13461 
      if ftype == TType.STOP:
13462 
        break
13463 
      if fid == 0:
13464 
        if ftype == TType.STRUCT:
13465 
          self.success = Item()
13466 
          self.success.read(iprot)
13467 
        else:
13468 
          iprot.skip(ftype)
13469 
      elif fid == 1:
13470 
        if ftype == TType.STRUCT:
13471 
          self.cex = CatalogServiceException()
13472 
          self.cex.read(iprot)
13473 
        else:
13474 
          iprot.skip(ftype)
13475 
      else:
13476 
        iprot.skip(ftype)
13477 
      iprot.readFieldEnd()
13478 
    iprot.readStructEnd()
13479 
 
13480 
  def write(self, oprot):
13481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13483 
      return
13484 
    oprot.writeStructBegin('getItemForSource_result')
13485 
    if self.success is not None:
13486 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13487 
      self.success.write(oprot)
13488 
      oprot.writeFieldEnd()
13489 
    if self.cex is not None:
13490 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13491 
      self.cex.write(oprot)
13492 
      oprot.writeFieldEnd()
13493 
    oprot.writeFieldStop()
13494 
    oprot.writeStructEnd()
13495 
 
13496 
  def validate(self):
13497 
    return
13498 
 
13499 
 
13500 
  def __repr__(self):
13501 
    L = ['%s=%r' % (key, value)
13502 
      for key, value in self.__dict__.iteritems()]
13503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13504 
 
13505 
  def __eq__(self, other):
13506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13507 
 
13508 
  def __ne__(self, other):
13509 
    return not (self == other)
13510 
 
13511 
class searchItemsInRange_args:
13512 
  """
13513 
  Attributes:
13514 
   - searchTerms
13515 
   - offset
13516 
   - limit
13517 
  """
13518 
 
13519 
  thrift_spec = (
13520 
    None, # 0
13521 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13522 
    (2, TType.I64, 'offset', None, None, ), # 2
13523 
    (3, TType.I64, 'limit', None, None, ), # 3
13524 
  )
13525 
 
13526 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13527 
    self.searchTerms = searchTerms
13528 
    self.offset = offset
13529 
    self.limit = limit
13530 
 
13531 
  def read(self, iprot):
13532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13534 
      return
13535 
    iprot.readStructBegin()
13536 
    while True:
13537 
      (fname, ftype, fid) = iprot.readFieldBegin()
13538 
      if ftype == TType.STOP:
13539 
        break
13540 
      if fid == 1:
13541 
        if ftype == TType.LIST:
13542 
          self.searchTerms = []
6850 kshitij.so 13543 
          (_etype238, _size235) = iprot.readListBegin()
13544 
          for _i239 in xrange(_size235):
13545 
            _elem240 = iprot.readString();
13546 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13547 
          iprot.readListEnd()
13548 
        else:
13549 
          iprot.skip(ftype)
13550 
      elif fid == 2:
13551 
        if ftype == TType.I64:
13552 
          self.offset = iprot.readI64();
13553 
        else:
13554 
          iprot.skip(ftype)
13555 
      elif fid == 3:
13556 
        if ftype == TType.I64:
13557 
          self.limit = iprot.readI64();
13558 
        else:
13559 
          iprot.skip(ftype)
13560 
      else:
13561 
        iprot.skip(ftype)
13562 
      iprot.readFieldEnd()
13563 
    iprot.readStructEnd()
13564 
 
13565 
  def write(self, oprot):
13566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13568 
      return
13569 
    oprot.writeStructBegin('searchItemsInRange_args')
13570 
    if self.searchTerms is not None:
13571 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13572 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13573 
      for iter241 in self.searchTerms:
13574 
        oprot.writeString(iter241)
5944 mandeep.dh 13575 
      oprot.writeListEnd()
13576 
      oprot.writeFieldEnd()
13577 
    if self.offset is not None:
13578 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13579 
      oprot.writeI64(self.offset)
13580 
      oprot.writeFieldEnd()
13581 
    if self.limit is not None:
13582 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13583 
      oprot.writeI64(self.limit)
13584 
      oprot.writeFieldEnd()
13585 
    oprot.writeFieldStop()
13586 
    oprot.writeStructEnd()
13587 
 
13588 
  def validate(self):
13589 
    return
13590 
 
13591 
 
13592 
  def __repr__(self):
13593 
    L = ['%s=%r' % (key, value)
13594 
      for key, value in self.__dict__.iteritems()]
13595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13596 
 
13597 
  def __eq__(self, other):
13598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13599 
 
13600 
  def __ne__(self, other):
13601 
    return not (self == other)
13602 
 
13603 
class searchItemsInRange_result:
13604 
  """
13605 
  Attributes:
13606 
   - success
13607 
  """
13608 
 
13609 
  thrift_spec = (
13610 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13611 
  )
13612 
 
13613 
  def __init__(self, success=None,):
13614 
    self.success = success
13615 
 
13616 
  def read(self, iprot):
13617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13619 
      return
13620 
    iprot.readStructBegin()
13621 
    while True:
13622 
      (fname, ftype, fid) = iprot.readFieldBegin()
13623 
      if ftype == TType.STOP:
13624 
        break
13625 
      if fid == 0:
13626 
        if ftype == TType.LIST:
13627 
          self.success = []
6850 kshitij.so 13628 
          (_etype245, _size242) = iprot.readListBegin()
13629 
          for _i246 in xrange(_size242):
13630 
            _elem247 = Item()
13631 
            _elem247.read(iprot)
13632 
            self.success.append(_elem247)
5944 mandeep.dh 13633 
          iprot.readListEnd()
13634 
        else:
13635 
          iprot.skip(ftype)
13636 
      else:
13637 
        iprot.skip(ftype)
13638 
      iprot.readFieldEnd()
13639 
    iprot.readStructEnd()
13640 
 
13641 
  def write(self, oprot):
13642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13644 
      return
13645 
    oprot.writeStructBegin('searchItemsInRange_result')
13646 
    if self.success is not None:
13647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13649 
      for iter248 in self.success:
13650 
        iter248.write(oprot)
5944 mandeep.dh 13651 
      oprot.writeListEnd()
13652 
      oprot.writeFieldEnd()
13653 
    oprot.writeFieldStop()
13654 
    oprot.writeStructEnd()
13655 
 
13656 
  def validate(self):
13657 
    return
13658 
 
13659 
 
13660 
  def __repr__(self):
13661 
    L = ['%s=%r' % (key, value)
13662 
      for key, value in self.__dict__.iteritems()]
13663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13664 
 
13665 
  def __eq__(self, other):
13666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13667 
 
13668 
  def __ne__(self, other):
13669 
    return not (self == other)
13670 
 
13671 
class getSearchResultCount_args:
13672 
  """
13673 
  Attributes:
13674 
   - searchTerms
13675 
  """
13676 
 
13677 
  thrift_spec = (
13678 
    None, # 0
13679 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13680 
  )
13681 
 
13682 
  def __init__(self, searchTerms=None,):
13683 
    self.searchTerms = searchTerms
13684 
 
13685 
  def read(self, iprot):
13686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13688 
      return
13689 
    iprot.readStructBegin()
13690 
    while True:
13691 
      (fname, ftype, fid) = iprot.readFieldBegin()
13692 
      if ftype == TType.STOP:
13693 
        break
13694 
      if fid == 1:
13695 
        if ftype == TType.LIST:
13696 
          self.searchTerms = []
6850 kshitij.so 13697 
          (_etype252, _size249) = iprot.readListBegin()
13698 
          for _i253 in xrange(_size249):
13699 
            _elem254 = iprot.readString();
13700 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13701 
          iprot.readListEnd()
13702 
        else:
13703 
          iprot.skip(ftype)
13704 
      else:
13705 
        iprot.skip(ftype)
13706 
      iprot.readFieldEnd()
13707 
    iprot.readStructEnd()
13708 
 
13709 
  def write(self, oprot):
13710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13712 
      return
13713 
    oprot.writeStructBegin('getSearchResultCount_args')
13714 
    if self.searchTerms is not None:
13715 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13716 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13717 
      for iter255 in self.searchTerms:
13718 
        oprot.writeString(iter255)
5944 mandeep.dh 13719 
      oprot.writeListEnd()
13720 
      oprot.writeFieldEnd()
13721 
    oprot.writeFieldStop()
13722 
    oprot.writeStructEnd()
13723 
 
13724 
  def validate(self):
13725 
    return
13726 
 
13727 
 
13728 
  def __repr__(self):
13729 
    L = ['%s=%r' % (key, value)
13730 
      for key, value in self.__dict__.iteritems()]
13731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13732 
 
13733 
  def __eq__(self, other):
13734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13735 
 
13736 
  def __ne__(self, other):
13737 
    return not (self == other)
13738 
 
13739 
class getSearchResultCount_result:
13740 
  """
13741 
  Attributes:
13742 
   - success
13743 
  """
13744 
 
13745 
  thrift_spec = (
13746 
    (0, TType.I32, 'success', None, None, ), # 0
13747 
  )
13748 
 
13749 
  def __init__(self, success=None,):
13750 
    self.success = success
13751 
 
13752 
  def read(self, iprot):
13753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13755 
      return
13756 
    iprot.readStructBegin()
13757 
    while True:
13758 
      (fname, ftype, fid) = iprot.readFieldBegin()
13759 
      if ftype == TType.STOP:
13760 
        break
13761 
      if fid == 0:
13762 
        if ftype == TType.I32:
13763 
          self.success = iprot.readI32();
13764 
        else:
13765 
          iprot.skip(ftype)
13766 
      else:
13767 
        iprot.skip(ftype)
13768 
      iprot.readFieldEnd()
13769 
    iprot.readStructEnd()
13770 
 
13771 
  def write(self, oprot):
13772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13774 
      return
13775 
    oprot.writeStructBegin('getSearchResultCount_result')
13776 
    if self.success is not None:
13777 
      oprot.writeFieldBegin('success', TType.I32, 0)
13778 
      oprot.writeI32(self.success)
13779 
      oprot.writeFieldEnd()
13780 
    oprot.writeFieldStop()
13781 
    oprot.writeStructEnd()
13782 
 
13783 
  def validate(self):
13784 
    return
13785 
 
13786 
 
13787 
  def __repr__(self):
13788 
    L = ['%s=%r' % (key, value)
13789 
      for key, value in self.__dict__.iteritems()]
13790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13791 
 
13792 
  def __eq__(self, other):
13793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13794 
 
13795 
  def __ne__(self, other):
13796 
    return not (self == other)
13797 
 
13798 
class getProductNotifications_args:
13799 
  """
13800 
  Attributes:
13801 
   - startDateTime
13802 
  """
13803 
 
13804 
  thrift_spec = (
13805 
    None, # 0
13806 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13807 
  )
13808 
 
13809 
  def __init__(self, startDateTime=None,):
13810 
    self.startDateTime = startDateTime
13811 
 
13812 
  def read(self, iprot):
13813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13815 
      return
13816 
    iprot.readStructBegin()
13817 
    while True:
13818 
      (fname, ftype, fid) = iprot.readFieldBegin()
13819 
      if ftype == TType.STOP:
13820 
        break
13821 
      if fid == 1:
13822 
        if ftype == TType.I64:
13823 
          self.startDateTime = iprot.readI64();
13824 
        else:
13825 
          iprot.skip(ftype)
13826 
      else:
13827 
        iprot.skip(ftype)
13828 
      iprot.readFieldEnd()
13829 
    iprot.readStructEnd()
13830 
 
13831 
  def write(self, oprot):
13832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13834 
      return
13835 
    oprot.writeStructBegin('getProductNotifications_args')
13836 
    if self.startDateTime is not None:
13837 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13838 
      oprot.writeI64(self.startDateTime)
13839 
      oprot.writeFieldEnd()
13840 
    oprot.writeFieldStop()
13841 
    oprot.writeStructEnd()
13842 
 
13843 
  def validate(self):
13844 
    return
13845 
 
13846 
 
13847 
  def __repr__(self):
13848 
    L = ['%s=%r' % (key, value)
13849 
      for key, value in self.__dict__.iteritems()]
13850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13851 
 
13852 
  def __eq__(self, other):
13853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13854 
 
13855 
  def __ne__(self, other):
13856 
    return not (self == other)
13857 
 
13858 
class getProductNotifications_result:
13859 
  """
13860 
  Attributes:
13861 
   - success
13862 
  """
13863 
 
13864 
  thrift_spec = (
13865 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13866 
  )
13867 
 
13868 
  def __init__(self, success=None,):
13869 
    self.success = success
13870 
 
13871 
  def read(self, iprot):
13872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13874 
      return
13875 
    iprot.readStructBegin()
13876 
    while True:
13877 
      (fname, ftype, fid) = iprot.readFieldBegin()
13878 
      if ftype == TType.STOP:
13879 
        break
13880 
      if fid == 0:
13881 
        if ftype == TType.LIST:
13882 
          self.success = []
6850 kshitij.so 13883 
          (_etype259, _size256) = iprot.readListBegin()
13884 
          for _i260 in xrange(_size256):
13885 
            _elem261 = ProductNotificationRequest()
13886 
            _elem261.read(iprot)
13887 
            self.success.append(_elem261)
5944 mandeep.dh 13888 
          iprot.readListEnd()
13889 
        else:
13890 
          iprot.skip(ftype)
13891 
      else:
13892 
        iprot.skip(ftype)
13893 
      iprot.readFieldEnd()
13894 
    iprot.readStructEnd()
13895 
 
13896 
  def write(self, oprot):
13897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13899 
      return
13900 
    oprot.writeStructBegin('getProductNotifications_result')
13901 
    if self.success is not None:
13902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13904 
      for iter262 in self.success:
13905 
        iter262.write(oprot)
5944 mandeep.dh 13906 
      oprot.writeListEnd()
13907 
      oprot.writeFieldEnd()
13908 
    oprot.writeFieldStop()
13909 
    oprot.writeStructEnd()
13910 
 
13911 
  def validate(self):
13912 
    return
13913 
 
13914 
 
13915 
  def __repr__(self):
13916 
    L = ['%s=%r' % (key, value)
13917 
      for key, value in self.__dict__.iteritems()]
13918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13919 
 
13920 
  def __eq__(self, other):
13921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13922 
 
13923 
  def __ne__(self, other):
13924 
    return not (self == other)
13925 
 
13926 
class getProductNotificationRequestCount_args:
13927 
  """
13928 
  Attributes:
13929 
   - startDateTime
13930 
  """
13931 
 
13932 
  thrift_spec = (
13933 
    None, # 0
13934 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13935 
  )
13936 
 
13937 
  def __init__(self, startDateTime=None,):
13938 
    self.startDateTime = startDateTime
13939 
 
13940 
  def read(self, iprot):
13941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13943 
      return
13944 
    iprot.readStructBegin()
13945 
    while True:
13946 
      (fname, ftype, fid) = iprot.readFieldBegin()
13947 
      if ftype == TType.STOP:
13948 
        break
13949 
      if fid == 1:
13950 
        if ftype == TType.I64:
13951 
          self.startDateTime = iprot.readI64();
13952 
        else:
13953 
          iprot.skip(ftype)
13954 
      else:
13955 
        iprot.skip(ftype)
13956 
      iprot.readFieldEnd()
13957 
    iprot.readStructEnd()
13958 
 
13959 
  def write(self, oprot):
13960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13962 
      return
13963 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13964 
    if self.startDateTime is not None:
13965 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13966 
      oprot.writeI64(self.startDateTime)
13967 
      oprot.writeFieldEnd()
13968 
    oprot.writeFieldStop()
13969 
    oprot.writeStructEnd()
13970 
 
13971 
  def validate(self):
13972 
    return
13973 
 
13974 
 
13975 
  def __repr__(self):
13976 
    L = ['%s=%r' % (key, value)
13977 
      for key, value in self.__dict__.iteritems()]
13978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13979 
 
13980 
  def __eq__(self, other):
13981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13982 
 
13983 
  def __ne__(self, other):
13984 
    return not (self == other)
13985 
 
13986 
class getProductNotificationRequestCount_result:
13987 
  """
13988 
  Attributes:
13989 
   - success
13990 
  """
13991 
 
13992 
  thrift_spec = (
13993 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13994 
  )
13995 
 
13996 
  def __init__(self, success=None,):
13997 
    self.success = success
13998 
 
13999 
  def read(self, iprot):
14000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14002 
      return
14003 
    iprot.readStructBegin()
14004 
    while True:
14005 
      (fname, ftype, fid) = iprot.readFieldBegin()
14006 
      if ftype == TType.STOP:
14007 
        break
14008 
      if fid == 0:
14009 
        if ftype == TType.LIST:
14010 
          self.success = []
6850 kshitij.so 14011 
          (_etype266, _size263) = iprot.readListBegin()
14012 
          for _i267 in xrange(_size263):
14013 
            _elem268 = ProductNotificationRequestCount()
14014 
            _elem268.read(iprot)
14015 
            self.success.append(_elem268)
5944 mandeep.dh 14016 
          iprot.readListEnd()
14017 
        else:
14018 
          iprot.skip(ftype)
14019 
      else:
14020 
        iprot.skip(ftype)
14021 
      iprot.readFieldEnd()
14022 
    iprot.readStructEnd()
14023 
 
14024 
  def write(self, oprot):
14025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14027 
      return
14028 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14029 
    if self.success is not None:
14030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 14032 
      for iter269 in self.success:
14033 
        iter269.write(oprot)
5944 mandeep.dh 14034 
      oprot.writeListEnd()
14035 
      oprot.writeFieldEnd()
14036 
    oprot.writeFieldStop()
14037 
    oprot.writeStructEnd()
14038 
 
14039 
  def validate(self):
14040 
    return
14041 
 
14042 
 
14043 
  def __repr__(self):
14044 
    L = ['%s=%r' % (key, value)
14045 
      for key, value in self.__dict__.iteritems()]
14046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14047 
 
14048 
  def __eq__(self, other):
14049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14050 
 
14051 
  def __ne__(self, other):
14052 
    return not (self == other)
14053 
 
14054 
class addAuthorizationLog_args:
14055 
  """
14056 
  Attributes:
14057 
   - itemId
14058 
   - username
14059 
   - reason
14060 
  """
14061 
 
14062 
  thrift_spec = (
14063 
    None, # 0
14064 
    (1, TType.I64, 'itemId', None, None, ), # 1
14065 
    (2, TType.STRING, 'username', None, None, ), # 2
14066 
    (3, TType.STRING, 'reason', None, None, ), # 3
14067 
  )
14068 
 
14069 
  def __init__(self, itemId=None, username=None, reason=None,):
14070 
    self.itemId = itemId
14071 
    self.username = username
14072 
    self.reason = reason
14073 
 
14074 
  def read(self, iprot):
14075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14077 
      return
14078 
    iprot.readStructBegin()
14079 
    while True:
14080 
      (fname, ftype, fid) = iprot.readFieldBegin()
14081 
      if ftype == TType.STOP:
14082 
        break
14083 
      if fid == 1:
14084 
        if ftype == TType.I64:
14085 
          self.itemId = iprot.readI64();
14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      elif fid == 2:
14089 
        if ftype == TType.STRING:
14090 
          self.username = iprot.readString();
14091 
        else:
14092 
          iprot.skip(ftype)
14093 
      elif fid == 3:
14094 
        if ftype == TType.STRING:
14095 
          self.reason = iprot.readString();
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('addAuthorizationLog_args')
14108 
    if self.itemId is not None:
14109 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14110 
      oprot.writeI64(self.itemId)
14111 
      oprot.writeFieldEnd()
14112 
    if self.username is not None:
14113 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14114 
      oprot.writeString(self.username)
14115 
      oprot.writeFieldEnd()
14116 
    if self.reason is not None:
14117 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14118 
      oprot.writeString(self.reason)
14119 
      oprot.writeFieldEnd()
14120 
    oprot.writeFieldStop()
14121 
    oprot.writeStructEnd()
14122 
 
14123 
  def validate(self):
14124 
    return
14125 
 
14126 
 
14127 
  def __repr__(self):
14128 
    L = ['%s=%r' % (key, value)
14129 
      for key, value in self.__dict__.iteritems()]
14130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14131 
 
14132 
  def __eq__(self, other):
14133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14134 
 
14135 
  def __ne__(self, other):
14136 
    return not (self == other)
14137 
 
14138 
class addAuthorizationLog_result:
14139 
  """
14140 
  Attributes:
14141 
   - success
14142 
   - cex
14143 
  """
14144 
 
14145 
  thrift_spec = (
14146 
    (0, TType.BOOL, 'success', None, None, ), # 0
14147 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14148 
  )
14149 
 
14150 
  def __init__(self, success=None, cex=None,):
14151 
    self.success = success
14152 
    self.cex = cex
14153 
 
14154 
  def read(self, iprot):
14155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14157 
      return
14158 
    iprot.readStructBegin()
14159 
    while True:
14160 
      (fname, ftype, fid) = iprot.readFieldBegin()
14161 
      if ftype == TType.STOP:
14162 
        break
14163 
      if fid == 0:
14164 
        if ftype == TType.BOOL:
14165 
          self.success = iprot.readBool();
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      elif fid == 1:
14169 
        if ftype == TType.STRUCT:
14170 
          self.cex = CatalogServiceException()
14171 
          self.cex.read(iprot)
14172 
        else:
14173 
          iprot.skip(ftype)
14174 
      else:
14175 
        iprot.skip(ftype)
14176 
      iprot.readFieldEnd()
14177 
    iprot.readStructEnd()
14178 
 
14179 
  def write(self, oprot):
14180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14182 
      return
14183 
    oprot.writeStructBegin('addAuthorizationLog_result')
14184 
    if self.success is not None:
14185 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14186 
      oprot.writeBool(self.success)
14187 
      oprot.writeFieldEnd()
14188 
    if self.cex is not None:
14189 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14190 
      self.cex.write(oprot)
14191 
      oprot.writeFieldEnd()
14192 
    oprot.writeFieldStop()
14193 
    oprot.writeStructEnd()
14194 
 
14195 
  def validate(self):
14196 
    return
14197 
 
14198 
 
14199 
  def __repr__(self):
14200 
    L = ['%s=%r' % (key, value)
14201 
      for key, value in self.__dict__.iteritems()]
14202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14203 
 
14204 
  def __eq__(self, other):
14205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14206 
 
14207 
  def __ne__(self, other):
14208 
    return not (self == other)
14209 
 
14210 
class addupdateVoucherForItem_args:
14211 
  """
14212 
  Attributes:
14213 
   - catalog_item_id
14214 
   - voucherType
14215 
   - voucherAmount
14216 
  """
14217 
 
14218 
  thrift_spec = (
14219 
    None, # 0
14220 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14221 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14222 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14223 
  )
14224 
 
14225 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14226 
    self.catalog_item_id = catalog_item_id
14227 
    self.voucherType = voucherType
14228 
    self.voucherAmount = voucherAmount
14229 
 
14230 
  def read(self, iprot):
14231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14233 
      return
14234 
    iprot.readStructBegin()
14235 
    while True:
14236 
      (fname, ftype, fid) = iprot.readFieldBegin()
14237 
      if ftype == TType.STOP:
14238 
        break
14239 
      if fid == 1:
14240 
        if ftype == TType.I64:
14241 
          self.catalog_item_id = iprot.readI64();
14242 
        else:
14243 
          iprot.skip(ftype)
14244 
      elif fid == 2:
14245 
        if ftype == TType.I64:
14246 
          self.voucherType = iprot.readI64();
14247 
        else:
14248 
          iprot.skip(ftype)
14249 
      elif fid == 3:
14250 
        if ftype == TType.I64:
14251 
          self.voucherAmount = iprot.readI64();
14252 
        else:
14253 
          iprot.skip(ftype)
14254 
      else:
14255 
        iprot.skip(ftype)
14256 
      iprot.readFieldEnd()
14257 
    iprot.readStructEnd()
14258 
 
14259 
  def write(self, oprot):
14260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14262 
      return
14263 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14264 
    if self.catalog_item_id is not None:
14265 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14266 
      oprot.writeI64(self.catalog_item_id)
14267 
      oprot.writeFieldEnd()
14268 
    if self.voucherType is not None:
14269 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14270 
      oprot.writeI64(self.voucherType)
14271 
      oprot.writeFieldEnd()
14272 
    if self.voucherAmount is not None:
14273 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14274 
      oprot.writeI64(self.voucherAmount)
14275 
      oprot.writeFieldEnd()
14276 
    oprot.writeFieldStop()
14277 
    oprot.writeStructEnd()
14278 
 
14279 
  def validate(self):
14280 
    return
14281 
 
14282 
 
14283 
  def __repr__(self):
14284 
    L = ['%s=%r' % (key, value)
14285 
      for key, value in self.__dict__.iteritems()]
14286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14287 
 
14288 
  def __eq__(self, other):
14289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14290 
 
14291 
  def __ne__(self, other):
14292 
    return not (self == other)
14293 
 
14294 
class addupdateVoucherForItem_result:
14295 
  """
14296 
  Attributes:
14297 
   - success
14298 
   - cex
14299 
  """
14300 
 
14301 
  thrift_spec = (
14302 
    (0, TType.BOOL, 'success', None, None, ), # 0
14303 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14304 
  )
14305 
 
14306 
  def __init__(self, success=None, cex=None,):
14307 
    self.success = success
14308 
    self.cex = cex
14309 
 
14310 
  def read(self, iprot):
14311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14313 
      return
14314 
    iprot.readStructBegin()
14315 
    while True:
14316 
      (fname, ftype, fid) = iprot.readFieldBegin()
14317 
      if ftype == TType.STOP:
14318 
        break
14319 
      if fid == 0:
14320 
        if ftype == TType.BOOL:
14321 
          self.success = iprot.readBool();
14322 
        else:
14323 
          iprot.skip(ftype)
14324 
      elif fid == 1:
14325 
        if ftype == TType.STRUCT:
14326 
          self.cex = CatalogServiceException()
14327 
          self.cex.read(iprot)
14328 
        else:
14329 
          iprot.skip(ftype)
14330 
      else:
14331 
        iprot.skip(ftype)
14332 
      iprot.readFieldEnd()
14333 
    iprot.readStructEnd()
14334 
 
14335 
  def write(self, oprot):
14336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14338 
      return
14339 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14340 
    if self.success is not None:
14341 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14342 
      oprot.writeBool(self.success)
14343 
      oprot.writeFieldEnd()
14344 
    if self.cex is not None:
14345 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14346 
      self.cex.write(oprot)
14347 
      oprot.writeFieldEnd()
14348 
    oprot.writeFieldStop()
14349 
    oprot.writeStructEnd()
14350 
 
14351 
  def validate(self):
14352 
    return
14353 
 
14354 
 
14355 
  def __repr__(self):
14356 
    L = ['%s=%r' % (key, value)
14357 
      for key, value in self.__dict__.iteritems()]
14358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14359 
 
14360 
  def __eq__(self, other):
14361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14362 
 
14363 
  def __ne__(self, other):
14364 
    return not (self == other)
14365 
 
14366 
class deleteVoucherForItem_args:
14367 
  """
14368 
  Attributes:
14369 
   - catalog_item_id
14370 
   - voucherType
14371 
  """
14372 
 
14373 
  thrift_spec = (
14374 
    None, # 0
14375 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14376 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14377 
  )
14378 
 
14379 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14380 
    self.catalog_item_id = catalog_item_id
14381 
    self.voucherType = voucherType
14382 
 
14383 
  def read(self, iprot):
14384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14386 
      return
14387 
    iprot.readStructBegin()
14388 
    while True:
14389 
      (fname, ftype, fid) = iprot.readFieldBegin()
14390 
      if ftype == TType.STOP:
14391 
        break
14392 
      if fid == 1:
14393 
        if ftype == TType.I64:
14394 
          self.catalog_item_id = iprot.readI64();
14395 
        else:
14396 
          iprot.skip(ftype)
14397 
      elif fid == 2:
14398 
        if ftype == TType.I64:
14399 
          self.voucherType = iprot.readI64();
14400 
        else:
14401 
          iprot.skip(ftype)
14402 
      else:
14403 
        iprot.skip(ftype)
14404 
      iprot.readFieldEnd()
14405 
    iprot.readStructEnd()
14406 
 
14407 
  def write(self, oprot):
14408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14410 
      return
14411 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14412 
    if self.catalog_item_id is not None:
14413 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14414 
      oprot.writeI64(self.catalog_item_id)
14415 
      oprot.writeFieldEnd()
14416 
    if self.voucherType is not None:
14417 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14418 
      oprot.writeI64(self.voucherType)
14419 
      oprot.writeFieldEnd()
14420 
    oprot.writeFieldStop()
14421 
    oprot.writeStructEnd()
14422 
 
14423 
  def validate(self):
14424 
    return
14425 
 
14426 
 
14427 
  def __repr__(self):
14428 
    L = ['%s=%r' % (key, value)
14429 
      for key, value in self.__dict__.iteritems()]
14430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14431 
 
14432 
  def __eq__(self, other):
14433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14434 
 
14435 
  def __ne__(self, other):
14436 
    return not (self == other)
14437 
 
14438 
class deleteVoucherForItem_result:
14439 
  """
14440 
  Attributes:
14441 
   - success
14442 
   - cex
14443 
  """
14444 
 
14445 
  thrift_spec = (
14446 
    (0, TType.BOOL, 'success', None, None, ), # 0
14447 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14448 
  )
14449 
 
14450 
  def __init__(self, success=None, cex=None,):
14451 
    self.success = success
14452 
    self.cex = cex
14453 
 
14454 
  def read(self, iprot):
14455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14457 
      return
14458 
    iprot.readStructBegin()
14459 
    while True:
14460 
      (fname, ftype, fid) = iprot.readFieldBegin()
14461 
      if ftype == TType.STOP:
14462 
        break
14463 
      if fid == 0:
14464 
        if ftype == TType.BOOL:
14465 
          self.success = iprot.readBool();
14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      elif fid == 1:
14469 
        if ftype == TType.STRUCT:
14470 
          self.cex = CatalogServiceException()
14471 
          self.cex.read(iprot)
14472 
        else:
14473 
          iprot.skip(ftype)
14474 
      else:
14475 
        iprot.skip(ftype)
14476 
      iprot.readFieldEnd()
14477 
    iprot.readStructEnd()
14478 
 
14479 
  def write(self, oprot):
14480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14482 
      return
14483 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14484 
    if self.success is not None:
14485 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14486 
      oprot.writeBool(self.success)
14487 
      oprot.writeFieldEnd()
14488 
    if self.cex is not None:
14489 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14490 
      self.cex.write(oprot)
14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
14510 
class getVoucherAmount_args:
14511 
  """
14512 
  Attributes:
14513 
   - itemId
14514 
   - voucherType
14515 
  """
14516 
 
14517 
  thrift_spec = (
14518 
    None, # 0
14519 
    (1, TType.I64, 'itemId', None, None, ), # 1
14520 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14521 
  )
14522 
 
14523 
  def __init__(self, itemId=None, voucherType=None,):
14524 
    self.itemId = itemId
14525 
    self.voucherType = voucherType
14526 
 
14527 
  def read(self, iprot):
14528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14530 
      return
14531 
    iprot.readStructBegin()
14532 
    while True:
14533 
      (fname, ftype, fid) = iprot.readFieldBegin()
14534 
      if ftype == TType.STOP:
14535 
        break
14536 
      if fid == 1:
14537 
        if ftype == TType.I64:
14538 
          self.itemId = iprot.readI64();
14539 
        else:
14540 
          iprot.skip(ftype)
14541 
      elif fid == 2:
14542 
        if ftype == TType.I64:
14543 
          self.voucherType = iprot.readI64();
14544 
        else:
14545 
          iprot.skip(ftype)
14546 
      else:
14547 
        iprot.skip(ftype)
14548 
      iprot.readFieldEnd()
14549 
    iprot.readStructEnd()
14550 
 
14551 
  def write(self, oprot):
14552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14554 
      return
14555 
    oprot.writeStructBegin('getVoucherAmount_args')
14556 
    if self.itemId is not None:
14557 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14558 
      oprot.writeI64(self.itemId)
14559 
      oprot.writeFieldEnd()
14560 
    if self.voucherType is not None:
14561 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14562 
      oprot.writeI64(self.voucherType)
14563 
      oprot.writeFieldEnd()
14564 
    oprot.writeFieldStop()
14565 
    oprot.writeStructEnd()
14566 
 
14567 
  def validate(self):
14568 
    return
14569 
 
14570 
 
14571 
  def __repr__(self):
14572 
    L = ['%s=%r' % (key, value)
14573 
      for key, value in self.__dict__.iteritems()]
14574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14575 
 
14576 
  def __eq__(self, other):
14577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14578 
 
14579 
  def __ne__(self, other):
14580 
    return not (self == other)
14581 
 
14582 
class getVoucherAmount_result:
14583 
  """
14584 
  Attributes:
14585 
   - success
14586 
  """
14587 
 
14588 
  thrift_spec = (
14589 
    (0, TType.I64, 'success', None, None, ), # 0
14590 
  )
14591 
 
14592 
  def __init__(self, success=None,):
14593 
    self.success = success
14594 
 
14595 
  def read(self, iprot):
14596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14598 
      return
14599 
    iprot.readStructBegin()
14600 
    while True:
14601 
      (fname, ftype, fid) = iprot.readFieldBegin()
14602 
      if ftype == TType.STOP:
14603 
        break
14604 
      if fid == 0:
14605 
        if ftype == TType.I64:
14606 
          self.success = 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('getVoucherAmount_result')
14619 
    if self.success is not None:
14620 
      oprot.writeFieldBegin('success', TType.I64, 0)
14621 
      oprot.writeI64(self.success)
14622 
      oprot.writeFieldEnd()
14623 
    oprot.writeFieldStop()
14624 
    oprot.writeStructEnd()
14625 
 
14626 
  def validate(self):
14627 
    return
14628 
 
14629 
 
14630 
  def __repr__(self):
14631 
    L = ['%s=%r' % (key, value)
14632 
      for key, value in self.__dict__.iteritems()]
14633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14634 
 
14635 
  def __eq__(self, other):
14636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14637 
 
14638 
  def __ne__(self, other):
14639 
    return not (self == other)
14640 
 
14641 
class getAllItemVouchers_args:
14642 
  """
14643 
  Attributes:
14644 
   - itemId
14645 
  """
14646 
 
14647 
  thrift_spec = (
14648 
    None, # 0
14649 
    (1, TType.I64, 'itemId', None, None, ), # 1
14650 
  )
14651 
 
14652 
  def __init__(self, itemId=None,):
14653 
    self.itemId = itemId
14654 
 
14655 
  def read(self, iprot):
14656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14658 
      return
14659 
    iprot.readStructBegin()
14660 
    while True:
14661 
      (fname, ftype, fid) = iprot.readFieldBegin()
14662 
      if ftype == TType.STOP:
14663 
        break
14664 
      if fid == 1:
14665 
        if ftype == TType.I64:
14666 
          self.itemId = iprot.readI64();
14667 
        else:
14668 
          iprot.skip(ftype)
14669 
      else:
14670 
        iprot.skip(ftype)
14671 
      iprot.readFieldEnd()
14672 
    iprot.readStructEnd()
14673 
 
14674 
  def write(self, oprot):
14675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14677 
      return
14678 
    oprot.writeStructBegin('getAllItemVouchers_args')
14679 
    if self.itemId is not None:
14680 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14681 
      oprot.writeI64(self.itemId)
14682 
      oprot.writeFieldEnd()
14683 
    oprot.writeFieldStop()
14684 
    oprot.writeStructEnd()
14685 
 
14686 
  def validate(self):
14687 
    return
14688 
 
14689 
 
14690 
  def __repr__(self):
14691 
    L = ['%s=%r' % (key, value)
14692 
      for key, value in self.__dict__.iteritems()]
14693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14694 
 
14695 
  def __eq__(self, other):
14696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14697 
 
14698 
  def __ne__(self, other):
14699 
    return not (self == other)
14700 
 
14701 
class getAllItemVouchers_result:
14702 
  """
14703 
  Attributes:
14704 
   - success
14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14709 
  )
14710 
 
14711 
  def __init__(self, success=None,):
14712 
    self.success = success
14713 
 
14714 
  def read(self, iprot):
14715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14717 
      return
14718 
    iprot.readStructBegin()
14719 
    while True:
14720 
      (fname, ftype, fid) = iprot.readFieldBegin()
14721 
      if ftype == TType.STOP:
14722 
        break
14723 
      if fid == 0:
14724 
        if ftype == TType.LIST:
14725 
          self.success = []
7256 rajveer 14726 
          (_etype273, _size270) = iprot.readListBegin()
14727 
          for _i274 in xrange(_size270):
14728 
            _elem275 = VoucherItemMapping()
14729 
            _elem275.read(iprot)
14730 
            self.success.append(_elem275)
5944 mandeep.dh 14731 
          iprot.readListEnd()
14732 
        else:
14733 
          iprot.skip(ftype)
14734 
      else:
14735 
        iprot.skip(ftype)
14736 
      iprot.readFieldEnd()
14737 
    iprot.readStructEnd()
14738 
 
14739 
  def write(self, oprot):
14740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14742 
      return
14743 
    oprot.writeStructBegin('getAllItemVouchers_result')
14744 
    if self.success is not None:
14745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14747 
      for iter276 in self.success:
14748 
        iter276.write(oprot)
5944 mandeep.dh 14749 
      oprot.writeListEnd()
14750 
      oprot.writeFieldEnd()
14751 
    oprot.writeFieldStop()
14752 
    oprot.writeStructEnd()
14753 
 
14754 
  def validate(self):
14755 
    return
14756 
 
14757 
 
14758 
  def __repr__(self):
14759 
    L = ['%s=%r' % (key, value)
14760 
      for key, value in self.__dict__.iteritems()]
14761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14762 
 
14763 
  def __eq__(self, other):
14764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14765 
 
14766 
  def __ne__(self, other):
14767 
    return not (self == other)
14768 
 
14769 
class isValidCatalogItemId_args:
14770 
  """
14771 
  Attributes:
14772 
   - catalog_item_id
14773 
  """
14774 
 
14775 
  thrift_spec = (
14776 
    None, # 0
14777 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14778 
  )
14779 
 
14780 
  def __init__(self, catalog_item_id=None,):
14781 
    self.catalog_item_id = catalog_item_id
14782 
 
14783 
  def read(self, iprot):
14784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14786 
      return
14787 
    iprot.readStructBegin()
14788 
    while True:
14789 
      (fname, ftype, fid) = iprot.readFieldBegin()
14790 
      if ftype == TType.STOP:
14791 
        break
14792 
      if fid == 1:
14793 
        if ftype == TType.I64:
14794 
          self.catalog_item_id = iprot.readI64();
14795 
        else:
14796 
          iprot.skip(ftype)
14797 
      else:
14798 
        iprot.skip(ftype)
14799 
      iprot.readFieldEnd()
14800 
    iprot.readStructEnd()
14801 
 
14802 
  def write(self, oprot):
14803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14805 
      return
14806 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14807 
    if self.catalog_item_id is not None:
14808 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14809 
      oprot.writeI64(self.catalog_item_id)
14810 
      oprot.writeFieldEnd()
14811 
    oprot.writeFieldStop()
14812 
    oprot.writeStructEnd()
14813 
 
14814 
  def validate(self):
14815 
    return
14816 
 
14817 
 
14818 
  def __repr__(self):
14819 
    L = ['%s=%r' % (key, value)
14820 
      for key, value in self.__dict__.iteritems()]
14821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14822 
 
14823 
  def __eq__(self, other):
14824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14825 
 
14826 
  def __ne__(self, other):
14827 
    return not (self == other)
14828 
 
14829 
class isValidCatalogItemId_result:
14830 
  """
14831 
  Attributes:
14832 
   - success
14833 
  """
14834 
 
14835 
  thrift_spec = (
14836 
    (0, TType.BOOL, 'success', None, None, ), # 0
14837 
  )
14838 
 
14839 
  def __init__(self, success=None,):
14840 
    self.success = success
14841 
 
14842 
  def read(self, iprot):
14843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14845 
      return
14846 
    iprot.readStructBegin()
14847 
    while True:
14848 
      (fname, ftype, fid) = iprot.readFieldBegin()
14849 
      if ftype == TType.STOP:
14850 
        break
14851 
      if fid == 0:
14852 
        if ftype == TType.BOOL:
14853 
          self.success = iprot.readBool();
14854 
        else:
14855 
          iprot.skip(ftype)
14856 
      else:
14857 
        iprot.skip(ftype)
14858 
      iprot.readFieldEnd()
14859 
    iprot.readStructEnd()
14860 
 
14861 
  def write(self, oprot):
14862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14864 
      return
14865 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14866 
    if self.success is not None:
14867 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14868 
      oprot.writeBool(self.success)
14869 
      oprot.writeFieldEnd()
14870 
    oprot.writeFieldStop()
14871 
    oprot.writeStructEnd()
14872 
 
14873 
  def validate(self):
14874 
    return
14875 
 
14876 
 
14877 
  def __repr__(self):
14878 
    L = ['%s=%r' % (key, value)
14879 
      for key, value in self.__dict__.iteritems()]
14880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14881 
 
14882 
  def __eq__(self, other):
14883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14884 
 
14885 
  def __ne__(self, other):
14886 
    return not (self == other)
6039 amit.gupta 14887 
 
14888 
class getVatPercentageForItem_args:
14889 
  """
14890 
  Attributes:
14891 
   - itemId
7330 amit.gupta 14892 
   - stateId
6039 amit.gupta 14893 
   - price
14894 
  """
14895 
 
14896 
  thrift_spec = (
14897 
    None, # 0
14898 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 14899 
    (2, TType.I64, 'stateId', None, None, ), # 2
14900 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 14901 
  )
14902 
 
7330 amit.gupta 14903 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 14904 
    self.itemId = itemId
7330 amit.gupta 14905 
    self.stateId = stateId
6039 amit.gupta 14906 
    self.price = price
14907 
 
14908 
  def read(self, iprot):
14909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14911 
      return
14912 
    iprot.readStructBegin()
14913 
    while True:
14914 
      (fname, ftype, fid) = iprot.readFieldBegin()
14915 
      if ftype == TType.STOP:
14916 
        break
14917 
      if fid == 1:
14918 
        if ftype == TType.I64:
14919 
          self.itemId = iprot.readI64();
14920 
        else:
14921 
          iprot.skip(ftype)
14922 
      elif fid == 2:
7330 amit.gupta 14923 
        if ftype == TType.I64:
14924 
          self.stateId = iprot.readI64();
14925 
        else:
14926 
          iprot.skip(ftype)
14927 
      elif fid == 3:
6039 amit.gupta 14928 
        if ftype == TType.DOUBLE:
14929 
          self.price = iprot.readDouble();
14930 
        else:
14931 
          iprot.skip(ftype)
14932 
      else:
14933 
        iprot.skip(ftype)
14934 
      iprot.readFieldEnd()
14935 
    iprot.readStructEnd()
14936 
 
14937 
  def write(self, oprot):
14938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14940 
      return
14941 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14942 
    if self.itemId is not None:
14943 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14944 
      oprot.writeI64(self.itemId)
14945 
      oprot.writeFieldEnd()
7330 amit.gupta 14946 
    if self.stateId is not None:
14947 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
14948 
      oprot.writeI64(self.stateId)
14949 
      oprot.writeFieldEnd()
6039 amit.gupta 14950 
    if self.price is not None:
7330 amit.gupta 14951 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 14952 
      oprot.writeDouble(self.price)
14953 
      oprot.writeFieldEnd()
14954 
    oprot.writeFieldStop()
14955 
    oprot.writeStructEnd()
14956 
 
14957 
  def validate(self):
14958 
    return
14959 
 
14960 
 
14961 
  def __repr__(self):
14962 
    L = ['%s=%r' % (key, value)
14963 
      for key, value in self.__dict__.iteritems()]
14964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14965 
 
14966 
  def __eq__(self, other):
14967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14968 
 
14969 
  def __ne__(self, other):
14970 
    return not (self == other)
14971 
 
14972 
class getVatPercentageForItem_result:
14973 
  """
14974 
  Attributes:
14975 
   - success
7340 amit.gupta 14976 
   - cex
6039 amit.gupta 14977 
  """
14978 
 
14979 
  thrift_spec = (
14980 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 14981 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 14982 
  )
14983 
 
7340 amit.gupta 14984 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 14985 
    self.success = success
7340 amit.gupta 14986 
    self.cex = cex
6039 amit.gupta 14987 
 
14988 
  def read(self, iprot):
14989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14991 
      return
14992 
    iprot.readStructBegin()
14993 
    while True:
14994 
      (fname, ftype, fid) = iprot.readFieldBegin()
14995 
      if ftype == TType.STOP:
14996 
        break
14997 
      if fid == 0:
14998 
        if ftype == TType.DOUBLE:
14999 
          self.success = iprot.readDouble();
15000 
        else:
15001 
          iprot.skip(ftype)
7340 amit.gupta 15002 
      elif fid == 1:
15003 
        if ftype == TType.STRUCT:
15004 
          self.cex = CatalogServiceException()
15005 
          self.cex.read(iprot)
15006 
        else:
15007 
          iprot.skip(ftype)
6039 amit.gupta 15008 
      else:
15009 
        iprot.skip(ftype)
15010 
      iprot.readFieldEnd()
15011 
    iprot.readStructEnd()
15012 
 
15013 
  def write(self, oprot):
15014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15016 
      return
15017 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15018 
    if self.success is not None:
15019 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15020 
      oprot.writeDouble(self.success)
15021 
      oprot.writeFieldEnd()
7340 amit.gupta 15022 
    if self.cex is not None:
15023 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15024 
      self.cex.write(oprot)
15025 
      oprot.writeFieldEnd()
6039 amit.gupta 15026 
    oprot.writeFieldStop()
15027 
    oprot.writeStructEnd()
15028 
 
15029 
  def validate(self):
15030 
    return
15031 
 
15032 
 
15033 
  def __repr__(self):
15034 
    L = ['%s=%r' % (key, value)
15035 
      for key, value in self.__dict__.iteritems()]
15036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15037 
 
15038 
  def __eq__(self, other):
15039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15040 
 
15041 
  def __ne__(self, other):
15042 
    return not (self == other)
15043 
 
15044 
class getVatAmountForItem_args:
15045 
  """
15046 
  Attributes:
15047 
   - itemId
15048 
   - price
15049 
  """
15050 
 
15051 
  thrift_spec = (
15052 
    None, # 0
15053 
    (1, TType.I64, 'itemId', None, None, ), # 1
15054 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15055 
  )
15056 
 
15057 
  def __init__(self, itemId=None, price=None,):
15058 
    self.itemId = itemId
15059 
    self.price = price
15060 
 
15061 
  def read(self, iprot):
15062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15064 
      return
15065 
    iprot.readStructBegin()
15066 
    while True:
15067 
      (fname, ftype, fid) = iprot.readFieldBegin()
15068 
      if ftype == TType.STOP:
15069 
        break
15070 
      if fid == 1:
15071 
        if ftype == TType.I64:
15072 
          self.itemId = iprot.readI64();
15073 
        else:
15074 
          iprot.skip(ftype)
15075 
      elif fid == 2:
15076 
        if ftype == TType.DOUBLE:
15077 
          self.price = iprot.readDouble();
15078 
        else:
15079 
          iprot.skip(ftype)
15080 
      else:
15081 
        iprot.skip(ftype)
15082 
      iprot.readFieldEnd()
15083 
    iprot.readStructEnd()
15084 
 
15085 
  def write(self, oprot):
15086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15088 
      return
15089 
    oprot.writeStructBegin('getVatAmountForItem_args')
15090 
    if self.itemId is not None:
15091 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15092 
      oprot.writeI64(self.itemId)
15093 
      oprot.writeFieldEnd()
15094 
    if self.price is not None:
15095 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15096 
      oprot.writeDouble(self.price)
15097 
      oprot.writeFieldEnd()
15098 
    oprot.writeFieldStop()
15099 
    oprot.writeStructEnd()
15100 
 
15101 
  def validate(self):
15102 
    return
15103 
 
15104 
 
15105 
  def __repr__(self):
15106 
    L = ['%s=%r' % (key, value)
15107 
      for key, value in self.__dict__.iteritems()]
15108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15109 
 
15110 
  def __eq__(self, other):
15111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15112 
 
15113 
  def __ne__(self, other):
15114 
    return not (self == other)
15115 
 
15116 
class getVatAmountForItem_result:
15117 
  """
15118 
  Attributes:
15119 
   - success
15120 
  """
15121 
 
15122 
  thrift_spec = (
15123 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15124 
  )
15125 
 
15126 
  def __init__(self, success=None,):
15127 
    self.success = success
15128 
 
15129 
  def read(self, iprot):
15130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15132 
      return
15133 
    iprot.readStructBegin()
15134 
    while True:
15135 
      (fname, ftype, fid) = iprot.readFieldBegin()
15136 
      if ftype == TType.STOP:
15137 
        break
15138 
      if fid == 0:
15139 
        if ftype == TType.DOUBLE:
15140 
          self.success = iprot.readDouble();
15141 
        else:
15142 
          iprot.skip(ftype)
15143 
      else:
15144 
        iprot.skip(ftype)
15145 
      iprot.readFieldEnd()
15146 
    iprot.readStructEnd()
15147 
 
15148 
  def write(self, oprot):
15149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15151 
      return
15152 
    oprot.writeStructBegin('getVatAmountForItem_result')
15153 
    if self.success is not None:
15154 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15155 
      oprot.writeDouble(self.success)
15156 
      oprot.writeFieldEnd()
15157 
    oprot.writeFieldStop()
15158 
    oprot.writeStructEnd()
15159 
 
15160 
  def validate(self):
15161 
    return
15162 
 
15163 
 
15164 
  def __repr__(self):
15165 
    L = ['%s=%r' % (key, value)
15166 
      for key, value in self.__dict__.iteritems()]
15167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15168 
 
15169 
  def __eq__(self, other):
15170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15171 
 
15172 
  def __ne__(self, other):
15173 
    return not (self == other)
6531 vikram.rag 15174 
 
15175 
class getAllIgnoredInventoryUpdateItemsList_args:
15176 
  """
15177 
  Attributes:
15178 
   - offset
15179 
   - limit
15180 
  """
15181 
 
15182 
  thrift_spec = (
15183 
    None, # 0
15184 
    (1, TType.I32, 'offset', None, None, ), # 1
15185 
    (2, TType.I32, 'limit', None, None, ), # 2
15186 
  )
15187 
 
15188 
  def __init__(self, offset=None, limit=None,):
15189 
    self.offset = offset
15190 
    self.limit = limit
15191 
 
15192 
  def read(self, iprot):
15193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15195 
      return
15196 
    iprot.readStructBegin()
15197 
    while True:
15198 
      (fname, ftype, fid) = iprot.readFieldBegin()
15199 
      if ftype == TType.STOP:
15200 
        break
15201 
      if fid == 1:
15202 
        if ftype == TType.I32:
15203 
          self.offset = iprot.readI32();
15204 
        else:
15205 
          iprot.skip(ftype)
15206 
      elif fid == 2:
15207 
        if ftype == TType.I32:
15208 
          self.limit = iprot.readI32();
15209 
        else:
15210 
          iprot.skip(ftype)
15211 
      else:
15212 
        iprot.skip(ftype)
15213 
      iprot.readFieldEnd()
15214 
    iprot.readStructEnd()
15215 
 
15216 
  def write(self, oprot):
15217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15219 
      return
15220 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15221 
    if self.offset is not None:
15222 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15223 
      oprot.writeI32(self.offset)
15224 
      oprot.writeFieldEnd()
15225 
    if self.limit is not None:
15226 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15227 
      oprot.writeI32(self.limit)
15228 
      oprot.writeFieldEnd()
15229 
    oprot.writeFieldStop()
15230 
    oprot.writeStructEnd()
15231 
 
15232 
  def validate(self):
15233 
    return
15234 
 
15235 
 
15236 
  def __repr__(self):
15237 
    L = ['%s=%r' % (key, value)
15238 
      for key, value in self.__dict__.iteritems()]
15239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15240 
 
15241 
  def __eq__(self, other):
15242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15243 
 
15244 
  def __ne__(self, other):
15245 
    return not (self == other)
15246 
 
15247 
class getAllIgnoredInventoryUpdateItemsList_result:
15248 
  """
15249 
  Attributes:
15250 
   - success
15251 
  """
15252 
 
15253 
  thrift_spec = (
15254 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15255 
  )
15256 
 
15257 
  def __init__(self, success=None,):
15258 
    self.success = success
15259 
 
15260 
  def read(self, iprot):
15261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15263 
      return
15264 
    iprot.readStructBegin()
15265 
    while True:
15266 
      (fname, ftype, fid) = iprot.readFieldBegin()
15267 
      if ftype == TType.STOP:
15268 
        break
15269 
      if fid == 0:
15270 
        if ftype == TType.LIST:
15271 
          self.success = []
7256 rajveer 15272 
          (_etype280, _size277) = iprot.readListBegin()
15273 
          for _i281 in xrange(_size277):
15274 
            _elem282 = Item()
15275 
            _elem282.read(iprot)
15276 
            self.success.append(_elem282)
6531 vikram.rag 15277 
          iprot.readListEnd()
15278 
        else:
15279 
          iprot.skip(ftype)
15280 
      else:
15281 
        iprot.skip(ftype)
15282 
      iprot.readFieldEnd()
15283 
    iprot.readStructEnd()
15284 
 
15285 
  def write(self, oprot):
15286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15288 
      return
15289 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15290 
    if self.success is not None:
15291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15293 
      for iter283 in self.success:
15294 
        iter283.write(oprot)
6531 vikram.rag 15295 
      oprot.writeListEnd()
15296 
      oprot.writeFieldEnd()
15297 
    oprot.writeFieldStop()
15298 
    oprot.writeStructEnd()
15299 
 
15300 
  def validate(self):
15301 
    return
15302 
 
15303 
 
15304 
  def __repr__(self):
15305 
    L = ['%s=%r' % (key, value)
15306 
      for key, value in self.__dict__.iteritems()]
15307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15308 
 
15309 
  def __eq__(self, other):
15310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15311 
 
15312 
  def __ne__(self, other):
15313 
    return not (self == other)
6805 anupam.sin 15314 
 
6821 amar.kumar 15315 
class getAllAliveItems_args:
15316 
 
15317 
  thrift_spec = (
15318 
  )
15319 
 
15320 
  def read(self, iprot):
15321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15323 
      return
15324 
    iprot.readStructBegin()
15325 
    while True:
15326 
      (fname, ftype, fid) = iprot.readFieldBegin()
15327 
      if ftype == TType.STOP:
15328 
        break
15329 
      else:
15330 
        iprot.skip(ftype)
15331 
      iprot.readFieldEnd()
15332 
    iprot.readStructEnd()
15333 
 
15334 
  def write(self, oprot):
15335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15337 
      return
15338 
    oprot.writeStructBegin('getAllAliveItems_args')
15339 
    oprot.writeFieldStop()
15340 
    oprot.writeStructEnd()
15341 
 
15342 
  def validate(self):
15343 
    return
15344 
 
15345 
 
15346 
  def __repr__(self):
15347 
    L = ['%s=%r' % (key, value)
15348 
      for key, value in self.__dict__.iteritems()]
15349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15350 
 
15351 
  def __eq__(self, other):
15352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15353 
 
15354 
  def __ne__(self, other):
15355 
    return not (self == other)
15356 
 
15357 
class getAllAliveItems_result:
15358 
  """
15359 
  Attributes:
15360 
   - success
15361 
  """
15362 
 
15363 
  thrift_spec = (
15364 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15365 
  )
15366 
 
15367 
  def __init__(self, success=None,):
15368 
    self.success = success
15369 
 
15370 
  def read(self, iprot):
15371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15373 
      return
15374 
    iprot.readStructBegin()
15375 
    while True:
15376 
      (fname, ftype, fid) = iprot.readFieldBegin()
15377 
      if ftype == TType.STOP:
15378 
        break
15379 
      if fid == 0:
15380 
        if ftype == TType.LIST:
15381 
          self.success = []
7256 rajveer 15382 
          (_etype287, _size284) = iprot.readListBegin()
15383 
          for _i288 in xrange(_size284):
15384 
            _elem289 = Item()
15385 
            _elem289.read(iprot)
15386 
            self.success.append(_elem289)
6821 amar.kumar 15387 
          iprot.readListEnd()
15388 
        else:
15389 
          iprot.skip(ftype)
15390 
      else:
15391 
        iprot.skip(ftype)
15392 
      iprot.readFieldEnd()
15393 
    iprot.readStructEnd()
15394 
 
15395 
  def write(self, oprot):
15396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15398 
      return
15399 
    oprot.writeStructBegin('getAllAliveItems_result')
15400 
    if self.success is not None:
15401 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15402 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15403 
      for iter290 in self.success:
15404 
        iter290.write(oprot)
6821 amar.kumar 15405 
      oprot.writeListEnd()
15406 
      oprot.writeFieldEnd()
15407 
    oprot.writeFieldStop()
15408 
    oprot.writeStructEnd()
15409 
 
15410 
  def validate(self):
15411 
    return
15412 
 
15413 
 
15414 
  def __repr__(self):
15415 
    L = ['%s=%r' % (key, value)
15416 
      for key, value in self.__dict__.iteritems()]
15417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15418 
 
15419 
  def __eq__(self, other):
15420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15421 
 
15422 
  def __ne__(self, other):
15423 
    return not (self == other)
15424 
 
6805 anupam.sin 15425 
class getInsuranceAmount_args:
15426 
  """
15427 
  Attributes:
15428 
   - itemId
6921 anupam.sin 15429 
   - price
6805 anupam.sin 15430 
   - insurerId
15431 
   - quantity
15432 
  """
15433 
 
15434 
  thrift_spec = (
15435 
    None, # 0
15436 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15437 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15438 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15439 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15440 
  )
15441 
 
6921 anupam.sin 15442 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15443 
    self.itemId = itemId
6921 anupam.sin 15444 
    self.price = price
6805 anupam.sin 15445 
    self.insurerId = insurerId
15446 
    self.quantity = quantity
15447 
 
15448 
  def read(self, iprot):
15449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15451 
      return
15452 
    iprot.readStructBegin()
15453 
    while True:
15454 
      (fname, ftype, fid) = iprot.readFieldBegin()
15455 
      if ftype == TType.STOP:
15456 
        break
15457 
      if fid == 1:
15458 
        if ftype == TType.I64:
15459 
          self.itemId = iprot.readI64();
15460 
        else:
15461 
          iprot.skip(ftype)
15462 
      elif fid == 2:
6921 anupam.sin 15463 
        if ftype == TType.DOUBLE:
15464 
          self.price = iprot.readDouble();
15465 
        else:
15466 
          iprot.skip(ftype)
15467 
      elif fid == 3:
6805 anupam.sin 15468 
        if ftype == TType.I64:
15469 
          self.insurerId = iprot.readI64();
15470 
        else:
15471 
          iprot.skip(ftype)
6921 anupam.sin 15472 
      elif fid == 4:
6805 anupam.sin 15473 
        if ftype == TType.I64:
15474 
          self.quantity = iprot.readI64();
15475 
        else:
15476 
          iprot.skip(ftype)
15477 
      else:
15478 
        iprot.skip(ftype)
15479 
      iprot.readFieldEnd()
15480 
    iprot.readStructEnd()
15481 
 
15482 
  def write(self, oprot):
15483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15485 
      return
15486 
    oprot.writeStructBegin('getInsuranceAmount_args')
15487 
    if self.itemId is not None:
15488 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15489 
      oprot.writeI64(self.itemId)
15490 
      oprot.writeFieldEnd()
6921 anupam.sin 15491 
    if self.price is not None:
15492 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15493 
      oprot.writeDouble(self.price)
15494 
      oprot.writeFieldEnd()
6805 anupam.sin 15495 
    if self.insurerId is not None:
6921 anupam.sin 15496 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15497 
      oprot.writeI64(self.insurerId)
15498 
      oprot.writeFieldEnd()
15499 
    if self.quantity is not None:
6921 anupam.sin 15500 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15501 
      oprot.writeI64(self.quantity)
15502 
      oprot.writeFieldEnd()
15503 
    oprot.writeFieldStop()
15504 
    oprot.writeStructEnd()
15505 
 
15506 
  def validate(self):
15507 
    return
15508 
 
15509 
 
15510 
  def __repr__(self):
15511 
    L = ['%s=%r' % (key, value)
15512 
      for key, value in self.__dict__.iteritems()]
15513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15514 
 
15515 
  def __eq__(self, other):
15516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15517 
 
15518 
  def __ne__(self, other):
15519 
    return not (self == other)
15520 
 
15521 
class getInsuranceAmount_result:
15522 
  """
15523 
  Attributes:
15524 
   - success
15525 
  """
15526 
 
15527 
  thrift_spec = (
15528 
    (0, TType.I64, 'success', None, None, ), # 0
15529 
  )
15530 
 
15531 
  def __init__(self, success=None,):
15532 
    self.success = success
15533 
 
15534 
  def read(self, iprot):
15535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15537 
      return
15538 
    iprot.readStructBegin()
15539 
    while True:
15540 
      (fname, ftype, fid) = iprot.readFieldBegin()
15541 
      if ftype == TType.STOP:
15542 
        break
15543 
      if fid == 0:
15544 
        if ftype == TType.I64:
15545 
          self.success = iprot.readI64();
15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
15557 
    oprot.writeStructBegin('getInsuranceAmount_result')
15558 
    if self.success is not None:
15559 
      oprot.writeFieldBegin('success', TType.I64, 0)
15560 
      oprot.writeI64(self.success)
15561 
      oprot.writeFieldEnd()
15562 
    oprot.writeFieldStop()
15563 
    oprot.writeStructEnd()
15564 
 
15565 
  def validate(self):
15566 
    return
15567 
 
15568 
 
15569 
  def __repr__(self):
15570 
    L = ['%s=%r' % (key, value)
15571 
      for key, value in self.__dict__.iteritems()]
15572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15573 
 
15574 
  def __eq__(self, other):
15575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15576 
 
15577 
  def __ne__(self, other):
15578 
    return not (self == other)
15579 
 
15580 
class getInsurer_args:
15581 
  """
15582 
  Attributes:
15583 
   - insurerId
15584 
  """
15585 
 
15586 
  thrift_spec = (
15587 
    None, # 0
15588 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15589 
  )
15590 
 
15591 
  def __init__(self, insurerId=None,):
15592 
    self.insurerId = insurerId
15593 
 
15594 
  def read(self, iprot):
15595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15597 
      return
15598 
    iprot.readStructBegin()
15599 
    while True:
15600 
      (fname, ftype, fid) = iprot.readFieldBegin()
15601 
      if ftype == TType.STOP:
15602 
        break
15603 
      if fid == 1:
15604 
        if ftype == TType.I64:
15605 
          self.insurerId = iprot.readI64();
15606 
        else:
15607 
          iprot.skip(ftype)
15608 
      else:
15609 
        iprot.skip(ftype)
15610 
      iprot.readFieldEnd()
15611 
    iprot.readStructEnd()
15612 
 
15613 
  def write(self, oprot):
15614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15616 
      return
15617 
    oprot.writeStructBegin('getInsurer_args')
15618 
    if self.insurerId is not None:
15619 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15620 
      oprot.writeI64(self.insurerId)
15621 
      oprot.writeFieldEnd()
15622 
    oprot.writeFieldStop()
15623 
    oprot.writeStructEnd()
15624 
 
15625 
  def validate(self):
15626 
    return
15627 
 
15628 
 
15629 
  def __repr__(self):
15630 
    L = ['%s=%r' % (key, value)
15631 
      for key, value in self.__dict__.iteritems()]
15632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15633 
 
15634 
  def __eq__(self, other):
15635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15636 
 
15637 
  def __ne__(self, other):
15638 
    return not (self == other)
15639 
 
15640 
class getInsurer_result:
15641 
  """
15642 
  Attributes:
15643 
   - success
15644 
  """
15645 
 
15646 
  thrift_spec = (
15647 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15648 
  )
15649 
 
15650 
  def __init__(self, success=None,):
15651 
    self.success = success
15652 
 
15653 
  def read(self, iprot):
15654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15656 
      return
15657 
    iprot.readStructBegin()
15658 
    while True:
15659 
      (fname, ftype, fid) = iprot.readFieldBegin()
15660 
      if ftype == TType.STOP:
15661 
        break
15662 
      if fid == 0:
15663 
        if ftype == TType.STRUCT:
15664 
          self.success = Insurer()
15665 
          self.success.read(iprot)
15666 
        else:
15667 
          iprot.skip(ftype)
15668 
      else:
15669 
        iprot.skip(ftype)
15670 
      iprot.readFieldEnd()
15671 
    iprot.readStructEnd()
15672 
 
15673 
  def write(self, oprot):
15674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15676 
      return
15677 
    oprot.writeStructBegin('getInsurer_result')
15678 
    if self.success is not None:
15679 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15680 
      self.success.write(oprot)
15681 
      oprot.writeFieldEnd()
15682 
    oprot.writeFieldStop()
15683 
    oprot.writeStructEnd()
15684 
 
15685 
  def validate(self):
15686 
    return
15687 
 
15688 
 
15689 
  def __repr__(self):
15690 
    L = ['%s=%r' % (key, value)
15691 
      for key, value in self.__dict__.iteritems()]
15692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15693 
 
15694 
  def __eq__(self, other):
15695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15696 
 
15697 
  def __ne__(self, other):
15698 
    return not (self == other)
6838 vikram.rag 15699 
 
15700 
class getAllInsurers_args:
15701 
 
15702 
  thrift_spec = (
15703 
  )
15704 
 
15705 
  def read(self, iprot):
15706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15708 
      return
15709 
    iprot.readStructBegin()
15710 
    while True:
15711 
      (fname, ftype, fid) = iprot.readFieldBegin()
15712 
      if ftype == TType.STOP:
15713 
        break
15714 
      else:
15715 
        iprot.skip(ftype)
15716 
      iprot.readFieldEnd()
15717 
    iprot.readStructEnd()
15718 
 
15719 
  def write(self, oprot):
15720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15722 
      return
15723 
    oprot.writeStructBegin('getAllInsurers_args')
15724 
    oprot.writeFieldStop()
15725 
    oprot.writeStructEnd()
15726 
 
15727 
  def validate(self):
15728 
    return
15729 
 
15730 
 
15731 
  def __repr__(self):
15732 
    L = ['%s=%r' % (key, value)
15733 
      for key, value in self.__dict__.iteritems()]
15734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15735 
 
15736 
  def __eq__(self, other):
15737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15738 
 
15739 
  def __ne__(self, other):
15740 
    return not (self == other)
15741 
 
15742 
class getAllInsurers_result:
15743 
  """
15744 
  Attributes:
15745 
   - success
15746 
  """
15747 
 
15748 
  thrift_spec = (
15749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15750 
  )
15751 
 
15752 
  def __init__(self, success=None,):
15753 
    self.success = success
15754 
 
15755 
  def read(self, iprot):
15756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15758 
      return
15759 
    iprot.readStructBegin()
15760 
    while True:
15761 
      (fname, ftype, fid) = iprot.readFieldBegin()
15762 
      if ftype == TType.STOP:
15763 
        break
15764 
      if fid == 0:
15765 
        if ftype == TType.LIST:
15766 
          self.success = []
7256 rajveer 15767 
          (_etype294, _size291) = iprot.readListBegin()
15768 
          for _i295 in xrange(_size291):
15769 
            _elem296 = Insurer()
15770 
            _elem296.read(iprot)
15771 
            self.success.append(_elem296)
6838 vikram.rag 15772 
          iprot.readListEnd()
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
15784 
    oprot.writeStructBegin('getAllInsurers_result')
15785 
    if self.success is not None:
15786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15788 
      for iter297 in self.success:
15789 
        iter297.write(oprot)
6838 vikram.rag 15790 
      oprot.writeListEnd()
15791 
      oprot.writeFieldEnd()
15792 
    oprot.writeFieldStop()
15793 
    oprot.writeStructEnd()
15794 
 
15795 
  def validate(self):
15796 
    return
15797 
 
15798 
 
15799 
  def __repr__(self):
15800 
    L = ['%s=%r' % (key, value)
15801 
      for key, value in self.__dict__.iteritems()]
15802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15803 
 
15804 
  def __eq__(self, other):
15805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15806 
 
15807 
  def __ne__(self, other):
15808 
    return not (self == other)
6962 rajveer 15809 
 
15810 
class updateInsuranceDeclaredAmount_args:
15811 
  """
15812 
  Attributes:
15813 
   - insurerId
15814 
   - amount
15815 
  """
15816 
 
15817 
  thrift_spec = (
15818 
    None, # 0
15819 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15820 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15821 
  )
15822 
 
15823 
  def __init__(self, insurerId=None, amount=None,):
15824 
    self.insurerId = insurerId
15825 
    self.amount = amount
15826 
 
15827 
  def read(self, iprot):
15828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15830 
      return
15831 
    iprot.readStructBegin()
15832 
    while True:
15833 
      (fname, ftype, fid) = iprot.readFieldBegin()
15834 
      if ftype == TType.STOP:
15835 
        break
15836 
      if fid == 1:
15837 
        if ftype == TType.I64:
15838 
          self.insurerId = iprot.readI64();
15839 
        else:
15840 
          iprot.skip(ftype)
15841 
      elif fid == 2:
15842 
        if ftype == TType.DOUBLE:
15843 
          self.amount = iprot.readDouble();
15844 
        else:
15845 
          iprot.skip(ftype)
15846 
      else:
15847 
        iprot.skip(ftype)
15848 
      iprot.readFieldEnd()
15849 
    iprot.readStructEnd()
15850 
 
15851 
  def write(self, oprot):
15852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15854 
      return
15855 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15856 
    if self.insurerId is not None:
15857 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15858 
      oprot.writeI64(self.insurerId)
15859 
      oprot.writeFieldEnd()
15860 
    if self.amount is not None:
15861 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15862 
      oprot.writeDouble(self.amount)
15863 
      oprot.writeFieldEnd()
15864 
    oprot.writeFieldStop()
15865 
    oprot.writeStructEnd()
15866 
 
15867 
  def validate(self):
15868 
    return
15869 
 
15870 
 
15871 
  def __repr__(self):
15872 
    L = ['%s=%r' % (key, value)
15873 
      for key, value in self.__dict__.iteritems()]
15874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15875 
 
15876 
  def __eq__(self, other):
15877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15878 
 
15879 
  def __ne__(self, other):
15880 
    return not (self == other)
15881 
 
15882 
class updateInsuranceDeclaredAmount_result:
15883 
 
15884 
  thrift_spec = (
15885 
  )
15886 
 
15887 
  def read(self, iprot):
15888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15890 
      return
15891 
    iprot.readStructBegin()
15892 
    while True:
15893 
      (fname, ftype, fid) = iprot.readFieldBegin()
15894 
      if ftype == TType.STOP:
15895 
        break
15896 
      else:
15897 
        iprot.skip(ftype)
15898 
      iprot.readFieldEnd()
15899 
    iprot.readStructEnd()
15900 
 
15901 
  def write(self, oprot):
15902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15904 
      return
15905 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15906 
    oprot.writeFieldStop()
15907 
    oprot.writeStructEnd()
15908 
 
15909 
  def validate(self):
15910 
    return
15911 
 
15912 
 
15913 
  def __repr__(self):
15914 
    L = ['%s=%r' % (key, value)
15915 
      for key, value in self.__dict__.iteritems()]
15916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15917 
 
15918 
  def __eq__(self, other):
15919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15920 
 
15921 
  def __ne__(self, other):
15922 
    return not (self == other)
7190 amar.kumar 15923 
 
15924 
class getFreebieForItem_args:
15925 
  """
15926 
  Attributes:
15927 
   - itemId
15928 
  """
15929 
 
15930 
  thrift_spec = (
15931 
    None, # 0
15932 
    (1, TType.I64, 'itemId', None, None, ), # 1
15933 
  )
15934 
 
15935 
  def __init__(self, itemId=None,):
15936 
    self.itemId = itemId
15937 
 
15938 
  def read(self, iprot):
15939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15941 
      return
15942 
    iprot.readStructBegin()
15943 
    while True:
15944 
      (fname, ftype, fid) = iprot.readFieldBegin()
15945 
      if ftype == TType.STOP:
15946 
        break
15947 
      if fid == 1:
15948 
        if ftype == TType.I64:
15949 
          self.itemId = iprot.readI64();
15950 
        else:
15951 
          iprot.skip(ftype)
15952 
      else:
15953 
        iprot.skip(ftype)
15954 
      iprot.readFieldEnd()
15955 
    iprot.readStructEnd()
15956 
 
15957 
  def write(self, oprot):
15958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15960 
      return
15961 
    oprot.writeStructBegin('getFreebieForItem_args')
15962 
    if self.itemId is not None:
15963 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15964 
      oprot.writeI64(self.itemId)
15965 
      oprot.writeFieldEnd()
15966 
    oprot.writeFieldStop()
15967 
    oprot.writeStructEnd()
15968 
 
15969 
  def validate(self):
15970 
    return
15971 
 
15972 
 
15973 
  def __repr__(self):
15974 
    L = ['%s=%r' % (key, value)
15975 
      for key, value in self.__dict__.iteritems()]
15976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15977 
 
15978 
  def __eq__(self, other):
15979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15980 
 
15981 
  def __ne__(self, other):
15982 
    return not (self == other)
15983 
 
15984 
class getFreebieForItem_result:
15985 
  """
15986 
  Attributes:
15987 
   - success
15988 
  """
15989 
 
15990 
  thrift_spec = (
15991 
    (0, TType.I64, 'success', None, None, ), # 0
15992 
  )
15993 
 
15994 
  def __init__(self, success=None,):
15995 
    self.success = success
15996 
 
15997 
  def read(self, iprot):
15998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16000 
      return
16001 
    iprot.readStructBegin()
16002 
    while True:
16003 
      (fname, ftype, fid) = iprot.readFieldBegin()
16004 
      if ftype == TType.STOP:
16005 
        break
16006 
      if fid == 0:
16007 
        if ftype == TType.I64:
16008 
          self.success = iprot.readI64();
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      else:
16012 
        iprot.skip(ftype)
16013 
      iprot.readFieldEnd()
16014 
    iprot.readStructEnd()
16015 
 
16016 
  def write(self, oprot):
16017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16019 
      return
16020 
    oprot.writeStructBegin('getFreebieForItem_result')
16021 
    if self.success is not None:
16022 
      oprot.writeFieldBegin('success', TType.I64, 0)
16023 
      oprot.writeI64(self.success)
16024 
      oprot.writeFieldEnd()
16025 
    oprot.writeFieldStop()
16026 
    oprot.writeStructEnd()
16027 
 
16028 
  def validate(self):
16029 
    return
16030 
 
16031 
 
16032 
  def __repr__(self):
16033 
    L = ['%s=%r' % (key, value)
16034 
      for key, value in self.__dict__.iteritems()]
16035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16036 
 
16037 
  def __eq__(self, other):
16038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16039 
 
16040 
  def __ne__(self, other):
16041 
    return not (self == other)
16042 
 
16043 
class addOrUpdateFreebieForItem_args:
16044 
  """
16045 
  Attributes:
16046 
   - freebieItem
16047 
  """
16048 
 
16049 
  thrift_spec = (
16050 
    None, # 0
16051 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16052 
  )
16053 
 
16054 
  def __init__(self, freebieItem=None,):
16055 
    self.freebieItem = freebieItem
16056 
 
16057 
  def read(self, iprot):
16058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16060 
      return
16061 
    iprot.readStructBegin()
16062 
    while True:
16063 
      (fname, ftype, fid) = iprot.readFieldBegin()
16064 
      if ftype == TType.STOP:
16065 
        break
16066 
      if fid == 1:
16067 
        if ftype == TType.STRUCT:
16068 
          self.freebieItem = FreebieItem()
16069 
          self.freebieItem.read(iprot)
16070 
        else:
16071 
          iprot.skip(ftype)
16072 
      else:
16073 
        iprot.skip(ftype)
16074 
      iprot.readFieldEnd()
16075 
    iprot.readStructEnd()
16076 
 
16077 
  def write(self, oprot):
16078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16080 
      return
16081 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16082 
    if self.freebieItem is not None:
16083 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16084 
      self.freebieItem.write(oprot)
16085 
      oprot.writeFieldEnd()
16086 
    oprot.writeFieldStop()
16087 
    oprot.writeStructEnd()
16088 
 
16089 
  def validate(self):
16090 
    return
16091 
 
16092 
 
16093 
  def __repr__(self):
16094 
    L = ['%s=%r' % (key, value)
16095 
      for key, value in self.__dict__.iteritems()]
16096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16097 
 
16098 
  def __eq__(self, other):
16099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16100 
 
16101 
  def __ne__(self, other):
16102 
    return not (self == other)
16103 
 
16104 
class addOrUpdateFreebieForItem_result:
16105 
 
16106 
  thrift_spec = (
16107 
  )
16108 
 
16109 
  def read(self, iprot):
16110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16112 
      return
16113 
    iprot.readStructBegin()
16114 
    while True:
16115 
      (fname, ftype, fid) = iprot.readFieldBegin()
16116 
      if ftype == TType.STOP:
16117 
        break
16118 
      else:
16119 
        iprot.skip(ftype)
16120 
      iprot.readFieldEnd()
16121 
    iprot.readStructEnd()
16122 
 
16123 
  def write(self, oprot):
16124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16126 
      return
16127 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16128 
    oprot.writeFieldStop()
16129 
    oprot.writeStructEnd()
16130 
 
16131 
  def validate(self):
16132 
    return
16133 
 
16134 
 
16135 
  def __repr__(self):
16136 
    L = ['%s=%r' % (key, value)
16137 
      for key, value in self.__dict__.iteritems()]
16138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16139 
 
16140 
  def __eq__(self, other):
16141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16142 
 
16143 
  def __ne__(self, other):
16144 
    return not (self == other)
7256 rajveer 16145 
 
7272 amit.gupta 16146 
class addOrUpdateBrandInfo_args:
16147 
  """
16148 
  Attributes:
16149 
   - brandInfo
16150 
  """
16151 
 
16152 
  thrift_spec = (
16153 
    None, # 0
16154 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16155 
  )
16156 
 
16157 
  def __init__(self, brandInfo=None,):
16158 
    self.brandInfo = brandInfo
16159 
 
16160 
  def read(self, iprot):
16161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16163 
      return
16164 
    iprot.readStructBegin()
16165 
    while True:
16166 
      (fname, ftype, fid) = iprot.readFieldBegin()
16167 
      if ftype == TType.STOP:
16168 
        break
16169 
      if fid == 1:
16170 
        if ftype == TType.STRUCT:
16171 
          self.brandInfo = BrandInfo()
16172 
          self.brandInfo.read(iprot)
16173 
        else:
16174 
          iprot.skip(ftype)
16175 
      else:
16176 
        iprot.skip(ftype)
16177 
      iprot.readFieldEnd()
16178 
    iprot.readStructEnd()
16179 
 
16180 
  def write(self, oprot):
16181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16183 
      return
16184 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16185 
    if self.brandInfo is not None:
16186 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16187 
      self.brandInfo.write(oprot)
16188 
      oprot.writeFieldEnd()
16189 
    oprot.writeFieldStop()
16190 
    oprot.writeStructEnd()
16191 
 
16192 
  def validate(self):
16193 
    return
16194 
 
16195 
 
16196 
  def __repr__(self):
16197 
    L = ['%s=%r' % (key, value)
16198 
      for key, value in self.__dict__.iteritems()]
16199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16200 
 
16201 
  def __eq__(self, other):
16202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16203 
 
16204 
  def __ne__(self, other):
16205 
    return not (self == other)
16206 
 
16207 
class addOrUpdateBrandInfo_result:
16208 
 
16209 
  thrift_spec = (
16210 
  )
16211 
 
16212 
  def read(self, iprot):
16213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16215 
      return
16216 
    iprot.readStructBegin()
16217 
    while True:
16218 
      (fname, ftype, fid) = iprot.readFieldBegin()
16219 
      if ftype == TType.STOP:
16220 
        break
16221 
      else:
16222 
        iprot.skip(ftype)
16223 
      iprot.readFieldEnd()
16224 
    iprot.readStructEnd()
16225 
 
16226 
  def write(self, oprot):
16227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16229 
      return
16230 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16231 
    oprot.writeFieldStop()
16232 
    oprot.writeStructEnd()
16233 
 
16234 
  def validate(self):
16235 
    return
16236 
 
16237 
 
16238 
  def __repr__(self):
16239 
    L = ['%s=%r' % (key, value)
16240 
      for key, value in self.__dict__.iteritems()]
16241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16242 
 
16243 
  def __eq__(self, other):
16244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16245 
 
16246 
  def __ne__(self, other):
16247 
    return not (self == other)
16248 
 
16249 
class getBrandInfo_args:
16250 
 
16251 
  thrift_spec = (
16252 
  )
16253 
 
16254 
  def read(self, iprot):
16255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16257 
      return
16258 
    iprot.readStructBegin()
16259 
    while True:
16260 
      (fname, ftype, fid) = iprot.readFieldBegin()
16261 
      if ftype == TType.STOP:
16262 
        break
16263 
      else:
16264 
        iprot.skip(ftype)
16265 
      iprot.readFieldEnd()
16266 
    iprot.readStructEnd()
16267 
 
16268 
  def write(self, oprot):
16269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16271 
      return
16272 
    oprot.writeStructBegin('getBrandInfo_args')
16273 
    oprot.writeFieldStop()
16274 
    oprot.writeStructEnd()
16275 
 
16276 
  def validate(self):
16277 
    return
16278 
 
16279 
 
16280 
  def __repr__(self):
16281 
    L = ['%s=%r' % (key, value)
16282 
      for key, value in self.__dict__.iteritems()]
16283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16284 
 
16285 
  def __eq__(self, other):
16286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16287 
 
16288 
  def __ne__(self, other):
16289 
    return not (self == other)
16290 
 
16291 
class getBrandInfo_result:
16292 
  """
16293 
  Attributes:
16294 
   - success
16295 
  """
16296 
 
16297 
  thrift_spec = (
16298 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16299 
  )
16300 
 
16301 
  def __init__(self, success=None,):
16302 
    self.success = success
16303 
 
16304 
  def read(self, iprot):
16305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16307 
      return
16308 
    iprot.readStructBegin()
16309 
    while True:
16310 
      (fname, ftype, fid) = iprot.readFieldBegin()
16311 
      if ftype == TType.STOP:
16312 
        break
16313 
      if fid == 0:
16314 
        if ftype == TType.MAP:
16315 
          self.success = {}
16316 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16317 
          for _i302 in xrange(_size298):
16318 
            _key303 = iprot.readString();
16319 
            _val304 = BrandInfo()
16320 
            _val304.read(iprot)
16321 
            self.success[_key303] = _val304
16322 
          iprot.readMapEnd()
16323 
        else:
16324 
          iprot.skip(ftype)
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('getBrandInfo_result')
16335 
    if self.success is not None:
16336 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16337 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16338 
      for kiter305,viter306 in self.success.items():
16339 
        oprot.writeString(kiter305)
16340 
        viter306.write(oprot)
16341 
      oprot.writeMapEnd()
16342 
      oprot.writeFieldEnd()
16343 
    oprot.writeFieldStop()
16344 
    oprot.writeStructEnd()
16345 
 
16346 
  def validate(self):
16347 
    return
16348 
 
16349 
 
16350 
  def __repr__(self):
16351 
    L = ['%s=%r' % (key, value)
16352 
      for key, value in self.__dict__.iteritems()]
16353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16354 
 
16355 
  def __eq__(self, other):
16356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16357 
 
16358 
  def __ne__(self, other):
16359 
    return not (self == other)
16360 
 
7256 rajveer 16361 
class getStorePricing_args:
16362 
  """
16363 
  Attributes:
16364 
   - itemId
16365 
  """
16366 
 
16367 
  thrift_spec = (
16368 
    None, # 0
16369 
    (1, TType.I64, 'itemId', None, None, ), # 1
16370 
  )
16371 
 
16372 
  def __init__(self, itemId=None,):
16373 
    self.itemId = itemId
16374 
 
16375 
  def read(self, iprot):
16376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16378 
      return
16379 
    iprot.readStructBegin()
16380 
    while True:
16381 
      (fname, ftype, fid) = iprot.readFieldBegin()
16382 
      if ftype == TType.STOP:
16383 
        break
16384 
      if fid == 1:
16385 
        if ftype == TType.I64:
16386 
          self.itemId = iprot.readI64();
16387 
        else:
16388 
          iprot.skip(ftype)
16389 
      else:
16390 
        iprot.skip(ftype)
16391 
      iprot.readFieldEnd()
16392 
    iprot.readStructEnd()
16393 
 
16394 
  def write(self, oprot):
16395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16397 
      return
16398 
    oprot.writeStructBegin('getStorePricing_args')
16399 
    if self.itemId is not None:
16400 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16401 
      oprot.writeI64(self.itemId)
16402 
      oprot.writeFieldEnd()
16403 
    oprot.writeFieldStop()
16404 
    oprot.writeStructEnd()
16405 
 
16406 
  def validate(self):
16407 
    return
16408 
 
16409 
 
16410 
  def __repr__(self):
16411 
    L = ['%s=%r' % (key, value)
16412 
      for key, value in self.__dict__.iteritems()]
16413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16414 
 
16415 
  def __eq__(self, other):
16416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16417 
 
16418 
  def __ne__(self, other):
16419 
    return not (self == other)
16420 
 
16421 
class getStorePricing_result:
16422 
  """
16423 
  Attributes:
16424 
   - success
16425 
  """
16426 
 
16427 
  thrift_spec = (
16428 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16429 
  )
16430 
 
16431 
  def __init__(self, success=None,):
16432 
    self.success = success
16433 
 
16434 
  def read(self, iprot):
16435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16437 
      return
16438 
    iprot.readStructBegin()
16439 
    while True:
16440 
      (fname, ftype, fid) = iprot.readFieldBegin()
16441 
      if ftype == TType.STOP:
16442 
        break
16443 
      if fid == 0:
16444 
        if ftype == TType.STRUCT:
16445 
          self.success = StorePricing()
16446 
          self.success.read(iprot)
16447 
        else:
16448 
          iprot.skip(ftype)
16449 
      else:
16450 
        iprot.skip(ftype)
16451 
      iprot.readFieldEnd()
16452 
    iprot.readStructEnd()
16453 
 
16454 
  def write(self, oprot):
16455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16457 
      return
16458 
    oprot.writeStructBegin('getStorePricing_result')
16459 
    if self.success is not None:
16460 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16461 
      self.success.write(oprot)
16462 
      oprot.writeFieldEnd()
16463 
    oprot.writeFieldStop()
16464 
    oprot.writeStructEnd()
16465 
 
16466 
  def validate(self):
16467 
    return
16468 
 
16469 
 
16470 
  def __repr__(self):
16471 
    L = ['%s=%r' % (key, value)
16472 
      for key, value in self.__dict__.iteritems()]
16473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16474 
 
16475 
  def __eq__(self, other):
16476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16477 
 
16478 
  def __ne__(self, other):
16479 
    return not (self == other)
7265 rajveer 16480 
 
7306 rajveer 16481 
class getStorePricings_args:
16482 
  """
16483 
  Attributes:
16484 
   - itemIds
16485 
  """
16486 
 
16487 
  thrift_spec = (
16488 
    None, # 0
16489 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16490 
  )
16491 
 
16492 
  def __init__(self, itemIds=None,):
16493 
    self.itemIds = itemIds
16494 
 
16495 
  def read(self, iprot):
16496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16498 
      return
16499 
    iprot.readStructBegin()
16500 
    while True:
16501 
      (fname, ftype, fid) = iprot.readFieldBegin()
16502 
      if ftype == TType.STOP:
16503 
        break
16504 
      if fid == 1:
16505 
        if ftype == TType.LIST:
16506 
          self.itemIds = []
16507 
          (_etype310, _size307) = iprot.readListBegin()
16508 
          for _i311 in xrange(_size307):
16509 
            _elem312 = iprot.readI64();
16510 
            self.itemIds.append(_elem312)
16511 
          iprot.readListEnd()
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      else:
16515 
        iprot.skip(ftype)
16516 
      iprot.readFieldEnd()
16517 
    iprot.readStructEnd()
16518 
 
16519 
  def write(self, oprot):
16520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16522 
      return
16523 
    oprot.writeStructBegin('getStorePricings_args')
16524 
    if self.itemIds is not None:
16525 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16526 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
16527 
      for iter313 in self.itemIds:
16528 
        oprot.writeI64(iter313)
16529 
      oprot.writeListEnd()
16530 
      oprot.writeFieldEnd()
16531 
    oprot.writeFieldStop()
16532 
    oprot.writeStructEnd()
16533 
 
16534 
  def validate(self):
16535 
    return
16536 
 
16537 
 
16538 
  def __repr__(self):
16539 
    L = ['%s=%r' % (key, value)
16540 
      for key, value in self.__dict__.iteritems()]
16541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16542 
 
16543 
  def __eq__(self, other):
16544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16545 
 
16546 
  def __ne__(self, other):
16547 
    return not (self == other)
16548 
 
16549 
class getStorePricings_result:
16550 
  """
16551 
  Attributes:
16552 
   - success
16553 
  """
16554 
 
16555 
  thrift_spec = (
16556 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16557 
  )
16558 
 
16559 
  def __init__(self, success=None,):
16560 
    self.success = success
16561 
 
16562 
  def read(self, iprot):
16563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16565 
      return
16566 
    iprot.readStructBegin()
16567 
    while True:
16568 
      (fname, ftype, fid) = iprot.readFieldBegin()
16569 
      if ftype == TType.STOP:
16570 
        break
16571 
      if fid == 0:
16572 
        if ftype == TType.LIST:
16573 
          self.success = []
16574 
          (_etype317, _size314) = iprot.readListBegin()
16575 
          for _i318 in xrange(_size314):
16576 
            _elem319 = StorePricing()
16577 
            _elem319.read(iprot)
16578 
            self.success.append(_elem319)
16579 
          iprot.readListEnd()
16580 
        else:
16581 
          iprot.skip(ftype)
16582 
      else:
16583 
        iprot.skip(ftype)
16584 
      iprot.readFieldEnd()
16585 
    iprot.readStructEnd()
16586 
 
16587 
  def write(self, oprot):
16588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16590 
      return
16591 
    oprot.writeStructBegin('getStorePricings_result')
16592 
    if self.success is not None:
16593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16595 
      for iter320 in self.success:
16596 
        iter320.write(oprot)
16597 
      oprot.writeListEnd()
16598 
      oprot.writeFieldEnd()
16599 
    oprot.writeFieldStop()
16600 
    oprot.writeStructEnd()
16601 
 
16602 
  def validate(self):
16603 
    return
16604 
 
16605 
 
16606 
  def __repr__(self):
16607 
    L = ['%s=%r' % (key, value)
16608 
      for key, value in self.__dict__.iteritems()]
16609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16610 
 
16611 
  def __eq__(self, other):
16612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16613 
 
16614 
  def __ne__(self, other):
16615 
    return not (self == other)
16616 
 
7265 rajveer 16617 
class updateStorePricing_args:
16618 
  """
16619 
  Attributes:
16620 
   - sp
16621 
  """
16622 
 
16623 
  thrift_spec = (
16624 
    None, # 0
16625 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16626 
  )
16627 
 
16628 
  def __init__(self, sp=None,):
16629 
    self.sp = sp
16630 
 
16631 
  def read(self, iprot):
16632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16634 
      return
16635 
    iprot.readStructBegin()
16636 
    while True:
16637 
      (fname, ftype, fid) = iprot.readFieldBegin()
16638 
      if ftype == TType.STOP:
16639 
        break
16640 
      if fid == 1:
16641 
        if ftype == TType.STRUCT:
16642 
          self.sp = StorePricing()
16643 
          self.sp.read(iprot)
16644 
        else:
16645 
          iprot.skip(ftype)
16646 
      else:
16647 
        iprot.skip(ftype)
16648 
      iprot.readFieldEnd()
16649 
    iprot.readStructEnd()
16650 
 
16651 
  def write(self, oprot):
16652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16654 
      return
16655 
    oprot.writeStructBegin('updateStorePricing_args')
16656 
    if self.sp is not None:
16657 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16658 
      self.sp.write(oprot)
16659 
      oprot.writeFieldEnd()
16660 
    oprot.writeFieldStop()
16661 
    oprot.writeStructEnd()
16662 
 
16663 
  def validate(self):
16664 
    return
16665 
 
16666 
 
16667 
  def __repr__(self):
16668 
    L = ['%s=%r' % (key, value)
16669 
      for key, value in self.__dict__.iteritems()]
16670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16671 
 
16672 
  def __eq__(self, other):
16673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16674 
 
16675 
  def __ne__(self, other):
16676 
    return not (self == other)
16677 
 
16678 
class updateStorePricing_result:
16679 
 
16680 
  thrift_spec = (
16681 
  )
16682 
 
16683 
  def read(self, iprot):
16684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16686 
      return
16687 
    iprot.readStructBegin()
16688 
    while True:
16689 
      (fname, ftype, fid) = iprot.readFieldBegin()
16690 
      if ftype == TType.STOP:
16691 
        break
16692 
      else:
16693 
        iprot.skip(ftype)
16694 
      iprot.readFieldEnd()
16695 
    iprot.readStructEnd()
16696 
 
16697 
  def write(self, oprot):
16698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16700 
      return
16701 
    oprot.writeStructBegin('updateStorePricing_result')
16702 
    oprot.writeFieldStop()
16703 
    oprot.writeStructEnd()
16704 
 
16705 
  def validate(self):
16706 
    return
16707 
 
16708 
 
16709 
  def __repr__(self):
16710 
    L = ['%s=%r' % (key, value)
16711 
      for key, value in self.__dict__.iteritems()]
16712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16713 
 
16714 
  def __eq__(self, other):
16715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16716 
 
16717 
  def __ne__(self, other):
16718 
    return not (self == other)
7281 kshitij.so 16719 
 
16720 
class getAllAmazonListedItems_args:
16721 
 
16722 
  thrift_spec = (
16723 
  )
16724 
 
16725 
  def read(self, iprot):
16726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16728 
      return
16729 
    iprot.readStructBegin()
16730 
    while True:
16731 
      (fname, ftype, fid) = iprot.readFieldBegin()
16732 
      if ftype == TType.STOP:
16733 
        break
16734 
      else:
16735 
        iprot.skip(ftype)
16736 
      iprot.readFieldEnd()
16737 
    iprot.readStructEnd()
16738 
 
16739 
  def write(self, oprot):
16740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16742 
      return
16743 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16744 
    oprot.writeFieldStop()
16745 
    oprot.writeStructEnd()
16746 
 
16747 
  def validate(self):
16748 
    return
16749 
 
16750 
 
16751 
  def __repr__(self):
16752 
    L = ['%s=%r' % (key, value)
16753 
      for key, value in self.__dict__.iteritems()]
16754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16755 
 
16756 
  def __eq__(self, other):
16757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16758 
 
16759 
  def __ne__(self, other):
16760 
    return not (self == other)
16761 
 
16762 
class getAllAmazonListedItems_result:
16763 
  """
16764 
  Attributes:
16765 
   - success
16766 
  """
16767 
 
16768 
  thrift_spec = (
16769 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16770 
  )
16771 
 
16772 
  def __init__(self, success=None,):
16773 
    self.success = success
16774 
 
16775 
  def read(self, iprot):
16776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16778 
      return
16779 
    iprot.readStructBegin()
16780 
    while True:
16781 
      (fname, ftype, fid) = iprot.readFieldBegin()
16782 
      if ftype == TType.STOP:
16783 
        break
16784 
      if fid == 0:
16785 
        if ftype == TType.LIST:
16786 
          self.success = []
7306 rajveer 16787 
          (_etype324, _size321) = iprot.readListBegin()
16788 
          for _i325 in xrange(_size321):
16789 
            _elem326 = Amazonlisted()
16790 
            _elem326.read(iprot)
16791 
            self.success.append(_elem326)
7281 kshitij.so 16792 
          iprot.readListEnd()
16793 
        else:
16794 
          iprot.skip(ftype)
16795 
      else:
16796 
        iprot.skip(ftype)
16797 
      iprot.readFieldEnd()
16798 
    iprot.readStructEnd()
16799 
 
16800 
  def write(self, oprot):
16801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16803 
      return
16804 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16805 
    if self.success is not None:
16806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 16808 
      for iter327 in self.success:
16809 
        iter327.write(oprot)
7281 kshitij.so 16810 
      oprot.writeListEnd()
16811 
      oprot.writeFieldEnd()
16812 
    oprot.writeFieldStop()
16813 
    oprot.writeStructEnd()
16814 
 
16815 
  def validate(self):
16816 
    return
16817 
 
16818 
 
16819 
  def __repr__(self):
16820 
    L = ['%s=%r' % (key, value)
16821 
      for key, value in self.__dict__.iteritems()]
16822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16823 
 
16824 
  def __eq__(self, other):
16825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16826 
 
16827 
  def __ne__(self, other):
16828 
    return not (self == other)
16829 
 
16830 
class getAmazonItemDetails_args:
16831 
  """
16832 
  Attributes:
16833 
   - itemId
16834 
  """
16835 
 
16836 
  thrift_spec = (
16837 
    None, # 0
16838 
    (1, TType.I64, 'itemId', None, None, ), # 1
16839 
  )
16840 
 
16841 
  def __init__(self, itemId=None,):
16842 
    self.itemId = itemId
16843 
 
16844 
  def read(self, iprot):
16845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16847 
      return
16848 
    iprot.readStructBegin()
16849 
    while True:
16850 
      (fname, ftype, fid) = iprot.readFieldBegin()
16851 
      if ftype == TType.STOP:
16852 
        break
16853 
      if fid == 1:
16854 
        if ftype == TType.I64:
16855 
          self.itemId = iprot.readI64();
16856 
        else:
16857 
          iprot.skip(ftype)
16858 
      else:
16859 
        iprot.skip(ftype)
16860 
      iprot.readFieldEnd()
16861 
    iprot.readStructEnd()
16862 
 
16863 
  def write(self, oprot):
16864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16866 
      return
16867 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16868 
    if self.itemId is not None:
16869 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16870 
      oprot.writeI64(self.itemId)
16871 
      oprot.writeFieldEnd()
16872 
    oprot.writeFieldStop()
16873 
    oprot.writeStructEnd()
16874 
 
16875 
  def validate(self):
16876 
    return
16877 
 
16878 
 
16879 
  def __repr__(self):
16880 
    L = ['%s=%r' % (key, value)
16881 
      for key, value in self.__dict__.iteritems()]
16882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16883 
 
16884 
  def __eq__(self, other):
16885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16886 
 
16887 
  def __ne__(self, other):
16888 
    return not (self == other)
16889 
 
16890 
class getAmazonItemDetails_result:
16891 
  """
16892 
  Attributes:
16893 
   - success
16894 
  """
16895 
 
16896 
  thrift_spec = (
16897 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16898 
  )
16899 
 
16900 
  def __init__(self, success=None,):
16901 
    self.success = success
16902 
 
16903 
  def read(self, iprot):
16904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16906 
      return
16907 
    iprot.readStructBegin()
16908 
    while True:
16909 
      (fname, ftype, fid) = iprot.readFieldBegin()
16910 
      if ftype == TType.STOP:
16911 
        break
16912 
      if fid == 0:
16913 
        if ftype == TType.STRUCT:
16914 
          self.success = Amazonlisted()
16915 
          self.success.read(iprot)
16916 
        else:
16917 
          iprot.skip(ftype)
16918 
      else:
16919 
        iprot.skip(ftype)
16920 
      iprot.readFieldEnd()
16921 
    iprot.readStructEnd()
16922 
 
16923 
  def write(self, oprot):
16924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16926 
      return
16927 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16928 
    if self.success is not None:
16929 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16930 
      self.success.write(oprot)
16931 
      oprot.writeFieldEnd()
16932 
    oprot.writeFieldStop()
16933 
    oprot.writeStructEnd()
16934 
 
16935 
  def validate(self):
16936 
    return
16937 
 
16938 
 
16939 
  def __repr__(self):
16940 
    L = ['%s=%r' % (key, value)
16941 
      for key, value in self.__dict__.iteritems()]
16942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16943 
 
16944 
  def __eq__(self, other):
16945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16946 
 
16947 
  def __ne__(self, other):
16948 
    return not (self == other)
16949 
 
16950 
class updateAmazonItemDetails_args:
16951 
  """
16952 
  Attributes:
16953 
   - itemId
16954 
   - fbaPrice
16955 
   - sellingPrice
16956 
   - isFba
16957 
   - isNonFba
16958 
   - isInventoryOverride
7367 kshitij.so 16959 
   - handlingTime
16960 
   - isCustomTime
7281 kshitij.so 16961 
  """
16962 
 
16963 
  thrift_spec = (
16964 
    None, # 0
16965 
    (1, TType.I64, 'itemId', None, None, ), # 1
16966 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16967 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16968 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16969 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16970 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 16971 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
16972 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 16973 
  )
16974 
 
7367 kshitij.so 16975 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 16976 
    self.itemId = itemId
16977 
    self.fbaPrice = fbaPrice
16978 
    self.sellingPrice = sellingPrice
16979 
    self.isFba = isFba
16980 
    self.isNonFba = isNonFba
16981 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 16982 
    self.handlingTime = handlingTime
16983 
    self.isCustomTime = isCustomTime
7281 kshitij.so 16984 
 
16985 
  def read(self, iprot):
16986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16988 
      return
16989 
    iprot.readStructBegin()
16990 
    while True:
16991 
      (fname, ftype, fid) = iprot.readFieldBegin()
16992 
      if ftype == TType.STOP:
16993 
        break
16994 
      if fid == 1:
16995 
        if ftype == TType.I64:
16996 
          self.itemId = iprot.readI64();
16997 
        else:
16998 
          iprot.skip(ftype)
16999 
      elif fid == 2:
17000 
        if ftype == TType.DOUBLE:
17001 
          self.fbaPrice = iprot.readDouble();
17002 
        else:
17003 
          iprot.skip(ftype)
17004 
      elif fid == 3:
17005 
        if ftype == TType.DOUBLE:
17006 
          self.sellingPrice = iprot.readDouble();
17007 
        else:
17008 
          iprot.skip(ftype)
17009 
      elif fid == 4:
17010 
        if ftype == TType.BOOL:
17011 
          self.isFba = iprot.readBool();
17012 
        else:
17013 
          iprot.skip(ftype)
17014 
      elif fid == 5:
17015 
        if ftype == TType.BOOL:
17016 
          self.isNonFba = iprot.readBool();
17017 
        else:
17018 
          iprot.skip(ftype)
17019 
      elif fid == 6:
17020 
        if ftype == TType.BOOL:
17021 
          self.isInventoryOverride = iprot.readBool();
17022 
        else:
17023 
          iprot.skip(ftype)
7367 kshitij.so 17024 
      elif fid == 7:
17025 
        if ftype == TType.I64:
17026 
          self.handlingTime = iprot.readI64();
17027 
        else:
17028 
          iprot.skip(ftype)
17029 
      elif fid == 8:
17030 
        if ftype == TType.BOOL:
17031 
          self.isCustomTime = iprot.readBool();
17032 
        else:
17033 
          iprot.skip(ftype)
7281 kshitij.so 17034 
      else:
17035 
        iprot.skip(ftype)
17036 
      iprot.readFieldEnd()
17037 
    iprot.readStructEnd()
17038 
 
17039 
  def write(self, oprot):
17040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17042 
      return
17043 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17044 
    if self.itemId is not None:
17045 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17046 
      oprot.writeI64(self.itemId)
17047 
      oprot.writeFieldEnd()
17048 
    if self.fbaPrice is not None:
17049 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17050 
      oprot.writeDouble(self.fbaPrice)
17051 
      oprot.writeFieldEnd()
17052 
    if self.sellingPrice is not None:
17053 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17054 
      oprot.writeDouble(self.sellingPrice)
17055 
      oprot.writeFieldEnd()
17056 
    if self.isFba is not None:
17057 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17058 
      oprot.writeBool(self.isFba)
17059 
      oprot.writeFieldEnd()
17060 
    if self.isNonFba is not None:
17061 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17062 
      oprot.writeBool(self.isNonFba)
17063 
      oprot.writeFieldEnd()
17064 
    if self.isInventoryOverride is not None:
17065 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17066 
      oprot.writeBool(self.isInventoryOverride)
17067 
      oprot.writeFieldEnd()
7367 kshitij.so 17068 
    if self.handlingTime is not None:
17069 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17070 
      oprot.writeI64(self.handlingTime)
17071 
      oprot.writeFieldEnd()
17072 
    if self.isCustomTime is not None:
17073 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17074 
      oprot.writeBool(self.isCustomTime)
17075 
      oprot.writeFieldEnd()
7281 kshitij.so 17076 
    oprot.writeFieldStop()
17077 
    oprot.writeStructEnd()
17078 
 
17079 
  def validate(self):
17080 
    return
17081 
 
17082 
 
17083 
  def __repr__(self):
17084 
    L = ['%s=%r' % (key, value)
17085 
      for key, value in self.__dict__.iteritems()]
17086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17087 
 
17088 
  def __eq__(self, other):
17089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17090 
 
17091 
  def __ne__(self, other):
17092 
    return not (self == other)
17093 
 
17094 
class updateAmazonItemDetails_result:
17095 
 
17096 
  thrift_spec = (
17097 
  )
17098 
 
17099 
  def read(self, iprot):
17100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17102 
      return
17103 
    iprot.readStructBegin()
17104 
    while True:
17105 
      (fname, ftype, fid) = iprot.readFieldBegin()
17106 
      if ftype == TType.STOP:
17107 
        break
17108 
      else:
17109 
        iprot.skip(ftype)
17110 
      iprot.readFieldEnd()
17111 
    iprot.readStructEnd()
17112 
 
17113 
  def write(self, oprot):
17114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17116 
      return
17117 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17118 
    oprot.writeFieldStop()
17119 
    oprot.writeStructEnd()
17120 
 
17121 
  def validate(self):
17122 
    return
17123 
 
17124 
 
17125 
  def __repr__(self):
17126 
    L = ['%s=%r' % (key, value)
17127 
      for key, value in self.__dict__.iteritems()]
17128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17129 
 
17130 
  def __eq__(self, other):
17131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17132 
 
17133 
  def __ne__(self, other):
17134 
    return not (self == other)
17135 
 
17136 
class addAmazonItem_args:
17137 
  """
17138 
  Attributes:
17139 
   - amazonlisted
17140 
  """
17141 
 
17142 
  thrift_spec = (
17143 
    None, # 0
17144 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17145 
  )
17146 
 
17147 
  def __init__(self, amazonlisted=None,):
17148 
    self.amazonlisted = amazonlisted
17149 
 
17150 
  def read(self, iprot):
17151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17153 
      return
17154 
    iprot.readStructBegin()
17155 
    while True:
17156 
      (fname, ftype, fid) = iprot.readFieldBegin()
17157 
      if ftype == TType.STOP:
17158 
        break
17159 
      if fid == 1:
17160 
        if ftype == TType.STRUCT:
17161 
          self.amazonlisted = Amazonlisted()
17162 
          self.amazonlisted.read(iprot)
17163 
        else:
17164 
          iprot.skip(ftype)
17165 
      else:
17166 
        iprot.skip(ftype)
17167 
      iprot.readFieldEnd()
17168 
    iprot.readStructEnd()
17169 
 
17170 
  def write(self, oprot):
17171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17173 
      return
17174 
    oprot.writeStructBegin('addAmazonItem_args')
17175 
    if self.amazonlisted is not None:
17176 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17177 
      self.amazonlisted.write(oprot)
17178 
      oprot.writeFieldEnd()
17179 
    oprot.writeFieldStop()
17180 
    oprot.writeStructEnd()
17181 
 
17182 
  def validate(self):
17183 
    return
17184 
 
17185 
 
17186 
  def __repr__(self):
17187 
    L = ['%s=%r' % (key, value)
17188 
      for key, value in self.__dict__.iteritems()]
17189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17190 
 
17191 
  def __eq__(self, other):
17192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17193 
 
17194 
  def __ne__(self, other):
17195 
    return not (self == other)
17196 
 
17197 
class addAmazonItem_result:
17198 
 
17199 
  thrift_spec = (
17200 
  )
17201 
 
17202 
  def read(self, iprot):
17203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17205 
      return
17206 
    iprot.readStructBegin()
17207 
    while True:
17208 
      (fname, ftype, fid) = iprot.readFieldBegin()
17209 
      if ftype == TType.STOP:
17210 
        break
17211 
      else:
17212 
        iprot.skip(ftype)
17213 
      iprot.readFieldEnd()
17214 
    iprot.readStructEnd()
17215 
 
17216 
  def write(self, oprot):
17217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17219 
      return
17220 
    oprot.writeStructBegin('addAmazonItem_result')
17221 
    oprot.writeFieldStop()
17222 
    oprot.writeStructEnd()
17223 
 
17224 
  def validate(self):
17225 
    return
17226 
 
17227 
 
17228 
  def __repr__(self):
17229 
    L = ['%s=%r' % (key, value)
17230 
      for key, value in self.__dict__.iteritems()]
17231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17232 
 
17233 
  def __eq__(self, other):
17234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17235 
 
17236 
  def __ne__(self, other):
17237 
    return not (self == other)
7291 vikram.rag 17238 
 
17239 
class getAsinItems_args:
17240 
 
17241 
  thrift_spec = (
17242 
  )
17243 
 
17244 
  def read(self, iprot):
17245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17247 
      return
17248 
    iprot.readStructBegin()
17249 
    while True:
17250 
      (fname, ftype, fid) = iprot.readFieldBegin()
17251 
      if ftype == TType.STOP:
17252 
        break
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('getAsinItems_args')
17263 
    oprot.writeFieldStop()
17264 
    oprot.writeStructEnd()
17265 
 
17266 
  def validate(self):
17267 
    return
17268 
 
17269 
 
17270 
  def __repr__(self):
17271 
    L = ['%s=%r' % (key, value)
17272 
      for key, value in self.__dict__.iteritems()]
17273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17274 
 
17275 
  def __eq__(self, other):
17276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17277 
 
17278 
  def __ne__(self, other):
17279 
    return not (self == other)
17280 
 
17281 
class getAsinItems_result:
17282 
  """
17283 
  Attributes:
17284 
   - success
17285 
  """
17286 
 
17287 
  thrift_spec = (
17288 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17289 
  )
17290 
 
17291 
  def __init__(self, success=None,):
17292 
    self.success = success
17293 
 
17294 
  def read(self, iprot):
17295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17297 
      return
17298 
    iprot.readStructBegin()
17299 
    while True:
17300 
      (fname, ftype, fid) = iprot.readFieldBegin()
17301 
      if ftype == TType.STOP:
17302 
        break
17303 
      if fid == 0:
17304 
        if ftype == TType.LIST:
17305 
          self.success = []
7306 rajveer 17306 
          (_etype331, _size328) = iprot.readListBegin()
17307 
          for _i332 in xrange(_size328):
17308 
            _elem333 = Item()
17309 
            _elem333.read(iprot)
17310 
            self.success.append(_elem333)
7291 vikram.rag 17311 
          iprot.readListEnd()
17312 
        else:
17313 
          iprot.skip(ftype)
17314 
      else:
17315 
        iprot.skip(ftype)
17316 
      iprot.readFieldEnd()
17317 
    iprot.readStructEnd()
17318 
 
17319 
  def write(self, oprot):
17320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17322 
      return
17323 
    oprot.writeStructBegin('getAsinItems_result')
17324 
    if self.success is not None:
17325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17327 
      for iter334 in self.success:
17328 
        iter334.write(oprot)
7291 vikram.rag 17329 
      oprot.writeListEnd()
17330 
      oprot.writeFieldEnd()
17331 
    oprot.writeFieldStop()
17332 
    oprot.writeStructEnd()
17333 
 
17334 
  def validate(self):
17335 
    return
17336 
 
17337 
 
17338 
  def __repr__(self):
17339 
    L = ['%s=%r' % (key, value)
17340 
      for key, value in self.__dict__.iteritems()]
17341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17342 
 
17343 
  def __eq__(self, other):
17344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17345 
 
17346 
  def __ne__(self, other):
17347 
    return not (self == other)
17348 
 
17349 
class getAllFbaListedItems_args:
17350 
 
17351 
  thrift_spec = (
17352 
  )
17353 
 
17354 
  def read(self, iprot):
17355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17357 
      return
17358 
    iprot.readStructBegin()
17359 
    while True:
17360 
      (fname, ftype, fid) = iprot.readFieldBegin()
17361 
      if ftype == TType.STOP:
17362 
        break
17363 
      else:
17364 
        iprot.skip(ftype)
17365 
      iprot.readFieldEnd()
17366 
    iprot.readStructEnd()
17367 
 
17368 
  def write(self, oprot):
17369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17371 
      return
17372 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17373 
    oprot.writeFieldStop()
17374 
    oprot.writeStructEnd()
17375 
 
17376 
  def validate(self):
17377 
    return
17378 
 
17379 
 
17380 
  def __repr__(self):
17381 
    L = ['%s=%r' % (key, value)
17382 
      for key, value in self.__dict__.iteritems()]
17383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17384 
 
17385 
  def __eq__(self, other):
17386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17387 
 
17388 
  def __ne__(self, other):
17389 
    return not (self == other)
17390 
 
17391 
class getAllFbaListedItems_result:
17392 
  """
17393 
  Attributes:
17394 
   - success
17395 
  """
17396 
 
17397 
  thrift_spec = (
17398 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17399 
  )
17400 
 
17401 
  def __init__(self, success=None,):
17402 
    self.success = success
17403 
 
17404 
  def read(self, iprot):
17405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17407 
      return
17408 
    iprot.readStructBegin()
17409 
    while True:
17410 
      (fname, ftype, fid) = iprot.readFieldBegin()
17411 
      if ftype == TType.STOP:
17412 
        break
17413 
      if fid == 0:
17414 
        if ftype == TType.LIST:
17415 
          self.success = []
7306 rajveer 17416 
          (_etype338, _size335) = iprot.readListBegin()
17417 
          for _i339 in xrange(_size335):
17418 
            _elem340 = Amazonlisted()
17419 
            _elem340.read(iprot)
17420 
            self.success.append(_elem340)
7291 vikram.rag 17421 
          iprot.readListEnd()
17422 
        else:
17423 
          iprot.skip(ftype)
17424 
      else:
17425 
        iprot.skip(ftype)
17426 
      iprot.readFieldEnd()
17427 
    iprot.readStructEnd()
17428 
 
17429 
  def write(self, oprot):
17430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17432 
      return
17433 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17434 
    if self.success is not None:
17435 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17436 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17437 
      for iter341 in self.success:
17438 
        iter341.write(oprot)
7291 vikram.rag 17439 
      oprot.writeListEnd()
17440 
      oprot.writeFieldEnd()
17441 
    oprot.writeFieldStop()
17442 
    oprot.writeStructEnd()
17443 
 
17444 
  def validate(self):
17445 
    return
17446 
 
17447 
 
17448 
  def __repr__(self):
17449 
    L = ['%s=%r' % (key, value)
17450 
      for key, value in self.__dict__.iteritems()]
17451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17452 
 
17453 
  def __eq__(self, other):
17454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17455 
 
17456 
  def __ne__(self, other):
17457 
    return not (self == other)
17458 
 
17459 
class getAllNonFbaListedItems_args:
17460 
 
17461 
  thrift_spec = (
17462 
  )
17463 
 
17464 
  def read(self, iprot):
17465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17467 
      return
17468 
    iprot.readStructBegin()
17469 
    while True:
17470 
      (fname, ftype, fid) = iprot.readFieldBegin()
17471 
      if ftype == TType.STOP:
17472 
        break
17473 
      else:
17474 
        iprot.skip(ftype)
17475 
      iprot.readFieldEnd()
17476 
    iprot.readStructEnd()
17477 
 
17478 
  def write(self, oprot):
17479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17481 
      return
17482 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17483 
    oprot.writeFieldStop()
17484 
    oprot.writeStructEnd()
17485 
 
17486 
  def validate(self):
17487 
    return
17488 
 
17489 
 
17490 
  def __repr__(self):
17491 
    L = ['%s=%r' % (key, value)
17492 
      for key, value in self.__dict__.iteritems()]
17493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17494 
 
17495 
  def __eq__(self, other):
17496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17497 
 
17498 
  def __ne__(self, other):
17499 
    return not (self == other)
17500 
 
17501 
class getAllNonFbaListedItems_result:
17502 
  """
17503 
  Attributes:
17504 
   - success
17505 
  """
17506 
 
17507 
  thrift_spec = (
17508 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17509 
  )
17510 
 
17511 
  def __init__(self, success=None,):
17512 
    self.success = success
17513 
 
17514 
  def read(self, iprot):
17515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17517 
      return
17518 
    iprot.readStructBegin()
17519 
    while True:
17520 
      (fname, ftype, fid) = iprot.readFieldBegin()
17521 
      if ftype == TType.STOP:
17522 
        break
17523 
      if fid == 0:
17524 
        if ftype == TType.LIST:
17525 
          self.success = []
7306 rajveer 17526 
          (_etype345, _size342) = iprot.readListBegin()
17527 
          for _i346 in xrange(_size342):
17528 
            _elem347 = Amazonlisted()
17529 
            _elem347.read(iprot)
17530 
            self.success.append(_elem347)
7291 vikram.rag 17531 
          iprot.readListEnd()
17532 
        else:
17533 
          iprot.skip(ftype)
17534 
      else:
17535 
        iprot.skip(ftype)
17536 
      iprot.readFieldEnd()
17537 
    iprot.readStructEnd()
17538 
 
17539 
  def write(self, oprot):
17540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17542 
      return
17543 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17544 
    if self.success is not None:
17545 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17546 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17547 
      for iter348 in self.success:
17548 
        iter348.write(oprot)
7291 vikram.rag 17549 
      oprot.writeListEnd()
17550 
      oprot.writeFieldEnd()
17551 
    oprot.writeFieldStop()
17552 
    oprot.writeStructEnd()
17553 
 
17554 
  def validate(self):
17555 
    return
17556 
 
17557 
 
17558 
  def __repr__(self):
17559 
    L = ['%s=%r' % (key, value)
17560 
      for key, value in self.__dict__.iteritems()]
17561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17562 
 
17563 
  def __eq__(self, other):
17564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17565 
 
17566 
  def __ne__(self, other):
17567 
    return not (self == other)