Subversion Repositories SmartDukaan

Rev

Rev 7272 | Rev 7291 | 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 
 
6039 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, price):
599 
    """
600 
    Parameters:
601 
     - itemId
602 
     - price
603 
    """
604 
    pass
5944 mandeep.dh 605 
 
6039 amit.gupta 606 
  def getVatAmountForItem(self, itemId, price):
607 
    """
608 
    Parameters:
609 
     - itemId
610 
     - price
611 
    """
612 
    pass
613 
 
6531 vikram.rag 614 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
615 
    """
616 
    Parameters:
617 
     - offset
618 
     - limit
619 
    """
620 
    pass
6039 amit.gupta 621 
 
6821 amar.kumar 622 
  def getAllAliveItems(self, ):
623 
    pass
624 
 
6921 anupam.sin 625 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 626 
    """
627 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 628 
 
6805 anupam.sin 629 
    Parameters:
630 
     - itemId
6921 anupam.sin 631 
     - price
6805 anupam.sin 632 
     - insurerId
633 
     - quantity
634 
    """
635 
    pass
636 
 
637 
  def getInsurer(self, insurerId):
638 
    """
639 
    Parameters:
640 
     - insurerId
641 
    """
642 
    pass
643 
 
6838 vikram.rag 644 
  def getAllInsurers(self, ):
645 
    pass
6805 anupam.sin 646 
 
6962 rajveer 647 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
648 
    """
649 
    Parameters:
650 
     - insurerId
651 
     - amount
652 
    """
653 
    pass
6838 vikram.rag 654 
 
7190 amar.kumar 655 
  def getFreebieForItem(self, itemId):
656 
    """
657 
    Parameters:
658 
     - itemId
659 
    """
660 
    pass
6962 rajveer 661 
 
7190 amar.kumar 662 
  def addOrUpdateFreebieForItem(self, freebieItem):
663 
    """
664 
    Parameters:
665 
     - freebieItem
666 
    """
667 
    pass
668 
 
7272 amit.gupta 669 
  def addOrUpdateBrandInfo(self, brandInfo):
670 
    """
671 
    Parameters:
672 
     - brandInfo
673 
    """
674 
    pass
675 
 
676 
  def getBrandInfo(self, ):
677 
    pass
678 
 
7256 rajveer 679 
  def getStorePricing(self, itemId):
680 
    """
681 
    Parameters:
682 
     - itemId
683 
    """
684 
    pass
7190 amar.kumar 685 
 
7265 rajveer 686 
  def updateStorePricing(self, sp):
687 
    """
688 
    Parameters:
689 
     - sp
690 
    """
691 
    pass
7256 rajveer 692 
 
7281 kshitij.so 693 
  def getAllAmazonListedItems(self, ):
694 
    pass
7265 rajveer 695 
 
7281 kshitij.so 696 
  def getAmazonItemDetails(self, itemId):
697 
    """
698 
    Parameters:
699 
     - itemId
700 
    """
701 
    pass
702 
 
703 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
704 
    """
705 
    Parameters:
706 
     - itemId
707 
     - fbaPrice
708 
     - sellingPrice
709 
     - isFba
710 
     - isNonFba
711 
     - isInventoryOverride
712 
    """
713 
    pass
714 
 
715 
  def addAmazonItem(self, amazonlisted):
716 
    """
717 
    Parameters:
718 
     - amazonlisted
719 
    """
720 
    pass
721 
 
722 
 
5944 mandeep.dh 723 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
724 
  def __init__(self, iprot, oprot=None):
725 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
726 
 
727 
  def addItem(self, item):
728 
    """
729 
    Availability and inventory attributes
730 
 
731 
    Parameters:
732 
     - item
733 
    """
734 
    self.send_addItem(item)
735 
    return self.recv_addItem()
736 
 
737 
  def send_addItem(self, item):
738 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
739 
    args = addItem_args()
740 
    args.item = item
741 
    args.write(self._oprot)
742 
    self._oprot.writeMessageEnd()
743 
    self._oprot.trans.flush()
744 
 
745 
  def recv_addItem(self, ):
746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
747 
    if mtype == TMessageType.EXCEPTION:
748 
      x = TApplicationException()
749 
      x.read(self._iprot)
750 
      self._iprot.readMessageEnd()
751 
      raise x
752 
    result = addItem_result()
753 
    result.read(self._iprot)
754 
    self._iprot.readMessageEnd()
755 
    if result.success is not None:
756 
      return result.success
757 
    if result.cex is not None:
758 
      raise result.cex
759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
760 
 
761 
  def updateItem(self, item):
762 
    """
763 
    Parameters:
764 
     - item
765 
    """
766 
    self.send_updateItem(item)
767 
    return self.recv_updateItem()
768 
 
769 
  def send_updateItem(self, item):
770 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
771 
    args = updateItem_args()
772 
    args.item = item
773 
    args.write(self._oprot)
774 
    self._oprot.writeMessageEnd()
775 
    self._oprot.trans.flush()
776 
 
777 
  def recv_updateItem(self, ):
778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
779 
    if mtype == TMessageType.EXCEPTION:
780 
      x = TApplicationException()
781 
      x.read(self._iprot)
782 
      self._iprot.readMessageEnd()
783 
      raise x
784 
    result = updateItem_result()
785 
    result.read(self._iprot)
786 
    self._iprot.readMessageEnd()
787 
    if result.success is not None:
788 
      return result.success
789 
    if result.cex is not None:
790 
      raise result.cex
791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
792 
 
793 
  def isActive(self, itemId):
794 
    """
795 
    Checks if the item given to the corresponding itemId is active. If it's active,
796 
    whether it's risky and if it's risky, its inventory position.
797 
 
798 
    Parameters:
799 
     - itemId
800 
    """
801 
    self.send_isActive(itemId)
802 
    return self.recv_isActive()
803 
 
804 
  def send_isActive(self, itemId):
805 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
806 
    args = isActive_args()
807 
    args.itemId = itemId
808 
    args.write(self._oprot)
809 
    self._oprot.writeMessageEnd()
810 
    self._oprot.trans.flush()
811 
 
812 
  def recv_isActive(self, ):
813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
814 
    if mtype == TMessageType.EXCEPTION:
815 
      x = TApplicationException()
816 
      x.read(self._iprot)
817 
      self._iprot.readMessageEnd()
818 
      raise x
819 
    result = isActive_result()
820 
    result.read(self._iprot)
821 
    self._iprot.readMessageEnd()
822 
    if result.success is not None:
823 
      return result.success
824 
    if result.isex is not None:
825 
      raise result.isex
826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
827 
 
828 
  def getItemStatusDescription(self, itemId):
829 
    """
830 
    Parameters:
831 
     - itemId
832 
    """
833 
    self.send_getItemStatusDescription(itemId)
834 
    return self.recv_getItemStatusDescription()
835 
 
836 
  def send_getItemStatusDescription(self, itemId):
837 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
838 
    args = getItemStatusDescription_args()
839 
    args.itemId = itemId
840 
    args.write(self._oprot)
841 
    self._oprot.writeMessageEnd()
842 
    self._oprot.trans.flush()
843 
 
844 
  def recv_getItemStatusDescription(self, ):
845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
846 
    if mtype == TMessageType.EXCEPTION:
847 
      x = TApplicationException()
848 
      x.read(self._iprot)
849 
      self._iprot.readMessageEnd()
850 
      raise x
851 
    result = getItemStatusDescription_result()
852 
    result.read(self._iprot)
853 
    self._iprot.readMessageEnd()
854 
    if result.success is not None:
855 
      return result.success
856 
    if result.isex is not None:
857 
      raise result.isex
858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
859 
 
860 
  def startItemOn(self, item_id, timestamp):
861 
    """
862 
    Parameters:
863 
     - item_id
864 
     - timestamp
865 
    """
866 
    self.send_startItemOn(item_id, timestamp)
867 
    self.recv_startItemOn()
868 
 
869 
  def send_startItemOn(self, item_id, timestamp):
870 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
871 
    args = startItemOn_args()
872 
    args.item_id = item_id
873 
    args.timestamp = timestamp
874 
    args.write(self._oprot)
875 
    self._oprot.writeMessageEnd()
876 
    self._oprot.trans.flush()
877 
 
878 
  def recv_startItemOn(self, ):
879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
880 
    if mtype == TMessageType.EXCEPTION:
881 
      x = TApplicationException()
882 
      x.read(self._iprot)
883 
      self._iprot.readMessageEnd()
884 
      raise x
885 
    result = startItemOn_result()
886 
    result.read(self._iprot)
887 
    self._iprot.readMessageEnd()
888 
    if result.cex is not None:
889 
      raise result.cex
890 
    return
891 
 
892 
  def retireItemOn(self, item_id, timestamp):
893 
    """
894 
    Parameters:
895 
     - item_id
896 
     - timestamp
897 
    """
898 
    self.send_retireItemOn(item_id, timestamp)
899 
    self.recv_retireItemOn()
900 
 
901 
  def send_retireItemOn(self, item_id, timestamp):
902 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
903 
    args = retireItemOn_args()
904 
    args.item_id = item_id
905 
    args.timestamp = timestamp
906 
    args.write(self._oprot)
907 
    self._oprot.writeMessageEnd()
908 
    self._oprot.trans.flush()
909 
 
910 
  def recv_retireItemOn(self, ):
911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
912 
    if mtype == TMessageType.EXCEPTION:
913 
      x = TApplicationException()
914 
      x.read(self._iprot)
915 
      self._iprot.readMessageEnd()
916 
      raise x
917 
    result = retireItemOn_result()
918 
    result.read(self._iprot)
919 
    self._iprot.readMessageEnd()
920 
    if result.cex is not None:
921 
      raise result.cex
922 
    return
923 
 
924 
  def changeItemStatus(self, item_id, timestamp, newstatus):
925 
    """
926 
    Parameters:
927 
     - item_id
928 
     - timestamp
929 
     - newstatus
930 
    """
931 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
932 
    self.recv_changeItemStatus()
933 
 
934 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
935 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
936 
    args = changeItemStatus_args()
937 
    args.item_id = item_id
938 
    args.timestamp = timestamp
939 
    args.newstatus = newstatus
940 
    args.write(self._oprot)
941 
    self._oprot.writeMessageEnd()
942 
    self._oprot.trans.flush()
943 
 
944 
  def recv_changeItemStatus(self, ):
945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
946 
    if mtype == TMessageType.EXCEPTION:
947 
      x = TApplicationException()
948 
      x.read(self._iprot)
949 
      self._iprot.readMessageEnd()
950 
      raise x
951 
    result = changeItemStatus_result()
952 
    result.read(self._iprot)
953 
    self._iprot.readMessageEnd()
954 
    if result.cex is not None:
955 
      raise result.cex
956 
    return
957 
 
958 
  def getItem(self, item_id):
959 
    """
960 
    Parameters:
961 
     - item_id
962 
    """
963 
    self.send_getItem(item_id)
964 
    return self.recv_getItem()
965 
 
966 
  def send_getItem(self, item_id):
967 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
968 
    args = getItem_args()
969 
    args.item_id = item_id
970 
    args.write(self._oprot)
971 
    self._oprot.writeMessageEnd()
972 
    self._oprot.trans.flush()
973 
 
974 
  def recv_getItem(self, ):
975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
976 
    if mtype == TMessageType.EXCEPTION:
977 
      x = TApplicationException()
978 
      x.read(self._iprot)
979 
      self._iprot.readMessageEnd()
980 
      raise x
981 
    result = getItem_result()
982 
    result.read(self._iprot)
983 
    self._iprot.readMessageEnd()
984 
    if result.success is not None:
985 
      return result.success
986 
    if result.cex is not None:
987 
      raise result.cex
988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
989 
 
990 
  def getItemsByCatalogId(self, catalog_item_id):
991 
    """
992 
    Parameters:
993 
     - catalog_item_id
994 
    """
995 
    self.send_getItemsByCatalogId(catalog_item_id)
996 
    return self.recv_getItemsByCatalogId()
997 
 
998 
  def send_getItemsByCatalogId(self, catalog_item_id):
999 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1000 
    args = getItemsByCatalogId_args()
1001 
    args.catalog_item_id = catalog_item_id
1002 
    args.write(self._oprot)
1003 
    self._oprot.writeMessageEnd()
1004 
    self._oprot.trans.flush()
1005 
 
1006 
  def recv_getItemsByCatalogId(self, ):
1007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1008 
    if mtype == TMessageType.EXCEPTION:
1009 
      x = TApplicationException()
1010 
      x.read(self._iprot)
1011 
      self._iprot.readMessageEnd()
1012 
      raise x
1013 
    result = getItemsByCatalogId_result()
1014 
    result.read(self._iprot)
1015 
    self._iprot.readMessageEnd()
1016 
    if result.success is not None:
1017 
      return result.success
1018 
    if result.cex is not None:
1019 
      raise result.cex
1020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1021 
 
1022 
  def getValidItemsByCatalogId(self, catalog_item_id):
1023 
    """
1024 
    Parameters:
1025 
     - catalog_item_id
1026 
    """
1027 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1028 
    return self.recv_getValidItemsByCatalogId()
1029 
 
1030 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1031 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1032 
    args = getValidItemsByCatalogId_args()
1033 
    args.catalog_item_id = catalog_item_id
1034 
    args.write(self._oprot)
1035 
    self._oprot.writeMessageEnd()
1036 
    self._oprot.trans.flush()
1037 
 
1038 
  def recv_getValidItemsByCatalogId(self, ):
1039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1040 
    if mtype == TMessageType.EXCEPTION:
1041 
      x = TApplicationException()
1042 
      x.read(self._iprot)
1043 
      self._iprot.readMessageEnd()
1044 
      raise x
1045 
    result = getValidItemsByCatalogId_result()
1046 
    result.read(self._iprot)
1047 
    self._iprot.readMessageEnd()
1048 
    if result.success is not None:
1049 
      return result.success
1050 
    if result.cex is not None:
1051 
      raise result.cex
1052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1053 
 
1054 
  def getAllItems(self, isActive):
1055 
    """
1056 
    Parameters:
1057 
     - isActive
1058 
    """
1059 
    self.send_getAllItems(isActive)
1060 
    return self.recv_getAllItems()
1061 
 
1062 
  def send_getAllItems(self, isActive):
1063 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1064 
    args = getAllItems_args()
1065 
    args.isActive = isActive
1066 
    args.write(self._oprot)
1067 
    self._oprot.writeMessageEnd()
1068 
    self._oprot.trans.flush()
1069 
 
1070 
  def recv_getAllItems(self, ):
1071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1072 
    if mtype == TMessageType.EXCEPTION:
1073 
      x = TApplicationException()
1074 
      x.read(self._iprot)
1075 
      self._iprot.readMessageEnd()
1076 
      raise x
1077 
    result = getAllItems_result()
1078 
    result.read(self._iprot)
1079 
    self._iprot.readMessageEnd()
1080 
    if result.success is not None:
1081 
      return result.success
1082 
    if result.cex is not None:
1083 
      raise result.cex
1084 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1085 
 
1086 
  def getAllItemsByStatus(self, itemStatus):
1087 
    """
1088 
    Parameters:
1089 
     - itemStatus
1090 
    """
1091 
    self.send_getAllItemsByStatus(itemStatus)
1092 
    return self.recv_getAllItemsByStatus()
1093 
 
1094 
  def send_getAllItemsByStatus(self, itemStatus):
1095 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1096 
    args = getAllItemsByStatus_args()
1097 
    args.itemStatus = itemStatus
1098 
    args.write(self._oprot)
1099 
    self._oprot.writeMessageEnd()
1100 
    self._oprot.trans.flush()
1101 
 
1102 
  def recv_getAllItemsByStatus(self, ):
1103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1104 
    if mtype == TMessageType.EXCEPTION:
1105 
      x = TApplicationException()
1106 
      x.read(self._iprot)
1107 
      self._iprot.readMessageEnd()
1108 
      raise x
1109 
    result = getAllItemsByStatus_result()
1110 
    result.read(self._iprot)
1111 
    self._iprot.readMessageEnd()
1112 
    if result.success is not None:
1113 
      return result.success
1114 
    if result.cex is not None:
1115 
      raise result.cex
1116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1117 
 
1118 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1119 
    """
1120 
    Parameters:
1121 
     - entityId
1122 
     - category
1123 
     - brand
1124 
     - modelName
1125 
     - modelNumber
1126 
    """
1127 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1128 
    return self.recv_markItemAsContentComplete()
1129 
 
1130 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1131 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1132 
    args = markItemAsContentComplete_args()
1133 
    args.entityId = entityId
1134 
    args.category = category
1135 
    args.brand = brand
1136 
    args.modelName = modelName
1137 
    args.modelNumber = modelNumber
1138 
    args.write(self._oprot)
1139 
    self._oprot.writeMessageEnd()
1140 
    self._oprot.trans.flush()
1141 
 
1142 
  def recv_markItemAsContentComplete(self, ):
1143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1144 
    if mtype == TMessageType.EXCEPTION:
1145 
      x = TApplicationException()
1146 
      x.read(self._iprot)
1147 
      self._iprot.readMessageEnd()
1148 
      raise x
1149 
    result = markItemAsContentComplete_result()
1150 
    result.read(self._iprot)
1151 
    self._iprot.readMessageEnd()
1152 
    if result.success is not None:
1153 
      return result.success
1154 
    if result.cex is not None:
1155 
      raise result.cex
1156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1157 
 
1158 
  def getAllItemsInRange(self, offset, limit):
1159 
    """
1160 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1161 
 
1162 
    Parameters:
1163 
     - offset
1164 
     - limit
1165 
    """
1166 
    self.send_getAllItemsInRange(offset, limit)
1167 
    return self.recv_getAllItemsInRange()
1168 
 
1169 
  def send_getAllItemsInRange(self, offset, limit):
1170 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1171 
    args = getAllItemsInRange_args()
1172 
    args.offset = offset
1173 
    args.limit = limit
1174 
    args.write(self._oprot)
1175 
    self._oprot.writeMessageEnd()
1176 
    self._oprot.trans.flush()
1177 
 
1178 
  def recv_getAllItemsInRange(self, ):
1179 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1180 
    if mtype == TMessageType.EXCEPTION:
1181 
      x = TApplicationException()
1182 
      x.read(self._iprot)
1183 
      self._iprot.readMessageEnd()
1184 
      raise x
1185 
    result = getAllItemsInRange_result()
1186 
    result.read(self._iprot)
1187 
    self._iprot.readMessageEnd()
1188 
    if result.success is not None:
1189 
      return result.success
1190 
    if result.cex is not None:
1191 
      raise result.cex
1192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1193 
 
1194 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1195 
    """
1196 
    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.
1197 
 
1198 
    Parameters:
1199 
     - itemStatus
1200 
     - offset
1201 
     - limit
1202 
    """
1203 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1204 
    return self.recv_getAllItemsByStatusInRange()
1205 
 
1206 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1207 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1208 
    args = getAllItemsByStatusInRange_args()
1209 
    args.itemStatus = itemStatus
1210 
    args.offset = offset
1211 
    args.limit = limit
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_getAllItemsByStatusInRange(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = getAllItemsByStatusInRange_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
1226 
    if result.success is not None:
1227 
      return result.success
1228 
    if result.cex is not None:
1229 
      raise result.cex
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1231 
 
1232 
  def getItemCountByStatus(self, useStatus, itemStatus):
1233 
    """
1234 
    Gets a count of all items by status
1235 
 
1236 
    Parameters:
1237 
     - useStatus
1238 
     - itemStatus
1239 
    """
1240 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1241 
    return self.recv_getItemCountByStatus()
1242 
 
1243 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1244 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1245 
    args = getItemCountByStatus_args()
1246 
    args.useStatus = useStatus
1247 
    args.itemStatus = itemStatus
1248 
    args.write(self._oprot)
1249 
    self._oprot.writeMessageEnd()
1250 
    self._oprot.trans.flush()
1251 
 
1252 
  def recv_getItemCountByStatus(self, ):
1253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1254 
    if mtype == TMessageType.EXCEPTION:
1255 
      x = TApplicationException()
1256 
      x.read(self._iprot)
1257 
      self._iprot.readMessageEnd()
1258 
      raise x
1259 
    result = getItemCountByStatus_result()
1260 
    result.read(self._iprot)
1261 
    self._iprot.readMessageEnd()
1262 
    if result.success is not None:
1263 
      return result.success
1264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1265 
 
1266 
  def getBestSellers(self, ):
1267 
    self.send_getBestSellers()
1268 
    return self.recv_getBestSellers()
1269 
 
1270 
  def send_getBestSellers(self, ):
1271 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1272 
    args = getBestSellers_args()
1273 
    args.write(self._oprot)
1274 
    self._oprot.writeMessageEnd()
1275 
    self._oprot.trans.flush()
1276 
 
1277 
  def recv_getBestSellers(self, ):
1278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1279 
    if mtype == TMessageType.EXCEPTION:
1280 
      x = TApplicationException()
1281 
      x.read(self._iprot)
1282 
      self._iprot.readMessageEnd()
1283 
      raise x
1284 
    result = getBestSellers_result()
1285 
    result.read(self._iprot)
1286 
    self._iprot.readMessageEnd()
1287 
    if result.success is not None:
1288 
      return result.success
1289 
    if result.isex is not None:
1290 
      raise result.isex
1291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1292 
 
1293 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1294 
    """
1295 
    Parameters:
1296 
     - beginIndex
1297 
     - totalItems
1298 
     - brand
1299 
     - category
1300 
    """
1301 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1302 
    return self.recv_getBestSellersCatalogIds()
1303 
 
1304 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1305 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1306 
    args = getBestSellersCatalogIds_args()
1307 
    args.beginIndex = beginIndex
1308 
    args.totalItems = totalItems
1309 
    args.brand = brand
1310 
    args.category = category
1311 
    args.write(self._oprot)
1312 
    self._oprot.writeMessageEnd()
1313 
    self._oprot.trans.flush()
1314 
 
1315 
  def recv_getBestSellersCatalogIds(self, ):
1316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1317 
    if mtype == TMessageType.EXCEPTION:
1318 
      x = TApplicationException()
1319 
      x.read(self._iprot)
1320 
      self._iprot.readMessageEnd()
1321 
      raise x
1322 
    result = getBestSellersCatalogIds_result()
1323 
    result.read(self._iprot)
1324 
    self._iprot.readMessageEnd()
1325 
    if result.success is not None:
1326 
      return result.success
1327 
    if result.cex is not None:
1328 
      raise result.cex
1329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1330 
 
1331 
  def getBestSellersCount(self, ):
1332 
    self.send_getBestSellersCount()
1333 
    return self.recv_getBestSellersCount()
1334 
 
1335 
  def send_getBestSellersCount(self, ):
1336 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1337 
    args = getBestSellersCount_args()
1338 
    args.write(self._oprot)
1339 
    self._oprot.writeMessageEnd()
1340 
    self._oprot.trans.flush()
1341 
 
1342 
  def recv_getBestSellersCount(self, ):
1343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1344 
    if mtype == TMessageType.EXCEPTION:
1345 
      x = TApplicationException()
1346 
      x.read(self._iprot)
1347 
      self._iprot.readMessageEnd()
1348 
      raise x
1349 
    result = getBestSellersCount_result()
1350 
    result.read(self._iprot)
1351 
    self._iprot.readMessageEnd()
1352 
    if result.success is not None:
1353 
      return result.success
1354 
    if result.cex is not None:
1355 
      raise result.cex
1356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1357 
 
1358 
  def getBestDeals(self, ):
1359 
    self.send_getBestDeals()
1360 
    return self.recv_getBestDeals()
1361 
 
1362 
  def send_getBestDeals(self, ):
1363 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1364 
    args = getBestDeals_args()
1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_getBestDeals(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = getBestDeals_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
1379 
    if result.success is not None:
1380 
      return result.success
1381 
    if result.isex is not None:
1382 
      raise result.isex
1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1384 
 
1385 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1386 
    """
1387 
    Parameters:
1388 
     - beginIndex
1389 
     - totalItems
1390 
     - brand
1391 
     - category
1392 
    """
1393 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1394 
    return self.recv_getBestDealsCatalogIds()
1395 
 
1396 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1397 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1398 
    args = getBestDealsCatalogIds_args()
1399 
    args.beginIndex = beginIndex
1400 
    args.totalItems = totalItems
1401 
    args.brand = brand
1402 
    args.category = category
1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
1407 
  def recv_getBestDealsCatalogIds(self, ):
1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
1414 
    result = getBestDealsCatalogIds_result()
1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
1417 
    if result.success is not None:
1418 
      return result.success
1419 
    if result.cex is not None:
1420 
      raise result.cex
1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1422 
 
1423 
  def getBestDealsCount(self, ):
1424 
    self.send_getBestDealsCount()
1425 
    return self.recv_getBestDealsCount()
1426 
 
1427 
  def send_getBestDealsCount(self, ):
1428 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1429 
    args = getBestDealsCount_args()
1430 
    args.write(self._oprot)
1431 
    self._oprot.writeMessageEnd()
1432 
    self._oprot.trans.flush()
1433 
 
1434 
  def recv_getBestDealsCount(self, ):
1435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1436 
    if mtype == TMessageType.EXCEPTION:
1437 
      x = TApplicationException()
1438 
      x.read(self._iprot)
1439 
      self._iprot.readMessageEnd()
1440 
      raise x
1441 
    result = getBestDealsCount_result()
1442 
    result.read(self._iprot)
1443 
    self._iprot.readMessageEnd()
1444 
    if result.success is not None:
1445 
      return result.success
1446 
    if result.cex is not None:
1447 
      raise result.cex
1448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1449 
 
1450 
  def getComingSoon(self, ):
1451 
    self.send_getComingSoon()
1452 
    return self.recv_getComingSoon()
1453 
 
1454 
  def send_getComingSoon(self, ):
1455 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1456 
    args = getComingSoon_args()
1457 
    args.write(self._oprot)
1458 
    self._oprot.writeMessageEnd()
1459 
    self._oprot.trans.flush()
1460 
 
1461 
  def recv_getComingSoon(self, ):
1462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1463 
    if mtype == TMessageType.EXCEPTION:
1464 
      x = TApplicationException()
1465 
      x.read(self._iprot)
1466 
      self._iprot.readMessageEnd()
1467 
      raise x
1468 
    result = getComingSoon_result()
1469 
    result.read(self._iprot)
1470 
    self._iprot.readMessageEnd()
1471 
    if result.success is not None:
1472 
      return result.success
1473 
    if result.isex is not None:
1474 
      raise result.isex
1475 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1476 
 
1477 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1478 
    """
1479 
    Parameters:
1480 
     - beginIndex
1481 
     - totalItems
1482 
     - brand
1483 
     - category
1484 
    """
1485 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1486 
    return self.recv_getComingSoonCatalogIds()
1487 
 
1488 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1489 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1490 
    args = getComingSoonCatalogIds_args()
1491 
    args.beginIndex = beginIndex
1492 
    args.totalItems = totalItems
1493 
    args.brand = brand
1494 
    args.category = category
1495 
    args.write(self._oprot)
1496 
    self._oprot.writeMessageEnd()
1497 
    self._oprot.trans.flush()
1498 
 
1499 
  def recv_getComingSoonCatalogIds(self, ):
1500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1501 
    if mtype == TMessageType.EXCEPTION:
1502 
      x = TApplicationException()
1503 
      x.read(self._iprot)
1504 
      self._iprot.readMessageEnd()
1505 
      raise x
1506 
    result = getComingSoonCatalogIds_result()
1507 
    result.read(self._iprot)
1508 
    self._iprot.readMessageEnd()
1509 
    if result.success is not None:
1510 
      return result.success
1511 
    if result.cex is not None:
1512 
      raise result.cex
1513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1514 
 
1515 
  def getComingSoonCount(self, ):
1516 
    self.send_getComingSoonCount()
1517 
    return self.recv_getComingSoonCount()
1518 
 
1519 
  def send_getComingSoonCount(self, ):
1520 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1521 
    args = getComingSoonCount_args()
1522 
    args.write(self._oprot)
1523 
    self._oprot.writeMessageEnd()
1524 
    self._oprot.trans.flush()
1525 
 
1526 
  def recv_getComingSoonCount(self, ):
1527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1528 
    if mtype == TMessageType.EXCEPTION:
1529 
      x = TApplicationException()
1530 
      x.read(self._iprot)
1531 
      self._iprot.readMessageEnd()
1532 
      raise x
1533 
    result = getComingSoonCount_result()
1534 
    result.read(self._iprot)
1535 
    self._iprot.readMessageEnd()
1536 
    if result.success is not None:
1537 
      return result.success
1538 
    if result.cex is not None:
1539 
      raise result.cex
1540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1541 
 
1542 
  def getLatestArrivals(self, ):
1543 
    """
1544 
    Returns a list of items sorted in the descending order by start date.
1545 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1546 
    """
1547 
    self.send_getLatestArrivals()
1548 
    return self.recv_getLatestArrivals()
1549 
 
1550 
  def send_getLatestArrivals(self, ):
1551 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1552 
    args = getLatestArrivals_args()
1553 
    args.write(self._oprot)
1554 
    self._oprot.writeMessageEnd()
1555 
    self._oprot.trans.flush()
1556 
 
1557 
  def recv_getLatestArrivals(self, ):
1558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1559 
    if mtype == TMessageType.EXCEPTION:
1560 
      x = TApplicationException()
1561 
      x.read(self._iprot)
1562 
      self._iprot.readMessageEnd()
1563 
      raise x
1564 
    result = getLatestArrivals_result()
1565 
    result.read(self._iprot)
1566 
    self._iprot.readMessageEnd()
1567 
    if result.success is not None:
1568 
      return result.success
1569 
    if result.isex is not None:
1570 
      raise result.isex
1571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1572 
 
1573 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1574 
    """
1575 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1576 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1577 
 
1578 
    Parameters:
1579 
     - beginIndex
1580 
     - totalItems
1581 
     - brand
1582 
     - categories
1583 
    """
1584 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1585 
    return self.recv_getLatestArrivalsCatalogIds()
1586 
 
1587 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1588 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1589 
    args = getLatestArrivalsCatalogIds_args()
1590 
    args.beginIndex = beginIndex
1591 
    args.totalItems = totalItems
1592 
    args.brand = brand
1593 
    args.categories = categories
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getLatestArrivalsCatalogIds(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getLatestArrivalsCatalogIds_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
1608 
    if result.success is not None:
1609 
      return result.success
1610 
    if result.cex is not None:
1611 
      raise result.cex
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1613 
 
1614 
  def getLatestArrivalsCount(self, ):
1615 
    """
1616 
    Get the total number of latest arrivals we are willing to show.
1617 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1618 
    """
1619 
    self.send_getLatestArrivalsCount()
1620 
    return self.recv_getLatestArrivalsCount()
1621 
 
1622 
  def send_getLatestArrivalsCount(self, ):
1623 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1624 
    args = getLatestArrivalsCount_args()
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getLatestArrivalsCount(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getLatestArrivalsCount_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
1639 
    if result.success is not None:
1640 
      return result.success
1641 
    if result.cex is not None:
1642 
      raise result.cex
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1644 
 
1645 
  def generateNewEntityID(self, ):
1646 
    self.send_generateNewEntityID()
1647 
    return self.recv_generateNewEntityID()
1648 
 
1649 
  def send_generateNewEntityID(self, ):
1650 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1651 
    args = generateNewEntityID_args()
1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
1656 
  def recv_generateNewEntityID(self, ):
1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
1663 
    result = generateNewEntityID_result()
1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
1666 
    if result.success is not None:
1667 
      return result.success
1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1669 
 
1670 
  def addCategory(self, category):
1671 
    """
1672 
    All category related functions
1673 
 
1674 
    Parameters:
1675 
     - category
1676 
    """
1677 
    self.send_addCategory(category)
1678 
    return self.recv_addCategory()
1679 
 
1680 
  def send_addCategory(self, category):
1681 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1682 
    args = addCategory_args()
1683 
    args.category = category
1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
1688 
  def recv_addCategory(self, ):
1689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1690 
    if mtype == TMessageType.EXCEPTION:
1691 
      x = TApplicationException()
1692 
      x.read(self._iprot)
1693 
      self._iprot.readMessageEnd()
1694 
      raise x
1695 
    result = addCategory_result()
1696 
    result.read(self._iprot)
1697 
    self._iprot.readMessageEnd()
1698 
    if result.success is not None:
1699 
      return result.success
1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1701 
 
1702 
  def getCategory(self, id):
1703 
    """
1704 
    Parameters:
1705 
     - id
1706 
    """
1707 
    self.send_getCategory(id)
1708 
    return self.recv_getCategory()
1709 
 
1710 
  def send_getCategory(self, id):
1711 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1712 
    args = getCategory_args()
1713 
    args.id = id
1714 
    args.write(self._oprot)
1715 
    self._oprot.writeMessageEnd()
1716 
    self._oprot.trans.flush()
1717 
 
1718 
  def recv_getCategory(self, ):
1719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1720 
    if mtype == TMessageType.EXCEPTION:
1721 
      x = TApplicationException()
1722 
      x.read(self._iprot)
1723 
      self._iprot.readMessageEnd()
1724 
      raise x
1725 
    result = getCategory_result()
1726 
    result.read(self._iprot)
1727 
    self._iprot.readMessageEnd()
1728 
    if result.success is not None:
1729 
      return result.success
1730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1731 
 
1732 
  def getAllCategories(self, ):
1733 
    self.send_getAllCategories()
1734 
    return self.recv_getAllCategories()
1735 
 
1736 
  def send_getAllCategories(self, ):
1737 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1738 
    args = getAllCategories_args()
1739 
    args.write(self._oprot)
1740 
    self._oprot.writeMessageEnd()
1741 
    self._oprot.trans.flush()
1742 
 
1743 
  def recv_getAllCategories(self, ):
1744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1745 
    if mtype == TMessageType.EXCEPTION:
1746 
      x = TApplicationException()
1747 
      x.read(self._iprot)
1748 
      self._iprot.readMessageEnd()
1749 
      raise x
1750 
    result = getAllCategories_result()
1751 
    result.read(self._iprot)
1752 
    self._iprot.readMessageEnd()
1753 
    if result.success is not None:
1754 
      return result.success
1755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1756 
 
1757 
  def getAllSimilarItems(self, itemId):
1758 
    """
1759 
    Returns the list of similar items.
1760 
 
1761 
    Parameters:
1762 
     - itemId
1763 
    """
1764 
    self.send_getAllSimilarItems(itemId)
1765 
    return self.recv_getAllSimilarItems()
1766 
 
1767 
  def send_getAllSimilarItems(self, itemId):
1768 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1769 
    args = getAllSimilarItems_args()
1770 
    args.itemId = itemId
1771 
    args.write(self._oprot)
1772 
    self._oprot.writeMessageEnd()
1773 
    self._oprot.trans.flush()
1774 
 
1775 
  def recv_getAllSimilarItems(self, ):
1776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1777 
    if mtype == TMessageType.EXCEPTION:
1778 
      x = TApplicationException()
1779 
      x.read(self._iprot)
1780 
      self._iprot.readMessageEnd()
1781 
      raise x
1782 
    result = getAllSimilarItems_result()
1783 
    result.read(self._iprot)
1784 
    self._iprot.readMessageEnd()
1785 
    if result.success is not None:
1786 
      return result.success
1787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1788 
 
1789 
  def addSimilarItem(self, itemId, catalogItemId):
1790 
    """
1791 
    Adds similar item.
1792 
 
1793 
    Parameters:
1794 
     - itemId
1795 
     - catalogItemId
1796 
    """
1797 
    self.send_addSimilarItem(itemId, catalogItemId)
1798 
    return self.recv_addSimilarItem()
1799 
 
1800 
  def send_addSimilarItem(self, itemId, catalogItemId):
1801 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1802 
    args = addSimilarItem_args()
1803 
    args.itemId = itemId
1804 
    args.catalogItemId = catalogItemId
1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
1809 
  def recv_addSimilarItem(self, ):
1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
1816 
    result = addSimilarItem_result()
1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
1819 
    if result.success is not None:
1820 
      return result.success
1821 
    if result.cex is not None:
1822 
      raise result.cex
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1824 
 
6512 kshitij.so 1825 
  def addTag(self, displayName, itemId):
1826 
    """
1827 
    Tag Related
1828 
 
1829 
    Parameters:
1830 
     - displayName
1831 
     - itemId
1832 
    """
1833 
    self.send_addTag(displayName, itemId)
1834 
    return self.recv_addTag()
1835 
 
1836 
  def send_addTag(self, displayName, itemId):
1837 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1838 
    args = addTag_args()
1839 
    args.displayName = displayName
1840 
    args.itemId = itemId
1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1845 
  def recv_addTag(self, ):
1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1852 
    result = addTag_result()
1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
1855 
    if result.success is not None:
1856 
      return result.success
1857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1858 
 
1859 
  def deleteEntityTag(self, displayName, itemId):
1860 
    """
1861 
    Parameters:
1862 
     - displayName
1863 
     - itemId
1864 
    """
1865 
    self.send_deleteEntityTag(displayName, itemId)
1866 
    return self.recv_deleteEntityTag()
1867 
 
1868 
  def send_deleteEntityTag(self, displayName, itemId):
1869 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1870 
    args = deleteEntityTag_args()
1871 
    args.displayName = displayName
1872 
    args.itemId = itemId
1873 
    args.write(self._oprot)
1874 
    self._oprot.writeMessageEnd()
1875 
    self._oprot.trans.flush()
1876 
 
1877 
  def recv_deleteEntityTag(self, ):
1878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1879 
    if mtype == TMessageType.EXCEPTION:
1880 
      x = TApplicationException()
1881 
      x.read(self._iprot)
1882 
      self._iprot.readMessageEnd()
1883 
      raise x
1884 
    result = deleteEntityTag_result()
1885 
    result.read(self._iprot)
1886 
    self._iprot.readMessageEnd()
1887 
    if result.success is not None:
1888 
      return result.success
1889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1890 
 
1891 
  def deleteTag(self, displayName):
1892 
    """
1893 
    Parameters:
1894 
     - displayName
1895 
    """
1896 
    self.send_deleteTag(displayName)
1897 
    return self.recv_deleteTag()
1898 
 
1899 
  def send_deleteTag(self, displayName):
1900 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1901 
    args = deleteTag_args()
1902 
    args.displayName = displayName
1903 
    args.write(self._oprot)
1904 
    self._oprot.writeMessageEnd()
1905 
    self._oprot.trans.flush()
1906 
 
1907 
  def recv_deleteTag(self, ):
1908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1909 
    if mtype == TMessageType.EXCEPTION:
1910 
      x = TApplicationException()
1911 
      x.read(self._iprot)
1912 
      self._iprot.readMessageEnd()
1913 
      raise x
1914 
    result = deleteTag_result()
1915 
    result.read(self._iprot)
1916 
    self._iprot.readMessageEnd()
1917 
    if result.success is not None:
1918 
      return result.success
1919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1920 
 
1921 
  def getAllTags(self, ):
1922 
    self.send_getAllTags()
1923 
    return self.recv_getAllTags()
1924 
 
1925 
  def send_getAllTags(self, ):
1926 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1927 
    args = getAllTags_args()
1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
1932 
  def recv_getAllTags(self, ):
1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
1939 
    result = getAllTags_result()
1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
1942 
    if result.success is not None:
1943 
      return result.success
1944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1945 
 
1946 
  def getAllEntitiesByTagName(self, displayName):
1947 
    """
1948 
    Parameters:
1949 
     - displayName
1950 
    """
1951 
    self.send_getAllEntitiesByTagName(displayName)
1952 
    return self.recv_getAllEntitiesByTagName()
1953 
 
1954 
  def send_getAllEntitiesByTagName(self, displayName):
1955 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1956 
    args = getAllEntitiesByTagName_args()
1957 
    args.displayName = displayName
1958 
    args.write(self._oprot)
1959 
    self._oprot.writeMessageEnd()
1960 
    self._oprot.trans.flush()
1961 
 
1962 
  def recv_getAllEntitiesByTagName(self, ):
1963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1964 
    if mtype == TMessageType.EXCEPTION:
1965 
      x = TApplicationException()
1966 
      x.read(self._iprot)
1967 
      self._iprot.readMessageEnd()
1968 
      raise x
1969 
    result = getAllEntitiesByTagName_result()
1970 
    result.read(self._iprot)
1971 
    self._iprot.readMessageEnd()
1972 
    if result.success is not None:
1973 
      return result.success
1974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1975 
 
6845 amit.gupta 1976 
  def getAllEntityTags(self, ):
1977 
    self.send_getAllEntityTags()
1978 
    return self.recv_getAllEntityTags()
1979 
 
1980 
  def send_getAllEntityTags(self, ):
1981 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
1982 
    args = getAllEntityTags_args()
1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1987 
  def recv_getAllEntityTags(self, ):
1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1994 
    result = getAllEntityTags_result()
1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
1997 
    if result.success is not None:
1998 
      return result.success
1999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2000 
 
6850 kshitij.so 2001 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2002 
    """
2003 
    Parameters:
2004 
     - bannerName
2005 
     - imageName
2006 
     - link
2007 
     - priority
2008 
     - isActive
2009 
     - hasMap
2010 
    """
2011 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2012 
    return self.recv_addBanner()
2013 
 
2014 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2015 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2016 
    args = addBanner_args()
2017 
    args.bannerName = bannerName
2018 
    args.imageName = imageName
2019 
    args.link = link
2020 
    args.priority = priority
2021 
    args.isActive = isActive
2022 
    args.hasMap = hasMap
2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
2027 
  def recv_addBanner(self, ):
2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
2034 
    result = addBanner_result()
2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
2037 
    if result.success is not None:
2038 
      return result.success
2039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2040 
 
2041 
  def getAllBanners(self, ):
2042 
    self.send_getAllBanners()
2043 
    return self.recv_getAllBanners()
2044 
 
2045 
  def send_getAllBanners(self, ):
2046 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2047 
    args = getAllBanners_args()
2048 
    args.write(self._oprot)
2049 
    self._oprot.writeMessageEnd()
2050 
    self._oprot.trans.flush()
2051 
 
2052 
  def recv_getAllBanners(self, ):
2053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2054 
    if mtype == TMessageType.EXCEPTION:
2055 
      x = TApplicationException()
2056 
      x.read(self._iprot)
2057 
      self._iprot.readMessageEnd()
2058 
      raise x
2059 
    result = getAllBanners_result()
2060 
    result.read(self._iprot)
2061 
    self._iprot.readMessageEnd()
2062 
    if result.success is not None:
2063 
      return result.success
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2065 
 
2066 
  def deleteBanner(self, bannerName):
2067 
    """
2068 
    Parameters:
2069 
     - bannerName
2070 
    """
2071 
    self.send_deleteBanner(bannerName)
2072 
    return self.recv_deleteBanner()
2073 
 
2074 
  def send_deleteBanner(self, bannerName):
2075 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2076 
    args = deleteBanner_args()
2077 
    args.bannerName = bannerName
2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
2082 
  def recv_deleteBanner(self, ):
2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
2089 
    result = deleteBanner_result()
2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
2092 
    if result.success is not None:
2093 
      return result.success
2094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2095 
 
2096 
  def getBannerDetails(self, bannerName):
2097 
    """
2098 
    Parameters:
2099 
     - bannerName
2100 
    """
2101 
    self.send_getBannerDetails(bannerName)
2102 
    return self.recv_getBannerDetails()
2103 
 
2104 
  def send_getBannerDetails(self, bannerName):
2105 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2106 
    args = getBannerDetails_args()
2107 
    args.bannerName = bannerName
2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
2112 
  def recv_getBannerDetails(self, ):
2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
2119 
    result = getBannerDetails_result()
2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
2122 
    if result.success is not None:
2123 
      return result.success
2124 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2125 
 
2126 
  def getActiveBanners(self, ):
2127 
    self.send_getActiveBanners()
2128 
    return self.recv_getActiveBanners()
2129 
 
2130 
  def send_getActiveBanners(self, ):
2131 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2132 
    args = getActiveBanners_args()
2133 
    args.write(self._oprot)
2134 
    self._oprot.writeMessageEnd()
2135 
    self._oprot.trans.flush()
2136 
 
2137 
  def recv_getActiveBanners(self, ):
2138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2139 
    if mtype == TMessageType.EXCEPTION:
2140 
      x = TApplicationException()
2141 
      x.read(self._iprot)
2142 
      self._iprot.readMessageEnd()
2143 
      raise x
2144 
    result = getActiveBanners_result()
2145 
    result.read(self._iprot)
2146 
    self._iprot.readMessageEnd()
2147 
    if result.success is not None:
2148 
      return result.success
2149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2150 
 
6849 kshitij.so 2151 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2152 
    """
2153 
    Parameters:
2154 
     - bannerName
2155 
     - mapLink
2156 
     - coordinates
2157 
    """
2158 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2159 
    return self.recv_addBannerMap()
2160 
 
2161 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2162 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2163 
    args = addBannerMap_args()
2164 
    args.bannerName = bannerName
2165 
    args.mapLink = mapLink
2166 
    args.coordinates = coordinates
2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
2171 
  def recv_addBannerMap(self, ):
2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
2178 
    result = addBannerMap_result()
2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
2181 
    if result.success is not None:
2182 
      return result.success
2183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2184 
 
2185 
  def deleteBannerMap(self, bannerName):
2186 
    """
2187 
    Parameters:
2188 
     - bannerName
2189 
    """
2190 
    self.send_deleteBannerMap(bannerName)
2191 
    return self.recv_deleteBannerMap()
2192 
 
2193 
  def send_deleteBannerMap(self, bannerName):
2194 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2195 
    args = deleteBannerMap_args()
2196 
    args.bannerName = bannerName
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_deleteBannerMap(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = deleteBannerMap_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.success is not None:
2212 
      return result.success
2213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2214 
 
2215 
  def getBannerMapDetails(self, bannerName):
2216 
    """
2217 
    Parameters:
2218 
     - bannerName
2219 
    """
2220 
    self.send_getBannerMapDetails(bannerName)
2221 
    return self.recv_getBannerMapDetails()
2222 
 
2223 
  def send_getBannerMapDetails(self, bannerName):
2224 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2225 
    args = getBannerMapDetails_args()
2226 
    args.bannerName = bannerName
2227 
    args.write(self._oprot)
2228 
    self._oprot.writeMessageEnd()
2229 
    self._oprot.trans.flush()
2230 
 
2231 
  def recv_getBannerMapDetails(self, ):
2232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2233 
    if mtype == TMessageType.EXCEPTION:
2234 
      x = TApplicationException()
2235 
      x.read(self._iprot)
2236 
      self._iprot.readMessageEnd()
2237 
      raise x
2238 
    result = getBannerMapDetails_result()
2239 
    result.read(self._iprot)
2240 
    self._iprot.readMessageEnd()
2241 
    if result.success is not None:
2242 
      return result.success
2243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2244 
 
5944 mandeep.dh 2245 
  def deleteSimilarItem(self, itemId, catalogItemId):
2246 
    """
2247 
    Delete similar item.
2248 
 
2249 
    Parameters:
2250 
     - itemId
2251 
     - catalogItemId
2252 
    """
2253 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2254 
    return self.recv_deleteSimilarItem()
2255 
 
2256 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2257 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2258 
    args = deleteSimilarItem_args()
2259 
    args.itemId = itemId
2260 
    args.catalogItemId = catalogItemId
2261 
    args.write(self._oprot)
2262 
    self._oprot.writeMessageEnd()
2263 
    self._oprot.trans.flush()
2264 
 
2265 
  def recv_deleteSimilarItem(self, ):
2266 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2267 
    if mtype == TMessageType.EXCEPTION:
2268 
      x = TApplicationException()
2269 
      x.read(self._iprot)
2270 
      self._iprot.readMessageEnd()
2271 
      raise x
2272 
    result = deleteSimilarItem_result()
2273 
    result.read(self._iprot)
2274 
    self._iprot.readMessageEnd()
2275 
    if result.success is not None:
2276 
      return result.success
2277 
    if result.cex is not None:
2278 
      raise result.cex
2279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2280 
 
2281 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2282 
    """
2283 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2284 
    If yes, returns the itemId else returns 0
2285 
 
2286 
    Parameters:
2287 
     - brand
2288 
     - modelNumber
2289 
     - modelName
2290 
     - color
2291 
    """
2292 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2293 
    return self.recv_checkSimilarItem()
2294 
 
2295 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2296 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2297 
    args = checkSimilarItem_args()
2298 
    args.brand = brand
2299 
    args.modelNumber = modelNumber
2300 
    args.modelName = modelName
2301 
    args.color = color
2302 
    args.write(self._oprot)
2303 
    self._oprot.writeMessageEnd()
2304 
    self._oprot.trans.flush()
2305 
 
2306 
  def recv_checkSimilarItem(self, ):
2307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2308 
    if mtype == TMessageType.EXCEPTION:
2309 
      x = TApplicationException()
2310 
      x.read(self._iprot)
2311 
      self._iprot.readMessageEnd()
2312 
      raise x
2313 
    result = checkSimilarItem_result()
2314 
    result.read(self._iprot)
2315 
    self._iprot.readMessageEnd()
2316 
    if result.success is not None:
2317 
      return result.success
2318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2319 
 
2320 
  def validateRiskyStatus(self, itemId):
2321 
    """
2322 
    Check wether item is risky and change status if inventory is not available for risky items
2323 
 
2324 
    Parameters:
2325 
     - itemId
2326 
    """
2327 
    self.send_validateRiskyStatus(itemId)
2328 
    self.recv_validateRiskyStatus()
2329 
 
2330 
  def send_validateRiskyStatus(self, itemId):
2331 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2332 
    args = validateRiskyStatus_args()
2333 
    args.itemId = itemId
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_validateRiskyStatus(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = validateRiskyStatus_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    return
2349 
 
2350 
  def changeItemRiskyFlag(self, itemId, risky):
2351 
    """
2352 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2353 
 
2354 
    Parameters:
2355 
     - itemId
2356 
     - risky
2357 
    """
2358 
    self.send_changeItemRiskyFlag(itemId, risky)
2359 
    self.recv_changeItemRiskyFlag()
2360 
 
2361 
  def send_changeItemRiskyFlag(self, itemId, risky):
2362 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2363 
    args = changeItemRiskyFlag_args()
2364 
    args.itemId = itemId
2365 
    args.risky = risky
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_changeItemRiskyFlag(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = changeItemRiskyFlag_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
2380 
    return
2381 
 
2382 
  def getItemsByRiskyFlag(self, ):
2383 
    """
2384 
    Returns list of items marked as risky.
2385 
    """
2386 
    self.send_getItemsByRiskyFlag()
2387 
    return self.recv_getItemsByRiskyFlag()
2388 
 
2389 
  def send_getItemsByRiskyFlag(self, ):
2390 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2391 
    args = getItemsByRiskyFlag_args()
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_getItemsByRiskyFlag(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = getItemsByRiskyFlag_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
2406 
    if result.success is not None:
2407 
      return result.success
2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2409 
 
2410 
  def getItemsForMasterSheet(self, category, brand):
2411 
    """
2412 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2413 
 
2414 
    Parameters:
2415 
     - category
2416 
     - brand
2417 
    """
2418 
    self.send_getItemsForMasterSheet(category, brand)
2419 
    return self.recv_getItemsForMasterSheet()
2420 
 
2421 
  def send_getItemsForMasterSheet(self, category, brand):
2422 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2423 
    args = getItemsForMasterSheet_args()
2424 
    args.category = category
2425 
    args.brand = brand
2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_getItemsForMasterSheet(self, ):
2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
2437 
    result = getItemsForMasterSheet_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
2440 
    if result.success is not None:
2441 
      return result.success
2442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2443 
 
2444 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2445 
    """
2446 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2447 
 
2448 
    Parameters:
2449 
     - beginIndex
2450 
     - totalItems
2451 
     - itemId
2452 
    """
2453 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2454 
    return self.recv_getSimilarItemsCatalogIds()
2455 
 
2456 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2457 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2458 
    args = getSimilarItemsCatalogIds_args()
2459 
    args.beginIndex = beginIndex
2460 
    args.totalItems = totalItems
2461 
    args.itemId = itemId
2462 
    args.write(self._oprot)
2463 
    self._oprot.writeMessageEnd()
2464 
    self._oprot.trans.flush()
2465 
 
2466 
  def recv_getSimilarItemsCatalogIds(self, ):
2467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2468 
    if mtype == TMessageType.EXCEPTION:
2469 
      x = TApplicationException()
2470 
      x.read(self._iprot)
2471 
      self._iprot.readMessageEnd()
2472 
      raise x
2473 
    result = getSimilarItemsCatalogIds_result()
2474 
    result.read(self._iprot)
2475 
    self._iprot.readMessageEnd()
2476 
    if result.success is not None:
2477 
      return result.success
2478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2479 
 
2480 
  def addProductNotification(self, itemId, email):
2481 
    """
2482 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2483 
 
2484 
    Parameters:
2485 
     - itemId
2486 
     - email
2487 
    """
2488 
    self.send_addProductNotification(itemId, email)
2489 
    return self.recv_addProductNotification()
2490 
 
2491 
  def send_addProductNotification(self, itemId, email):
2492 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2493 
    args = addProductNotification_args()
2494 
    args.itemId = itemId
2495 
    args.email = email
2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_addProductNotification(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = addProductNotification_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
2510 
    if result.success is not None:
2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2513 
 
2514 
  def sendProductNotifications(self, ):
2515 
    """
2516 
    Send the product notifications to the users for items which has stock.
2517 
    """
2518 
    self.send_sendProductNotifications()
2519 
    return self.recv_sendProductNotifications()
2520 
 
2521 
  def send_sendProductNotifications(self, ):
2522 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2523 
    args = sendProductNotifications_args()
2524 
    args.write(self._oprot)
2525 
    self._oprot.writeMessageEnd()
2526 
    self._oprot.trans.flush()
2527 
 
2528 
  def recv_sendProductNotifications(self, ):
2529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2530 
    if mtype == TMessageType.EXCEPTION:
2531 
      x = TApplicationException()
2532 
      x.read(self._iprot)
2533 
      self._iprot.readMessageEnd()
2534 
      raise x
2535 
    result = sendProductNotifications_result()
2536 
    result.read(self._iprot)
2537 
    self._iprot.readMessageEnd()
2538 
    if result.success is not None:
2539 
      return result.success
2540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2541 
 
2542 
  def getAllBrandsByCategory(self, categoryId):
2543 
    """
2544 
    Returns list of brand names for a given category Id
2545 
 
2546 
    Parameters:
2547 
     - categoryId
2548 
    """
2549 
    self.send_getAllBrandsByCategory(categoryId)
2550 
    return self.recv_getAllBrandsByCategory()
2551 
 
2552 
  def send_getAllBrandsByCategory(self, categoryId):
2553 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2554 
    args = getAllBrandsByCategory_args()
2555 
    args.categoryId = categoryId
2556 
    args.write(self._oprot)
2557 
    self._oprot.writeMessageEnd()
2558 
    self._oprot.trans.flush()
2559 
 
2560 
  def recv_getAllBrandsByCategory(self, ):
2561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2562 
    if mtype == TMessageType.EXCEPTION:
2563 
      x = TApplicationException()
2564 
      x.read(self._iprot)
2565 
      self._iprot.readMessageEnd()
2566 
      raise x
2567 
    result = getAllBrandsByCategory_result()
2568 
    result.read(self._iprot)
2569 
    self._iprot.readMessageEnd()
2570 
    if result.success is not None:
2571 
      return result.success
2572 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2573 
 
2574 
  def getAllBrands(self, ):
2575 
    """
2576 
    Returns list of brand names
2577 
    """
2578 
    self.send_getAllBrands()
2579 
    return self.recv_getAllBrands()
2580 
 
2581 
  def send_getAllBrands(self, ):
2582 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2583 
    args = getAllBrands_args()
2584 
    args.write(self._oprot)
2585 
    self._oprot.writeMessageEnd()
2586 
    self._oprot.trans.flush()
2587 
 
2588 
  def recv_getAllBrands(self, ):
2589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2590 
    if mtype == TMessageType.EXCEPTION:
2591 
      x = TApplicationException()
2592 
      x.read(self._iprot)
2593 
      self._iprot.readMessageEnd()
2594 
      raise x
2595 
    result = getAllBrands_result()
2596 
    result.read(self._iprot)
2597 
    self._iprot.readMessageEnd()
2598 
    if result.success is not None:
2599 
      return result.success
2600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2601 
 
2602 
  def getAllSources(self, ):
2603 
    """
2604 
    Return list of all sources
2605 
    """
2606 
    self.send_getAllSources()
2607 
    return self.recv_getAllSources()
2608 
 
2609 
  def send_getAllSources(self, ):
2610 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2611 
    args = getAllSources_args()
2612 
    args.write(self._oprot)
2613 
    self._oprot.writeMessageEnd()
2614 
    self._oprot.trans.flush()
2615 
 
2616 
  def recv_getAllSources(self, ):
2617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2618 
    if mtype == TMessageType.EXCEPTION:
2619 
      x = TApplicationException()
2620 
      x.read(self._iprot)
2621 
      self._iprot.readMessageEnd()
2622 
      raise x
2623 
    result = getAllSources_result()
2624 
    result.read(self._iprot)
2625 
    self._iprot.readMessageEnd()
2626 
    if result.success is not None:
2627 
      return result.success
2628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2629 
 
2630 
  def getItemPricingBySource(self, itemId, sourceId):
2631 
    """
2632 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2633 
 
2634 
    Parameters:
2635 
     - itemId
2636 
     - sourceId
2637 
    """
2638 
    self.send_getItemPricingBySource(itemId, sourceId)
2639 
    return self.recv_getItemPricingBySource()
2640 
 
2641 
  def send_getItemPricingBySource(self, itemId, sourceId):
2642 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2643 
    args = getItemPricingBySource_args()
2644 
    args.itemId = itemId
2645 
    args.sourceId = sourceId
2646 
    args.write(self._oprot)
2647 
    self._oprot.writeMessageEnd()
2648 
    self._oprot.trans.flush()
2649 
 
2650 
  def recv_getItemPricingBySource(self, ):
2651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2652 
    if mtype == TMessageType.EXCEPTION:
2653 
      x = TApplicationException()
2654 
      x.read(self._iprot)
2655 
      self._iprot.readMessageEnd()
2656 
      raise x
2657 
    result = getItemPricingBySource_result()
2658 
    result.read(self._iprot)
2659 
    self._iprot.readMessageEnd()
2660 
    if result.success is not None:
2661 
      return result.success
2662 
    if result.cex is not None:
2663 
      raise result.cex
2664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2665 
 
2666 
  def addSourceItemPricing(self, sourceItemPricing):
2667 
    """
2668 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2669 
    If item is not found or source is not found, it will throw exception.
2670 
 
2671 
    Parameters:
2672 
     - sourceItemPricing
2673 
    """
2674 
    self.send_addSourceItemPricing(sourceItemPricing)
2675 
    self.recv_addSourceItemPricing()
2676 
 
2677 
  def send_addSourceItemPricing(self, sourceItemPricing):
2678 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2679 
    args = addSourceItemPricing_args()
2680 
    args.sourceItemPricing = sourceItemPricing
2681 
    args.write(self._oprot)
2682 
    self._oprot.writeMessageEnd()
2683 
    self._oprot.trans.flush()
2684 
 
2685 
  def recv_addSourceItemPricing(self, ):
2686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2687 
    if mtype == TMessageType.EXCEPTION:
2688 
      x = TApplicationException()
2689 
      x.read(self._iprot)
2690 
      self._iprot.readMessageEnd()
2691 
      raise x
2692 
    result = addSourceItemPricing_result()
2693 
    result.read(self._iprot)
2694 
    self._iprot.readMessageEnd()
2695 
    if result.cex is not None:
2696 
      raise result.cex
2697 
    return
2698 
 
2699 
  def getAllSourcePricing(self, itemId):
2700 
    """
2701 
    Returns the list of source pricing information of an item.
2702 
    Raises an exception if item not found corresponding to itemId
2703 
 
2704 
    Parameters:
2705 
     - itemId
2706 
    """
2707 
    self.send_getAllSourcePricing(itemId)
2708 
    return self.recv_getAllSourcePricing()
2709 
 
2710 
  def send_getAllSourcePricing(self, itemId):
2711 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2712 
    args = getAllSourcePricing_args()
2713 
    args.itemId = itemId
2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2718 
  def recv_getAllSourcePricing(self, ):
2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2725 
    result = getAllSourcePricing_result()
2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success is not None:
2729 
      return result.success
2730 
    if result.cex is not None:
2731 
      raise result.cex
2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2733 
 
2734 
  def getItemForSource(self, item_id, sourceId):
2735 
    """
2736 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2737 
 
2738 
    Parameters:
2739 
     - item_id
2740 
     - sourceId
2741 
    """
2742 
    self.send_getItemForSource(item_id, sourceId)
2743 
    return self.recv_getItemForSource()
2744 
 
2745 
  def send_getItemForSource(self, item_id, sourceId):
2746 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2747 
    args = getItemForSource_args()
2748 
    args.item_id = item_id
2749 
    args.sourceId = sourceId
2750 
    args.write(self._oprot)
2751 
    self._oprot.writeMessageEnd()
2752 
    self._oprot.trans.flush()
2753 
 
2754 
  def recv_getItemForSource(self, ):
2755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2756 
    if mtype == TMessageType.EXCEPTION:
2757 
      x = TApplicationException()
2758 
      x.read(self._iprot)
2759 
      self._iprot.readMessageEnd()
2760 
      raise x
2761 
    result = getItemForSource_result()
2762 
    result.read(self._iprot)
2763 
    self._iprot.readMessageEnd()
2764 
    if result.success is not None:
2765 
      return result.success
2766 
    if result.cex is not None:
2767 
      raise result.cex
2768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2769 
 
2770 
  def searchItemsInRange(self, searchTerms, offset, limit):
2771 
    """
2772 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2773 
 
2774 
    Parameters:
2775 
     - searchTerms
2776 
     - offset
2777 
     - limit
2778 
    """
2779 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2780 
    return self.recv_searchItemsInRange()
2781 
 
2782 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2783 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2784 
    args = searchItemsInRange_args()
2785 
    args.searchTerms = searchTerms
2786 
    args.offset = offset
2787 
    args.limit = limit
2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
2792 
  def recv_searchItemsInRange(self, ):
2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
2799 
    result = searchItemsInRange_result()
2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
2802 
    if result.success is not None:
2803 
      return result.success
2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2805 
 
2806 
  def getSearchResultCount(self, searchTerms):
2807 
    """
2808 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2809 
 
2810 
    Parameters:
2811 
     - searchTerms
2812 
    """
2813 
    self.send_getSearchResultCount(searchTerms)
2814 
    return self.recv_getSearchResultCount()
2815 
 
2816 
  def send_getSearchResultCount(self, searchTerms):
2817 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2818 
    args = getSearchResultCount_args()
2819 
    args.searchTerms = searchTerms
2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2824 
  def recv_getSearchResultCount(self, ):
2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2831 
    result = getSearchResultCount_result()
2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
2834 
    if result.success is not None:
2835 
      return result.success
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2837 
 
2838 
  def getProductNotifications(self, startDateTime):
2839 
    """
2840 
    Returns a list of product notifications added after a supplied datetime
2841 
 
2842 
    Parameters:
2843 
     - startDateTime
2844 
    """
2845 
    self.send_getProductNotifications(startDateTime)
2846 
    return self.recv_getProductNotifications()
2847 
 
2848 
  def send_getProductNotifications(self, startDateTime):
2849 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2850 
    args = getProductNotifications_args()
2851 
    args.startDateTime = startDateTime
2852 
    args.write(self._oprot)
2853 
    self._oprot.writeMessageEnd()
2854 
    self._oprot.trans.flush()
2855 
 
2856 
  def recv_getProductNotifications(self, ):
2857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2858 
    if mtype == TMessageType.EXCEPTION:
2859 
      x = TApplicationException()
2860 
      x.read(self._iprot)
2861 
      self._iprot.readMessageEnd()
2862 
      raise x
2863 
    result = getProductNotifications_result()
2864 
    result.read(self._iprot)
2865 
    self._iprot.readMessageEnd()
2866 
    if result.success is not None:
2867 
      return result.success
2868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2869 
 
2870 
  def getProductNotificationRequestCount(self, startDateTime):
2871 
    """
2872 
    Returns a list of count of requests for product notification against each item
2873 
 
2874 
    Parameters:
2875 
     - startDateTime
2876 
    """
2877 
    self.send_getProductNotificationRequestCount(startDateTime)
2878 
    return self.recv_getProductNotificationRequestCount()
2879 
 
2880 
  def send_getProductNotificationRequestCount(self, startDateTime):
2881 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2882 
    args = getProductNotificationRequestCount_args()
2883 
    args.startDateTime = startDateTime
2884 
    args.write(self._oprot)
2885 
    self._oprot.writeMessageEnd()
2886 
    self._oprot.trans.flush()
2887 
 
2888 
  def recv_getProductNotificationRequestCount(self, ):
2889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2890 
    if mtype == TMessageType.EXCEPTION:
2891 
      x = TApplicationException()
2892 
      x.read(self._iprot)
2893 
      self._iprot.readMessageEnd()
2894 
      raise x
2895 
    result = getProductNotificationRequestCount_result()
2896 
    result.read(self._iprot)
2897 
    self._iprot.readMessageEnd()
2898 
    if result.success is not None:
2899 
      return result.success
2900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2901 
 
2902 
  def addAuthorizationLog(self, itemId, username, reason):
2903 
    """
2904 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2905 
 
2906 
    Parameters:
2907 
     - itemId
2908 
     - username
2909 
     - reason
2910 
    """
2911 
    self.send_addAuthorizationLog(itemId, username, reason)
2912 
    return self.recv_addAuthorizationLog()
2913 
 
2914 
  def send_addAuthorizationLog(self, itemId, username, reason):
2915 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2916 
    args = addAuthorizationLog_args()
2917 
    args.itemId = itemId
2918 
    args.username = username
2919 
    args.reason = reason
2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2924 
  def recv_addAuthorizationLog(self, ):
2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2931 
    result = addAuthorizationLog_result()
2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    if result.success is not None:
2935 
      return result.success
2936 
    if result.cex is not None:
2937 
      raise result.cex
2938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2939 
 
2940 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2941 
    """
2942 
    Parameters:
2943 
     - catalog_item_id
2944 
     - voucherType
2945 
     - voucherAmount
2946 
    """
2947 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2948 
    return self.recv_addupdateVoucherForItem()
2949 
 
2950 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2951 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2952 
    args = addupdateVoucherForItem_args()
2953 
    args.catalog_item_id = catalog_item_id
2954 
    args.voucherType = voucherType
2955 
    args.voucherAmount = voucherAmount
2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
2960 
  def recv_addupdateVoucherForItem(self, ):
2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
2967 
    result = addupdateVoucherForItem_result()
2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
2970 
    if result.success is not None:
2971 
      return result.success
2972 
    if result.cex is not None:
2973 
      raise result.cex
2974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2975 
 
2976 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2977 
    """
2978 
    Parameters:
2979 
     - catalog_item_id
2980 
     - voucherType
2981 
    """
2982 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
2983 
    return self.recv_deleteVoucherForItem()
2984 
 
2985 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
2986 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
2987 
    args = deleteVoucherForItem_args()
2988 
    args.catalog_item_id = catalog_item_id
2989 
    args.voucherType = voucherType
2990 
    args.write(self._oprot)
2991 
    self._oprot.writeMessageEnd()
2992 
    self._oprot.trans.flush()
2993 
 
2994 
  def recv_deleteVoucherForItem(self, ):
2995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2996 
    if mtype == TMessageType.EXCEPTION:
2997 
      x = TApplicationException()
2998 
      x.read(self._iprot)
2999 
      self._iprot.readMessageEnd()
3000 
      raise x
3001 
    result = deleteVoucherForItem_result()
3002 
    result.read(self._iprot)
3003 
    self._iprot.readMessageEnd()
3004 
    if result.success is not None:
3005 
      return result.success
3006 
    if result.cex is not None:
3007 
      raise result.cex
3008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3009 
 
3010 
  def getVoucherAmount(self, itemId, voucherType):
3011 
    """
3012 
    Parameters:
3013 
     - itemId
3014 
     - voucherType
3015 
    """
3016 
    self.send_getVoucherAmount(itemId, voucherType)
3017 
    return self.recv_getVoucherAmount()
3018 
 
3019 
  def send_getVoucherAmount(self, itemId, voucherType):
3020 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3021 
    args = getVoucherAmount_args()
3022 
    args.itemId = itemId
3023 
    args.voucherType = voucherType
3024 
    args.write(self._oprot)
3025 
    self._oprot.writeMessageEnd()
3026 
    self._oprot.trans.flush()
3027 
 
3028 
  def recv_getVoucherAmount(self, ):
3029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3030 
    if mtype == TMessageType.EXCEPTION:
3031 
      x = TApplicationException()
3032 
      x.read(self._iprot)
3033 
      self._iprot.readMessageEnd()
3034 
      raise x
3035 
    result = getVoucherAmount_result()
3036 
    result.read(self._iprot)
3037 
    self._iprot.readMessageEnd()
3038 
    if result.success is not None:
3039 
      return result.success
3040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3041 
 
3042 
  def getAllItemVouchers(self, itemId):
3043 
    """
3044 
    Parameters:
3045 
     - itemId
3046 
    """
3047 
    self.send_getAllItemVouchers(itemId)
3048 
    return self.recv_getAllItemVouchers()
3049 
 
3050 
  def send_getAllItemVouchers(self, itemId):
3051 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3052 
    args = getAllItemVouchers_args()
3053 
    args.itemId = itemId
3054 
    args.write(self._oprot)
3055 
    self._oprot.writeMessageEnd()
3056 
    self._oprot.trans.flush()
3057 
 
3058 
  def recv_getAllItemVouchers(self, ):
3059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3060 
    if mtype == TMessageType.EXCEPTION:
3061 
      x = TApplicationException()
3062 
      x.read(self._iprot)
3063 
      self._iprot.readMessageEnd()
3064 
      raise x
3065 
    result = getAllItemVouchers_result()
3066 
    result.read(self._iprot)
3067 
    self._iprot.readMessageEnd()
3068 
    if result.success is not None:
3069 
      return result.success
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3071 
 
3072 
  def isValidCatalogItemId(self, catalog_item_id):
3073 
    """
3074 
    Parameters:
3075 
     - catalog_item_id
3076 
    """
3077 
    self.send_isValidCatalogItemId(catalog_item_id)
3078 
    return self.recv_isValidCatalogItemId()
3079 
 
3080 
  def send_isValidCatalogItemId(self, catalog_item_id):
3081 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3082 
    args = isValidCatalogItemId_args()
3083 
    args.catalog_item_id = catalog_item_id
3084 
    args.write(self._oprot)
3085 
    self._oprot.writeMessageEnd()
3086 
    self._oprot.trans.flush()
3087 
 
3088 
  def recv_isValidCatalogItemId(self, ):
3089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3090 
    if mtype == TMessageType.EXCEPTION:
3091 
      x = TApplicationException()
3092 
      x.read(self._iprot)
3093 
      self._iprot.readMessageEnd()
3094 
      raise x
3095 
    result = isValidCatalogItemId_result()
3096 
    result.read(self._iprot)
3097 
    self._iprot.readMessageEnd()
3098 
    if result.success is not None:
3099 
      return result.success
3100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3101 
 
6039 amit.gupta 3102 
  def getVatPercentageForItem(self, itemId, price):
3103 
    """
3104 
    Parameters:
3105 
     - itemId
3106 
     - price
3107 
    """
3108 
    self.send_getVatPercentageForItem(itemId, price)
3109 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3110 
 
6039 amit.gupta 3111 
  def send_getVatPercentageForItem(self, itemId, price):
3112 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3113 
    args = getVatPercentageForItem_args()
3114 
    args.itemId = itemId
3115 
    args.price = price
3116 
    args.write(self._oprot)
3117 
    self._oprot.writeMessageEnd()
3118 
    self._oprot.trans.flush()
3119 
 
3120 
  def recv_getVatPercentageForItem(self, ):
3121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3122 
    if mtype == TMessageType.EXCEPTION:
3123 
      x = TApplicationException()
3124 
      x.read(self._iprot)
3125 
      self._iprot.readMessageEnd()
3126 
      raise x
3127 
    result = getVatPercentageForItem_result()
3128 
    result.read(self._iprot)
3129 
    self._iprot.readMessageEnd()
3130 
    if result.success is not None:
3131 
      return result.success
3132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3133 
 
3134 
  def getVatAmountForItem(self, itemId, price):
3135 
    """
3136 
    Parameters:
3137 
     - itemId
3138 
     - price
3139 
    """
3140 
    self.send_getVatAmountForItem(itemId, price)
3141 
    return self.recv_getVatAmountForItem()
3142 
 
3143 
  def send_getVatAmountForItem(self, itemId, price):
3144 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3145 
    args = getVatAmountForItem_args()
3146 
    args.itemId = itemId
3147 
    args.price = price
3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_getVatAmountForItem(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = getVatAmountForItem_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3162 
    if result.success is not None:
3163 
      return result.success
3164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3165 
 
6531 vikram.rag 3166 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3167 
    """
3168 
    Parameters:
3169 
     - offset
3170 
     - limit
3171 
    """
3172 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3173 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3174 
 
6531 vikram.rag 3175 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3176 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3177 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3178 
    args.offset = offset
3179 
    args.limit = limit
3180 
    args.write(self._oprot)
3181 
    self._oprot.writeMessageEnd()
3182 
    self._oprot.trans.flush()
3183 
 
3184 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3186 
    if mtype == TMessageType.EXCEPTION:
3187 
      x = TApplicationException()
3188 
      x.read(self._iprot)
3189 
      self._iprot.readMessageEnd()
3190 
      raise x
3191 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3192 
    result.read(self._iprot)
3193 
    self._iprot.readMessageEnd()
3194 
    if result.success is not None:
3195 
      return result.success
3196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3197 
 
6821 amar.kumar 3198 
  def getAllAliveItems(self, ):
3199 
    self.send_getAllAliveItems()
3200 
    return self.recv_getAllAliveItems()
3201 
 
3202 
  def send_getAllAliveItems(self, ):
3203 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3204 
    args = getAllAliveItems_args()
3205 
    args.write(self._oprot)
3206 
    self._oprot.writeMessageEnd()
3207 
    self._oprot.trans.flush()
3208 
 
3209 
  def recv_getAllAliveItems(self, ):
3210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3211 
    if mtype == TMessageType.EXCEPTION:
3212 
      x = TApplicationException()
3213 
      x.read(self._iprot)
3214 
      self._iprot.readMessageEnd()
3215 
      raise x
3216 
    result = getAllAliveItems_result()
3217 
    result.read(self._iprot)
3218 
    self._iprot.readMessageEnd()
3219 
    if result.success is not None:
3220 
      return result.success
3221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3222 
 
6921 anupam.sin 3223 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3224 
    """
3225 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3226 
 
6805 anupam.sin 3227 
    Parameters:
3228 
     - itemId
6921 anupam.sin 3229 
     - price
6805 anupam.sin 3230 
     - insurerId
3231 
     - quantity
3232 
    """
6921 anupam.sin 3233 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3234 
    return self.recv_getInsuranceAmount()
3235 
 
6921 anupam.sin 3236 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3237 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3238 
    args = getInsuranceAmount_args()
3239 
    args.itemId = itemId
6921 anupam.sin 3240 
    args.price = price
6805 anupam.sin 3241 
    args.insurerId = insurerId
3242 
    args.quantity = quantity
3243 
    args.write(self._oprot)
3244 
    self._oprot.writeMessageEnd()
3245 
    self._oprot.trans.flush()
3246 
 
3247 
  def recv_getInsuranceAmount(self, ):
3248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3249 
    if mtype == TMessageType.EXCEPTION:
3250 
      x = TApplicationException()
3251 
      x.read(self._iprot)
3252 
      self._iprot.readMessageEnd()
3253 
      raise x
3254 
    result = getInsuranceAmount_result()
3255 
    result.read(self._iprot)
3256 
    self._iprot.readMessageEnd()
3257 
    if result.success is not None:
3258 
      return result.success
3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3260 
 
3261 
  def getInsurer(self, insurerId):
3262 
    """
3263 
    Parameters:
3264 
     - insurerId
3265 
    """
3266 
    self.send_getInsurer(insurerId)
3267 
    return self.recv_getInsurer()
3268 
 
3269 
  def send_getInsurer(self, insurerId):
3270 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3271 
    args = getInsurer_args()
3272 
    args.insurerId = insurerId
3273 
    args.write(self._oprot)
3274 
    self._oprot.writeMessageEnd()
3275 
    self._oprot.trans.flush()
3276 
 
3277 
  def recv_getInsurer(self, ):
3278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3279 
    if mtype == TMessageType.EXCEPTION:
3280 
      x = TApplicationException()
3281 
      x.read(self._iprot)
3282 
      self._iprot.readMessageEnd()
3283 
      raise x
3284 
    result = getInsurer_result()
3285 
    result.read(self._iprot)
3286 
    self._iprot.readMessageEnd()
3287 
    if result.success is not None:
3288 
      return result.success
3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3290 
 
6838 vikram.rag 3291 
  def getAllInsurers(self, ):
3292 
    self.send_getAllInsurers()
3293 
    return self.recv_getAllInsurers()
6805 anupam.sin 3294 
 
6838 vikram.rag 3295 
  def send_getAllInsurers(self, ):
3296 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3297 
    args = getAllInsurers_args()
3298 
    args.write(self._oprot)
3299 
    self._oprot.writeMessageEnd()
3300 
    self._oprot.trans.flush()
3301 
 
3302 
  def recv_getAllInsurers(self, ):
3303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3304 
    if mtype == TMessageType.EXCEPTION:
3305 
      x = TApplicationException()
3306 
      x.read(self._iprot)
3307 
      self._iprot.readMessageEnd()
3308 
      raise x
3309 
    result = getAllInsurers_result()
3310 
    result.read(self._iprot)
3311 
    self._iprot.readMessageEnd()
3312 
    if result.success is not None:
3313 
      return result.success
3314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3315 
 
6962 rajveer 3316 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3317 
    """
3318 
    Parameters:
3319 
     - insurerId
3320 
     - amount
3321 
    """
3322 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3323 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3324 
 
6962 rajveer 3325 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3326 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3327 
    args = updateInsuranceDeclaredAmount_args()
3328 
    args.insurerId = insurerId
3329 
    args.amount = amount
3330 
    args.write(self._oprot)
3331 
    self._oprot.writeMessageEnd()
3332 
    self._oprot.trans.flush()
3333 
 
3334 
  def recv_updateInsuranceDeclaredAmount(self, ):
3335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3336 
    if mtype == TMessageType.EXCEPTION:
3337 
      x = TApplicationException()
3338 
      x.read(self._iprot)
3339 
      self._iprot.readMessageEnd()
3340 
      raise x
3341 
    result = updateInsuranceDeclaredAmount_result()
3342 
    result.read(self._iprot)
3343 
    self._iprot.readMessageEnd()
3344 
    return
3345 
 
7190 amar.kumar 3346 
  def getFreebieForItem(self, itemId):
3347 
    """
3348 
    Parameters:
3349 
     - itemId
3350 
    """
3351 
    self.send_getFreebieForItem(itemId)
3352 
    return self.recv_getFreebieForItem()
6962 rajveer 3353 
 
7190 amar.kumar 3354 
  def send_getFreebieForItem(self, itemId):
3355 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3356 
    args = getFreebieForItem_args()
3357 
    args.itemId = itemId
3358 
    args.write(self._oprot)
3359 
    self._oprot.writeMessageEnd()
3360 
    self._oprot.trans.flush()
3361 
 
3362 
  def recv_getFreebieForItem(self, ):
3363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3364 
    if mtype == TMessageType.EXCEPTION:
3365 
      x = TApplicationException()
3366 
      x.read(self._iprot)
3367 
      self._iprot.readMessageEnd()
3368 
      raise x
3369 
    result = getFreebieForItem_result()
3370 
    result.read(self._iprot)
3371 
    self._iprot.readMessageEnd()
3372 
    if result.success is not None:
3373 
      return result.success
3374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3375 
 
3376 
  def addOrUpdateFreebieForItem(self, freebieItem):
3377 
    """
3378 
    Parameters:
3379 
     - freebieItem
3380 
    """
3381 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3382 
    self.recv_addOrUpdateFreebieForItem()
3383 
 
3384 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3385 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3386 
    args = addOrUpdateFreebieForItem_args()
3387 
    args.freebieItem = freebieItem
3388 
    args.write(self._oprot)
3389 
    self._oprot.writeMessageEnd()
3390 
    self._oprot.trans.flush()
3391 
 
3392 
  def recv_addOrUpdateFreebieForItem(self, ):
3393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3394 
    if mtype == TMessageType.EXCEPTION:
3395 
      x = TApplicationException()
3396 
      x.read(self._iprot)
3397 
      self._iprot.readMessageEnd()
3398 
      raise x
3399 
    result = addOrUpdateFreebieForItem_result()
3400 
    result.read(self._iprot)
3401 
    self._iprot.readMessageEnd()
3402 
    return
3403 
 
7272 amit.gupta 3404 
  def addOrUpdateBrandInfo(self, brandInfo):
3405 
    """
3406 
    Parameters:
3407 
     - brandInfo
3408 
    """
3409 
    self.send_addOrUpdateBrandInfo(brandInfo)
3410 
    self.recv_addOrUpdateBrandInfo()
3411 
 
3412 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3413 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3414 
    args = addOrUpdateBrandInfo_args()
3415 
    args.brandInfo = brandInfo
3416 
    args.write(self._oprot)
3417 
    self._oprot.writeMessageEnd()
3418 
    self._oprot.trans.flush()
3419 
 
3420 
  def recv_addOrUpdateBrandInfo(self, ):
3421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3422 
    if mtype == TMessageType.EXCEPTION:
3423 
      x = TApplicationException()
3424 
      x.read(self._iprot)
3425 
      self._iprot.readMessageEnd()
3426 
      raise x
3427 
    result = addOrUpdateBrandInfo_result()
3428 
    result.read(self._iprot)
3429 
    self._iprot.readMessageEnd()
3430 
    return
3431 
 
3432 
  def getBrandInfo(self, ):
3433 
    self.send_getBrandInfo()
3434 
    return self.recv_getBrandInfo()
3435 
 
3436 
  def send_getBrandInfo(self, ):
3437 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3438 
    args = getBrandInfo_args()
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_getBrandInfo(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 = getBrandInfo_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    if result.success is not None:
3454 
      return result.success
3455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3456 
 
7256 rajveer 3457 
  def getStorePricing(self, itemId):
3458 
    """
3459 
    Parameters:
3460 
     - itemId
3461 
    """
3462 
    self.send_getStorePricing(itemId)
3463 
    return self.recv_getStorePricing()
7190 amar.kumar 3464 
 
7256 rajveer 3465 
  def send_getStorePricing(self, itemId):
3466 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3467 
    args = getStorePricing_args()
3468 
    args.itemId = itemId
3469 
    args.write(self._oprot)
3470 
    self._oprot.writeMessageEnd()
3471 
    self._oprot.trans.flush()
3472 
 
3473 
  def recv_getStorePricing(self, ):
3474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3475 
    if mtype == TMessageType.EXCEPTION:
3476 
      x = TApplicationException()
3477 
      x.read(self._iprot)
3478 
      self._iprot.readMessageEnd()
3479 
      raise x
3480 
    result = getStorePricing_result()
3481 
    result.read(self._iprot)
3482 
    self._iprot.readMessageEnd()
3483 
    if result.success is not None:
3484 
      return result.success
3485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3486 
 
7265 rajveer 3487 
  def updateStorePricing(self, sp):
3488 
    """
3489 
    Parameters:
3490 
     - sp
3491 
    """
3492 
    self.send_updateStorePricing(sp)
3493 
    self.recv_updateStorePricing()
7256 rajveer 3494 
 
7265 rajveer 3495 
  def send_updateStorePricing(self, sp):
3496 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3497 
    args = updateStorePricing_args()
3498 
    args.sp = sp
3499 
    args.write(self._oprot)
3500 
    self._oprot.writeMessageEnd()
3501 
    self._oprot.trans.flush()
3502 
 
3503 
  def recv_updateStorePricing(self, ):
3504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3505 
    if mtype == TMessageType.EXCEPTION:
3506 
      x = TApplicationException()
3507 
      x.read(self._iprot)
3508 
      self._iprot.readMessageEnd()
3509 
      raise x
3510 
    result = updateStorePricing_result()
3511 
    result.read(self._iprot)
3512 
    self._iprot.readMessageEnd()
3513 
    return
3514 
 
7281 kshitij.so 3515 
  def getAllAmazonListedItems(self, ):
3516 
    self.send_getAllAmazonListedItems()
3517 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3518 
 
7281 kshitij.so 3519 
  def send_getAllAmazonListedItems(self, ):
3520 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3521 
    args = getAllAmazonListedItems_args()
3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_getAllAmazonListedItems(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 = getAllAmazonListedItems_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, "getAllAmazonListedItems failed: unknown result");
3539 
 
3540 
  def getAmazonItemDetails(self, itemId):
3541 
    """
3542 
    Parameters:
3543 
     - itemId
3544 
    """
3545 
    self.send_getAmazonItemDetails(itemId)
3546 
    return self.recv_getAmazonItemDetails()
3547 
 
3548 
  def send_getAmazonItemDetails(self, itemId):
3549 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3550 
    args = getAmazonItemDetails_args()
3551 
    args.itemId = itemId
3552 
    args.write(self._oprot)
3553 
    self._oprot.writeMessageEnd()
3554 
    self._oprot.trans.flush()
3555 
 
3556 
  def recv_getAmazonItemDetails(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 = getAmazonItemDetails_result()
3564 
    result.read(self._iprot)
3565 
    self._iprot.readMessageEnd()
3566 
    if result.success is not None:
3567 
      return result.success
3568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3569 
 
3570 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3571 
    """
3572 
    Parameters:
3573 
     - itemId
3574 
     - fbaPrice
3575 
     - sellingPrice
3576 
     - isFba
3577 
     - isNonFba
3578 
     - isInventoryOverride
3579 
    """
3580 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride)
3581 
    self.recv_updateAmazonItemDetails()
3582 
 
3583 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3584 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3585 
    args = updateAmazonItemDetails_args()
3586 
    args.itemId = itemId
3587 
    args.fbaPrice = fbaPrice
3588 
    args.sellingPrice = sellingPrice
3589 
    args.isFba = isFba
3590 
    args.isNonFba = isNonFba
3591 
    args.isInventoryOverride = isInventoryOverride
3592 
    args.write(self._oprot)
3593 
    self._oprot.writeMessageEnd()
3594 
    self._oprot.trans.flush()
3595 
 
3596 
  def recv_updateAmazonItemDetails(self, ):
3597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3598 
    if mtype == TMessageType.EXCEPTION:
3599 
      x = TApplicationException()
3600 
      x.read(self._iprot)
3601 
      self._iprot.readMessageEnd()
3602 
      raise x
3603 
    result = updateAmazonItemDetails_result()
3604 
    result.read(self._iprot)
3605 
    self._iprot.readMessageEnd()
3606 
    return
3607 
 
3608 
  def addAmazonItem(self, amazonlisted):
3609 
    """
3610 
    Parameters:
3611 
     - amazonlisted
3612 
    """
3613 
    self.send_addAmazonItem(amazonlisted)
3614 
    self.recv_addAmazonItem()
3615 
 
3616 
  def send_addAmazonItem(self, amazonlisted):
3617 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3618 
    args = addAmazonItem_args()
3619 
    args.amazonlisted = amazonlisted
3620 
    args.write(self._oprot)
3621 
    self._oprot.writeMessageEnd()
3622 
    self._oprot.trans.flush()
3623 
 
3624 
  def recv_addAmazonItem(self, ):
3625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3626 
    if mtype == TMessageType.EXCEPTION:
3627 
      x = TApplicationException()
3628 
      x.read(self._iprot)
3629 
      self._iprot.readMessageEnd()
3630 
      raise x
3631 
    result = addAmazonItem_result()
3632 
    result.read(self._iprot)
3633 
    self._iprot.readMessageEnd()
3634 
    return
3635 
 
3636 
 
5944 mandeep.dh 3637 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3638 
  def __init__(self, handler):
3639 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3640 
    self._processMap["addItem"] = Processor.process_addItem
3641 
    self._processMap["updateItem"] = Processor.process_updateItem
3642 
    self._processMap["isActive"] = Processor.process_isActive
3643 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3644 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3645 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3646 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3647 
    self._processMap["getItem"] = Processor.process_getItem
3648 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3649 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3650 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3651 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3652 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3653 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3654 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3655 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3656 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3657 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3658 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3659 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3660 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3661 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3662 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3663 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3664 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3665 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3666 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3667 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3668 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3669 
    self._processMap["addCategory"] = Processor.process_addCategory
3670 
    self._processMap["getCategory"] = Processor.process_getCategory
3671 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3672 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3673 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3674 
    self._processMap["addTag"] = Processor.process_addTag
3675 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3676 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3677 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3678 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3679 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3680 
    self._processMap["addBanner"] = Processor.process_addBanner
3681 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3682 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3683 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3684 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3685 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3686 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3687 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3688 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3689 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3690 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3691 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3692 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3693 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3694 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3695 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3696 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3697 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3698 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3699 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3700 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3701 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3702 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3703 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3704 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3705 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3706 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3707 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3708 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3709 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3710 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3711 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3712 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3713 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3714 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3715 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3716 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3717 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3718 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3719 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3720 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3721 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3722 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3723 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3724 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3725 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3726 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7265 rajveer 3727 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3728 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3729 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3730 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3731 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
5944 mandeep.dh 3732 
 
3733 
  def process(self, iprot, oprot):
3734 
    (name, type, seqid) = iprot.readMessageBegin()
3735 
    if name not in self._processMap:
3736 
      iprot.skip(TType.STRUCT)
3737 
      iprot.readMessageEnd()
3738 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3739 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3740 
      x.write(oprot)
3741 
      oprot.writeMessageEnd()
3742 
      oprot.trans.flush()
3743 
      return
3744 
    else:
3745 
      self._processMap[name](self, seqid, iprot, oprot)
3746 
    return True
3747 
 
3748 
  def process_addItem(self, seqid, iprot, oprot):
3749 
    args = addItem_args()
3750 
    args.read(iprot)
3751 
    iprot.readMessageEnd()
3752 
    result = addItem_result()
3753 
    try:
3754 
      result.success = self._handler.addItem(args.item)
3755 
    except CatalogServiceException, cex:
3756 
      result.cex = cex
3757 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3758 
    result.write(oprot)
3759 
    oprot.writeMessageEnd()
3760 
    oprot.trans.flush()
3761 
 
3762 
  def process_updateItem(self, seqid, iprot, oprot):
3763 
    args = updateItem_args()
3764 
    args.read(iprot)
3765 
    iprot.readMessageEnd()
3766 
    result = updateItem_result()
3767 
    try:
3768 
      result.success = self._handler.updateItem(args.item)
3769 
    except CatalogServiceException, cex:
3770 
      result.cex = cex
3771 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3772 
    result.write(oprot)
3773 
    oprot.writeMessageEnd()
3774 
    oprot.trans.flush()
3775 
 
3776 
  def process_isActive(self, seqid, iprot, oprot):
3777 
    args = isActive_args()
3778 
    args.read(iprot)
3779 
    iprot.readMessageEnd()
3780 
    result = isActive_result()
3781 
    try:
3782 
      result.success = self._handler.isActive(args.itemId)
3783 
    except CatalogServiceException, isex:
3784 
      result.isex = isex
3785 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
3790 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3791 
    args = getItemStatusDescription_args()
3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
3794 
    result = getItemStatusDescription_result()
3795 
    try:
3796 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3797 
    except CatalogServiceException, isex:
3798 
      result.isex = isex
3799 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3800 
    result.write(oprot)
3801 
    oprot.writeMessageEnd()
3802 
    oprot.trans.flush()
3803 
 
3804 
  def process_startItemOn(self, seqid, iprot, oprot):
3805 
    args = startItemOn_args()
3806 
    args.read(iprot)
3807 
    iprot.readMessageEnd()
3808 
    result = startItemOn_result()
3809 
    try:
3810 
      self._handler.startItemOn(args.item_id, args.timestamp)
3811 
    except CatalogServiceException, cex:
3812 
      result.cex = cex
3813 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3814 
    result.write(oprot)
3815 
    oprot.writeMessageEnd()
3816 
    oprot.trans.flush()
3817 
 
3818 
  def process_retireItemOn(self, seqid, iprot, oprot):
3819 
    args = retireItemOn_args()
3820 
    args.read(iprot)
3821 
    iprot.readMessageEnd()
3822 
    result = retireItemOn_result()
3823 
    try:
3824 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3825 
    except CatalogServiceException, cex:
3826 
      result.cex = cex
3827 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
3831 
 
3832 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3833 
    args = changeItemStatus_args()
3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
3836 
    result = changeItemStatus_result()
3837 
    try:
3838 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3839 
    except CatalogServiceException, cex:
3840 
      result.cex = cex
3841 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
3845 
 
3846 
  def process_getItem(self, seqid, iprot, oprot):
3847 
    args = getItem_args()
3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
3850 
    result = getItem_result()
3851 
    try:
3852 
      result.success = self._handler.getItem(args.item_id)
3853 
    except CatalogServiceException, cex:
3854 
      result.cex = cex
3855 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3856 
    result.write(oprot)
3857 
    oprot.writeMessageEnd()
3858 
    oprot.trans.flush()
3859 
 
3860 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3861 
    args = getItemsByCatalogId_args()
3862 
    args.read(iprot)
3863 
    iprot.readMessageEnd()
3864 
    result = getItemsByCatalogId_result()
3865 
    try:
3866 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
3867 
    except CatalogServiceException, cex:
3868 
      result.cex = cex
3869 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
3870 
    result.write(oprot)
3871 
    oprot.writeMessageEnd()
3872 
    oprot.trans.flush()
3873 
 
3874 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
3875 
    args = getValidItemsByCatalogId_args()
3876 
    args.read(iprot)
3877 
    iprot.readMessageEnd()
3878 
    result = getValidItemsByCatalogId_result()
3879 
    try:
3880 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
3881 
    except CatalogServiceException, cex:
3882 
      result.cex = cex
3883 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
3884 
    result.write(oprot)
3885 
    oprot.writeMessageEnd()
3886 
    oprot.trans.flush()
3887 
 
3888 
  def process_getAllItems(self, seqid, iprot, oprot):
3889 
    args = getAllItems_args()
3890 
    args.read(iprot)
3891 
    iprot.readMessageEnd()
3892 
    result = getAllItems_result()
3893 
    try:
3894 
      result.success = self._handler.getAllItems(args.isActive)
3895 
    except CatalogServiceException, cex:
3896 
      result.cex = cex
3897 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
3898 
    result.write(oprot)
3899 
    oprot.writeMessageEnd()
3900 
    oprot.trans.flush()
3901 
 
3902 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
3903 
    args = getAllItemsByStatus_args()
3904 
    args.read(iprot)
3905 
    iprot.readMessageEnd()
3906 
    result = getAllItemsByStatus_result()
3907 
    try:
3908 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
3909 
    except CatalogServiceException, cex:
3910 
      result.cex = cex
3911 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
3912 
    result.write(oprot)
3913 
    oprot.writeMessageEnd()
3914 
    oprot.trans.flush()
3915 
 
3916 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
3917 
    args = markItemAsContentComplete_args()
3918 
    args.read(iprot)
3919 
    iprot.readMessageEnd()
3920 
    result = markItemAsContentComplete_result()
3921 
    try:
3922 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
3923 
    except CatalogServiceException, cex:
3924 
      result.cex = cex
3925 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
3926 
    result.write(oprot)
3927 
    oprot.writeMessageEnd()
3928 
    oprot.trans.flush()
3929 
 
3930 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
3931 
    args = getAllItemsInRange_args()
3932 
    args.read(iprot)
3933 
    iprot.readMessageEnd()
3934 
    result = getAllItemsInRange_result()
3935 
    try:
3936 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
3937 
    except CatalogServiceException, cex:
3938 
      result.cex = cex
3939 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
3940 
    result.write(oprot)
3941 
    oprot.writeMessageEnd()
3942 
    oprot.trans.flush()
3943 
 
3944 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
3945 
    args = getAllItemsByStatusInRange_args()
3946 
    args.read(iprot)
3947 
    iprot.readMessageEnd()
3948 
    result = getAllItemsByStatusInRange_result()
3949 
    try:
3950 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
3951 
    except CatalogServiceException, cex:
3952 
      result.cex = cex
3953 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
3954 
    result.write(oprot)
3955 
    oprot.writeMessageEnd()
3956 
    oprot.trans.flush()
3957 
 
3958 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
3959 
    args = getItemCountByStatus_args()
3960 
    args.read(iprot)
3961 
    iprot.readMessageEnd()
3962 
    result = getItemCountByStatus_result()
3963 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
3964 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
3965 
    result.write(oprot)
3966 
    oprot.writeMessageEnd()
3967 
    oprot.trans.flush()
3968 
 
3969 
  def process_getBestSellers(self, seqid, iprot, oprot):
3970 
    args = getBestSellers_args()
3971 
    args.read(iprot)
3972 
    iprot.readMessageEnd()
3973 
    result = getBestSellers_result()
3974 
    try:
3975 
      result.success = self._handler.getBestSellers()
3976 
    except CatalogServiceException, isex:
3977 
      result.isex = isex
3978 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
3979 
    result.write(oprot)
3980 
    oprot.writeMessageEnd()
3981 
    oprot.trans.flush()
3982 
 
3983 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
3984 
    args = getBestSellersCatalogIds_args()
3985 
    args.read(iprot)
3986 
    iprot.readMessageEnd()
3987 
    result = getBestSellersCatalogIds_result()
3988 
    try:
3989 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
3990 
    except CatalogServiceException, cex:
3991 
      result.cex = cex
3992 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
3993 
    result.write(oprot)
3994 
    oprot.writeMessageEnd()
3995 
    oprot.trans.flush()
3996 
 
3997 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
3998 
    args = getBestSellersCount_args()
3999 
    args.read(iprot)
4000 
    iprot.readMessageEnd()
4001 
    result = getBestSellersCount_result()
4002 
    try:
4003 
      result.success = self._handler.getBestSellersCount()
4004 
    except CatalogServiceException, cex:
4005 
      result.cex = cex
4006 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4007 
    result.write(oprot)
4008 
    oprot.writeMessageEnd()
4009 
    oprot.trans.flush()
4010 
 
4011 
  def process_getBestDeals(self, seqid, iprot, oprot):
4012 
    args = getBestDeals_args()
4013 
    args.read(iprot)
4014 
    iprot.readMessageEnd()
4015 
    result = getBestDeals_result()
4016 
    try:
4017 
      result.success = self._handler.getBestDeals()
4018 
    except CatalogServiceException, isex:
4019 
      result.isex = isex
4020 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4021 
    result.write(oprot)
4022 
    oprot.writeMessageEnd()
4023 
    oprot.trans.flush()
4024 
 
4025 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4026 
    args = getBestDealsCatalogIds_args()
4027 
    args.read(iprot)
4028 
    iprot.readMessageEnd()
4029 
    result = getBestDealsCatalogIds_result()
4030 
    try:
4031 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4032 
    except CatalogServiceException, cex:
4033 
      result.cex = cex
4034 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4035 
    result.write(oprot)
4036 
    oprot.writeMessageEnd()
4037 
    oprot.trans.flush()
4038 
 
4039 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4040 
    args = getBestDealsCount_args()
4041 
    args.read(iprot)
4042 
    iprot.readMessageEnd()
4043 
    result = getBestDealsCount_result()
4044 
    try:
4045 
      result.success = self._handler.getBestDealsCount()
4046 
    except CatalogServiceException, cex:
4047 
      result.cex = cex
4048 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4049 
    result.write(oprot)
4050 
    oprot.writeMessageEnd()
4051 
    oprot.trans.flush()
4052 
 
4053 
  def process_getComingSoon(self, seqid, iprot, oprot):
4054 
    args = getComingSoon_args()
4055 
    args.read(iprot)
4056 
    iprot.readMessageEnd()
4057 
    result = getComingSoon_result()
4058 
    try:
4059 
      result.success = self._handler.getComingSoon()
4060 
    except CatalogServiceException, isex:
4061 
      result.isex = isex
4062 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4063 
    result.write(oprot)
4064 
    oprot.writeMessageEnd()
4065 
    oprot.trans.flush()
4066 
 
4067 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4068 
    args = getComingSoonCatalogIds_args()
4069 
    args.read(iprot)
4070 
    iprot.readMessageEnd()
4071 
    result = getComingSoonCatalogIds_result()
4072 
    try:
4073 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4074 
    except CatalogServiceException, cex:
4075 
      result.cex = cex
4076 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4077 
    result.write(oprot)
4078 
    oprot.writeMessageEnd()
4079 
    oprot.trans.flush()
4080 
 
4081 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4082 
    args = getComingSoonCount_args()
4083 
    args.read(iprot)
4084 
    iprot.readMessageEnd()
4085 
    result = getComingSoonCount_result()
4086 
    try:
4087 
      result.success = self._handler.getComingSoonCount()
4088 
    except CatalogServiceException, cex:
4089 
      result.cex = cex
4090 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4091 
    result.write(oprot)
4092 
    oprot.writeMessageEnd()
4093 
    oprot.trans.flush()
4094 
 
4095 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4096 
    args = getLatestArrivals_args()
4097 
    args.read(iprot)
4098 
    iprot.readMessageEnd()
4099 
    result = getLatestArrivals_result()
4100 
    try:
4101 
      result.success = self._handler.getLatestArrivals()
4102 
    except CatalogServiceException, isex:
4103 
      result.isex = isex
4104 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4105 
    result.write(oprot)
4106 
    oprot.writeMessageEnd()
4107 
    oprot.trans.flush()
4108 
 
4109 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4110 
    args = getLatestArrivalsCatalogIds_args()
4111 
    args.read(iprot)
4112 
    iprot.readMessageEnd()
4113 
    result = getLatestArrivalsCatalogIds_result()
4114 
    try:
4115 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4116 
    except CatalogServiceException, cex:
4117 
      result.cex = cex
4118 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4119 
    result.write(oprot)
4120 
    oprot.writeMessageEnd()
4121 
    oprot.trans.flush()
4122 
 
4123 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4124 
    args = getLatestArrivalsCount_args()
4125 
    args.read(iprot)
4126 
    iprot.readMessageEnd()
4127 
    result = getLatestArrivalsCount_result()
4128 
    try:
4129 
      result.success = self._handler.getLatestArrivalsCount()
4130 
    except CatalogServiceException, cex:
4131 
      result.cex = cex
4132 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4133 
    result.write(oprot)
4134 
    oprot.writeMessageEnd()
4135 
    oprot.trans.flush()
4136 
 
4137 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4138 
    args = generateNewEntityID_args()
4139 
    args.read(iprot)
4140 
    iprot.readMessageEnd()
4141 
    result = generateNewEntityID_result()
4142 
    result.success = self._handler.generateNewEntityID()
4143 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4144 
    result.write(oprot)
4145 
    oprot.writeMessageEnd()
4146 
    oprot.trans.flush()
4147 
 
4148 
  def process_addCategory(self, seqid, iprot, oprot):
4149 
    args = addCategory_args()
4150 
    args.read(iprot)
4151 
    iprot.readMessageEnd()
4152 
    result = addCategory_result()
4153 
    result.success = self._handler.addCategory(args.category)
4154 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4155 
    result.write(oprot)
4156 
    oprot.writeMessageEnd()
4157 
    oprot.trans.flush()
4158 
 
4159 
  def process_getCategory(self, seqid, iprot, oprot):
4160 
    args = getCategory_args()
4161 
    args.read(iprot)
4162 
    iprot.readMessageEnd()
4163 
    result = getCategory_result()
4164 
    result.success = self._handler.getCategory(args.id)
4165 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4166 
    result.write(oprot)
4167 
    oprot.writeMessageEnd()
4168 
    oprot.trans.flush()
4169 
 
4170 
  def process_getAllCategories(self, seqid, iprot, oprot):
4171 
    args = getAllCategories_args()
4172 
    args.read(iprot)
4173 
    iprot.readMessageEnd()
4174 
    result = getAllCategories_result()
4175 
    result.success = self._handler.getAllCategories()
4176 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
4181 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4182 
    args = getAllSimilarItems_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = getAllSimilarItems_result()
4186 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4187 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4188 
    result.write(oprot)
4189 
    oprot.writeMessageEnd()
4190 
    oprot.trans.flush()
4191 
 
4192 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4193 
    args = addSimilarItem_args()
4194 
    args.read(iprot)
4195 
    iprot.readMessageEnd()
4196 
    result = addSimilarItem_result()
4197 
    try:
4198 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4199 
    except CatalogServiceException, cex:
4200 
      result.cex = cex
4201 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
6512 kshitij.so 4206 
  def process_addTag(self, seqid, iprot, oprot):
4207 
    args = addTag_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = addTag_result()
4211 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4212 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4213 
    result.write(oprot)
4214 
    oprot.writeMessageEnd()
4215 
    oprot.trans.flush()
4216 
 
4217 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4218 
    args = deleteEntityTag_args()
4219 
    args.read(iprot)
4220 
    iprot.readMessageEnd()
4221 
    result = deleteEntityTag_result()
4222 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4223 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4224 
    result.write(oprot)
4225 
    oprot.writeMessageEnd()
4226 
    oprot.trans.flush()
4227 
 
4228 
  def process_deleteTag(self, seqid, iprot, oprot):
4229 
    args = deleteTag_args()
4230 
    args.read(iprot)
4231 
    iprot.readMessageEnd()
4232 
    result = deleteTag_result()
4233 
    result.success = self._handler.deleteTag(args.displayName)
4234 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getAllTags(self, seqid, iprot, oprot):
4240 
    args = getAllTags_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getAllTags_result()
4244 
    result.success = self._handler.getAllTags()
4245 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4246 
    result.write(oprot)
4247 
    oprot.writeMessageEnd()
4248 
    oprot.trans.flush()
4249 
 
4250 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4251 
    args = getAllEntitiesByTagName_args()
4252 
    args.read(iprot)
4253 
    iprot.readMessageEnd()
4254 
    result = getAllEntitiesByTagName_result()
4255 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4256 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4257 
    result.write(oprot)
4258 
    oprot.writeMessageEnd()
4259 
    oprot.trans.flush()
4260 
 
6845 amit.gupta 4261 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4262 
    args = getAllEntityTags_args()
4263 
    args.read(iprot)
4264 
    iprot.readMessageEnd()
4265 
    result = getAllEntityTags_result()
4266 
    result.success = self._handler.getAllEntityTags()
4267 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4268 
    result.write(oprot)
4269 
    oprot.writeMessageEnd()
4270 
    oprot.trans.flush()
4271 
 
6850 kshitij.so 4272 
  def process_addBanner(self, seqid, iprot, oprot):
4273 
    args = addBanner_args()
4274 
    args.read(iprot)
4275 
    iprot.readMessageEnd()
4276 
    result = addBanner_result()
4277 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4278 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4279 
    result.write(oprot)
4280 
    oprot.writeMessageEnd()
4281 
    oprot.trans.flush()
4282 
 
4283 
  def process_getAllBanners(self, seqid, iprot, oprot):
4284 
    args = getAllBanners_args()
4285 
    args.read(iprot)
4286 
    iprot.readMessageEnd()
4287 
    result = getAllBanners_result()
4288 
    result.success = self._handler.getAllBanners()
4289 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4290 
    result.write(oprot)
4291 
    oprot.writeMessageEnd()
4292 
    oprot.trans.flush()
4293 
 
4294 
  def process_deleteBanner(self, seqid, iprot, oprot):
4295 
    args = deleteBanner_args()
4296 
    args.read(iprot)
4297 
    iprot.readMessageEnd()
4298 
    result = deleteBanner_result()
4299 
    result.success = self._handler.deleteBanner(args.bannerName)
4300 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4301 
    result.write(oprot)
4302 
    oprot.writeMessageEnd()
4303 
    oprot.trans.flush()
4304 
 
4305 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4306 
    args = getBannerDetails_args()
4307 
    args.read(iprot)
4308 
    iprot.readMessageEnd()
4309 
    result = getBannerDetails_result()
4310 
    result.success = self._handler.getBannerDetails(args.bannerName)
4311 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4312 
    result.write(oprot)
4313 
    oprot.writeMessageEnd()
4314 
    oprot.trans.flush()
4315 
 
4316 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4317 
    args = getActiveBanners_args()
4318 
    args.read(iprot)
4319 
    iprot.readMessageEnd()
4320 
    result = getActiveBanners_result()
4321 
    result.success = self._handler.getActiveBanners()
4322 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4323 
    result.write(oprot)
4324 
    oprot.writeMessageEnd()
4325 
    oprot.trans.flush()
4326 
 
6849 kshitij.so 4327 
  def process_addBannerMap(self, seqid, iprot, oprot):
4328 
    args = addBannerMap_args()
4329 
    args.read(iprot)
4330 
    iprot.readMessageEnd()
4331 
    result = addBannerMap_result()
4332 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4333 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4334 
    result.write(oprot)
4335 
    oprot.writeMessageEnd()
4336 
    oprot.trans.flush()
4337 
 
4338 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4339 
    args = deleteBannerMap_args()
4340 
    args.read(iprot)
4341 
    iprot.readMessageEnd()
4342 
    result = deleteBannerMap_result()
4343 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4344 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4345 
    result.write(oprot)
4346 
    oprot.writeMessageEnd()
4347 
    oprot.trans.flush()
4348 
 
4349 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4350 
    args = getBannerMapDetails_args()
4351 
    args.read(iprot)
4352 
    iprot.readMessageEnd()
4353 
    result = getBannerMapDetails_result()
4354 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4355 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
5944 mandeep.dh 4360 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4361 
    args = deleteSimilarItem_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = deleteSimilarItem_result()
4365 
    try:
4366 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4367 
    except CatalogServiceException, cex:
4368 
      result.cex = cex
4369 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4375 
    args = checkSimilarItem_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = checkSimilarItem_result()
4379 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4380 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4385 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4386 
    args = validateRiskyStatus_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = validateRiskyStatus_result()
4390 
    self._handler.validateRiskyStatus(args.itemId)
4391 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
4395 
 
4396 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4397 
    args = changeItemRiskyFlag_args()
4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
4400 
    result = changeItemRiskyFlag_result()
4401 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4402 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
4407 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4408 
    args = getItemsByRiskyFlag_args()
4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
4411 
    result = getItemsByRiskyFlag_result()
4412 
    result.success = self._handler.getItemsByRiskyFlag()
4413 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
4417 
 
4418 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4419 
    args = getItemsForMasterSheet_args()
4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
4422 
    result = getItemsForMasterSheet_result()
4423 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4424 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
4429 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4430 
    args = getSimilarItemsCatalogIds_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = getSimilarItemsCatalogIds_result()
4434 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4435 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4436 
    result.write(oprot)
4437 
    oprot.writeMessageEnd()
4438 
    oprot.trans.flush()
4439 
 
4440 
  def process_addProductNotification(self, seqid, iprot, oprot):
4441 
    args = addProductNotification_args()
4442 
    args.read(iprot)
4443 
    iprot.readMessageEnd()
4444 
    result = addProductNotification_result()
4445 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4446 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4447 
    result.write(oprot)
4448 
    oprot.writeMessageEnd()
4449 
    oprot.trans.flush()
4450 
 
4451 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4452 
    args = sendProductNotifications_args()
4453 
    args.read(iprot)
4454 
    iprot.readMessageEnd()
4455 
    result = sendProductNotifications_result()
4456 
    result.success = self._handler.sendProductNotifications()
4457 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4458 
    result.write(oprot)
4459 
    oprot.writeMessageEnd()
4460 
    oprot.trans.flush()
4461 
 
4462 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4463 
    args = getAllBrandsByCategory_args()
4464 
    args.read(iprot)
4465 
    iprot.readMessageEnd()
4466 
    result = getAllBrandsByCategory_result()
4467 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4468 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4469 
    result.write(oprot)
4470 
    oprot.writeMessageEnd()
4471 
    oprot.trans.flush()
4472 
 
4473 
  def process_getAllBrands(self, seqid, iprot, oprot):
4474 
    args = getAllBrands_args()
4475 
    args.read(iprot)
4476 
    iprot.readMessageEnd()
4477 
    result = getAllBrands_result()
4478 
    result.success = self._handler.getAllBrands()
4479 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4480 
    result.write(oprot)
4481 
    oprot.writeMessageEnd()
4482 
    oprot.trans.flush()
4483 
 
4484 
  def process_getAllSources(self, seqid, iprot, oprot):
4485 
    args = getAllSources_args()
4486 
    args.read(iprot)
4487 
    iprot.readMessageEnd()
4488 
    result = getAllSources_result()
4489 
    result.success = self._handler.getAllSources()
4490 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4491 
    result.write(oprot)
4492 
    oprot.writeMessageEnd()
4493 
    oprot.trans.flush()
4494 
 
4495 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4496 
    args = getItemPricingBySource_args()
4497 
    args.read(iprot)
4498 
    iprot.readMessageEnd()
4499 
    result = getItemPricingBySource_result()
4500 
    try:
4501 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4502 
    except CatalogServiceException, cex:
4503 
      result.cex = cex
4504 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
4508 
 
4509 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4510 
    args = addSourceItemPricing_args()
4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
4513 
    result = addSourceItemPricing_result()
4514 
    try:
4515 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4516 
    except CatalogServiceException, cex:
4517 
      result.cex = cex
4518 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4519 
    result.write(oprot)
4520 
    oprot.writeMessageEnd()
4521 
    oprot.trans.flush()
4522 
 
4523 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4524 
    args = getAllSourcePricing_args()
4525 
    args.read(iprot)
4526 
    iprot.readMessageEnd()
4527 
    result = getAllSourcePricing_result()
4528 
    try:
4529 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4530 
    except CatalogServiceException, cex:
4531 
      result.cex = cex
4532 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4533 
    result.write(oprot)
4534 
    oprot.writeMessageEnd()
4535 
    oprot.trans.flush()
4536 
 
4537 
  def process_getItemForSource(self, seqid, iprot, oprot):
4538 
    args = getItemForSource_args()
4539 
    args.read(iprot)
4540 
    iprot.readMessageEnd()
4541 
    result = getItemForSource_result()
4542 
    try:
4543 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4544 
    except CatalogServiceException, cex:
4545 
      result.cex = cex
4546 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4547 
    result.write(oprot)
4548 
    oprot.writeMessageEnd()
4549 
    oprot.trans.flush()
4550 
 
4551 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4552 
    args = searchItemsInRange_args()
4553 
    args.read(iprot)
4554 
    iprot.readMessageEnd()
4555 
    result = searchItemsInRange_result()
4556 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4557 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4558 
    result.write(oprot)
4559 
    oprot.writeMessageEnd()
4560 
    oprot.trans.flush()
4561 
 
4562 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4563 
    args = getSearchResultCount_args()
4564 
    args.read(iprot)
4565 
    iprot.readMessageEnd()
4566 
    result = getSearchResultCount_result()
4567 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4568 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4569 
    result.write(oprot)
4570 
    oprot.writeMessageEnd()
4571 
    oprot.trans.flush()
4572 
 
4573 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4574 
    args = getProductNotifications_args()
4575 
    args.read(iprot)
4576 
    iprot.readMessageEnd()
4577 
    result = getProductNotifications_result()
4578 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4579 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4580 
    result.write(oprot)
4581 
    oprot.writeMessageEnd()
4582 
    oprot.trans.flush()
4583 
 
4584 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4585 
    args = getProductNotificationRequestCount_args()
4586 
    args.read(iprot)
4587 
    iprot.readMessageEnd()
4588 
    result = getProductNotificationRequestCount_result()
4589 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4590 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4591 
    result.write(oprot)
4592 
    oprot.writeMessageEnd()
4593 
    oprot.trans.flush()
4594 
 
4595 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4596 
    args = addAuthorizationLog_args()
4597 
    args.read(iprot)
4598 
    iprot.readMessageEnd()
4599 
    result = addAuthorizationLog_result()
4600 
    try:
4601 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4602 
    except CatalogServiceException, cex:
4603 
      result.cex = cex
4604 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4605 
    result.write(oprot)
4606 
    oprot.writeMessageEnd()
4607 
    oprot.trans.flush()
4608 
 
4609 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4610 
    args = addupdateVoucherForItem_args()
4611 
    args.read(iprot)
4612 
    iprot.readMessageEnd()
4613 
    result = addupdateVoucherForItem_result()
4614 
    try:
4615 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4616 
    except CatalogServiceException, cex:
4617 
      result.cex = cex
4618 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4619 
    result.write(oprot)
4620 
    oprot.writeMessageEnd()
4621 
    oprot.trans.flush()
4622 
 
4623 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4624 
    args = deleteVoucherForItem_args()
4625 
    args.read(iprot)
4626 
    iprot.readMessageEnd()
4627 
    result = deleteVoucherForItem_result()
4628 
    try:
4629 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4630 
    except CatalogServiceException, cex:
4631 
      result.cex = cex
4632 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4633 
    result.write(oprot)
4634 
    oprot.writeMessageEnd()
4635 
    oprot.trans.flush()
4636 
 
4637 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4638 
    args = getVoucherAmount_args()
4639 
    args.read(iprot)
4640 
    iprot.readMessageEnd()
4641 
    result = getVoucherAmount_result()
4642 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4643 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4644 
    result.write(oprot)
4645 
    oprot.writeMessageEnd()
4646 
    oprot.trans.flush()
4647 
 
4648 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4649 
    args = getAllItemVouchers_args()
4650 
    args.read(iprot)
4651 
    iprot.readMessageEnd()
4652 
    result = getAllItemVouchers_result()
4653 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4654 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4655 
    result.write(oprot)
4656 
    oprot.writeMessageEnd()
4657 
    oprot.trans.flush()
4658 
 
4659 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4660 
    args = isValidCatalogItemId_args()
4661 
    args.read(iprot)
4662 
    iprot.readMessageEnd()
4663 
    result = isValidCatalogItemId_result()
4664 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4665 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4666 
    result.write(oprot)
4667 
    oprot.writeMessageEnd()
4668 
    oprot.trans.flush()
4669 
 
6039 amit.gupta 4670 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4671 
    args = getVatPercentageForItem_args()
4672 
    args.read(iprot)
4673 
    iprot.readMessageEnd()
4674 
    result = getVatPercentageForItem_result()
4675 
    result.success = self._handler.getVatPercentageForItem(args.itemId, args.price)
4676 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4677 
    result.write(oprot)
4678 
    oprot.writeMessageEnd()
4679 
    oprot.trans.flush()
5944 mandeep.dh 4680 
 
6039 amit.gupta 4681 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4682 
    args = getVatAmountForItem_args()
4683 
    args.read(iprot)
4684 
    iprot.readMessageEnd()
4685 
    result = getVatAmountForItem_result()
4686 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4687 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
6531 vikram.rag 4692 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4693 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4697 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4698 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4699 
    result.write(oprot)
4700 
    oprot.writeMessageEnd()
4701 
    oprot.trans.flush()
6039 amit.gupta 4702 
 
6821 amar.kumar 4703 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4704 
    args = getAllAliveItems_args()
4705 
    args.read(iprot)
4706 
    iprot.readMessageEnd()
4707 
    result = getAllAliveItems_result()
4708 
    result.success = self._handler.getAllAliveItems()
4709 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
6805 anupam.sin 4714 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4715 
    args = getInsuranceAmount_args()
4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
4718 
    result = getInsuranceAmount_result()
6921 anupam.sin 4719 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4720 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4721 
    result.write(oprot)
4722 
    oprot.writeMessageEnd()
4723 
    oprot.trans.flush()
6531 vikram.rag 4724 
 
6805 anupam.sin 4725 
  def process_getInsurer(self, seqid, iprot, oprot):
4726 
    args = getInsurer_args()
4727 
    args.read(iprot)
4728 
    iprot.readMessageEnd()
4729 
    result = getInsurer_result()
4730 
    result.success = self._handler.getInsurer(args.insurerId)
4731 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4732 
    result.write(oprot)
4733 
    oprot.writeMessageEnd()
4734 
    oprot.trans.flush()
4735 
 
6838 vikram.rag 4736 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4737 
    args = getAllInsurers_args()
4738 
    args.read(iprot)
4739 
    iprot.readMessageEnd()
4740 
    result = getAllInsurers_result()
4741 
    result.success = self._handler.getAllInsurers()
4742 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4743 
    result.write(oprot)
4744 
    oprot.writeMessageEnd()
4745 
    oprot.trans.flush()
6805 anupam.sin 4746 
 
6962 rajveer 4747 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4748 
    args = updateInsuranceDeclaredAmount_args()
4749 
    args.read(iprot)
4750 
    iprot.readMessageEnd()
4751 
    result = updateInsuranceDeclaredAmount_result()
4752 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4753 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4754 
    result.write(oprot)
4755 
    oprot.writeMessageEnd()
4756 
    oprot.trans.flush()
6838 vikram.rag 4757 
 
7190 amar.kumar 4758 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4759 
    args = getFreebieForItem_args()
4760 
    args.read(iprot)
4761 
    iprot.readMessageEnd()
4762 
    result = getFreebieForItem_result()
4763 
    result.success = self._handler.getFreebieForItem(args.itemId)
4764 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4765 
    result.write(oprot)
4766 
    oprot.writeMessageEnd()
4767 
    oprot.trans.flush()
6962 rajveer 4768 
 
7190 amar.kumar 4769 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4770 
    args = addOrUpdateFreebieForItem_args()
4771 
    args.read(iprot)
4772 
    iprot.readMessageEnd()
4773 
    result = addOrUpdateFreebieForItem_result()
4774 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4775 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4776 
    result.write(oprot)
4777 
    oprot.writeMessageEnd()
4778 
    oprot.trans.flush()
4779 
 
7272 amit.gupta 4780 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4781 
    args = addOrUpdateBrandInfo_args()
4782 
    args.read(iprot)
4783 
    iprot.readMessageEnd()
4784 
    result = addOrUpdateBrandInfo_result()
4785 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4786 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4787 
    result.write(oprot)
4788 
    oprot.writeMessageEnd()
4789 
    oprot.trans.flush()
4790 
 
4791 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4792 
    args = getBrandInfo_args()
4793 
    args.read(iprot)
4794 
    iprot.readMessageEnd()
4795 
    result = getBrandInfo_result()
4796 
    result.success = self._handler.getBrandInfo()
4797 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4798 
    result.write(oprot)
4799 
    oprot.writeMessageEnd()
4800 
    oprot.trans.flush()
4801 
 
7256 rajveer 4802 
  def process_getStorePricing(self, seqid, iprot, oprot):
4803 
    args = getStorePricing_args()
4804 
    args.read(iprot)
4805 
    iprot.readMessageEnd()
4806 
    result = getStorePricing_result()
4807 
    result.success = self._handler.getStorePricing(args.itemId)
4808 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4809 
    result.write(oprot)
4810 
    oprot.writeMessageEnd()
4811 
    oprot.trans.flush()
7190 amar.kumar 4812 
 
7265 rajveer 4813 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4814 
    args = updateStorePricing_args()
4815 
    args.read(iprot)
4816 
    iprot.readMessageEnd()
4817 
    result = updateStorePricing_result()
4818 
    self._handler.updateStorePricing(args.sp)
4819 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4820 
    result.write(oprot)
4821 
    oprot.writeMessageEnd()
4822 
    oprot.trans.flush()
7256 rajveer 4823 
 
7281 kshitij.so 4824 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4825 
    args = getAllAmazonListedItems_args()
4826 
    args.read(iprot)
4827 
    iprot.readMessageEnd()
4828 
    result = getAllAmazonListedItems_result()
4829 
    result.success = self._handler.getAllAmazonListedItems()
4830 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4831 
    result.write(oprot)
4832 
    oprot.writeMessageEnd()
4833 
    oprot.trans.flush()
7265 rajveer 4834 
 
7281 kshitij.so 4835 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4836 
    args = getAmazonItemDetails_args()
4837 
    args.read(iprot)
4838 
    iprot.readMessageEnd()
4839 
    result = getAmazonItemDetails_result()
4840 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4841 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
4846 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4847 
    args = updateAmazonItemDetails_args()
4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
4850 
    result = updateAmazonItemDetails_result()
4851 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride)
4852 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
4853 
    result.write(oprot)
4854 
    oprot.writeMessageEnd()
4855 
    oprot.trans.flush()
4856 
 
4857 
  def process_addAmazonItem(self, seqid, iprot, oprot):
4858 
    args = addAmazonItem_args()
4859 
    args.read(iprot)
4860 
    iprot.readMessageEnd()
4861 
    result = addAmazonItem_result()
4862 
    self._handler.addAmazonItem(args.amazonlisted)
4863 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
4864 
    result.write(oprot)
4865 
    oprot.writeMessageEnd()
4866 
    oprot.trans.flush()
4867 
 
4868 
 
5944 mandeep.dh 4869 
# HELPER FUNCTIONS AND STRUCTURES
4870 
 
4871 
class addItem_args:
4872 
  """
4873 
  Attributes:
4874 
   - item
4875 
  """
4876 
 
4877 
  thrift_spec = (
4878 
    None, # 0
4879 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
4880 
  )
4881 
 
4882 
  def __init__(self, item=None,):
4883 
    self.item = item
4884 
 
4885 
  def read(self, iprot):
4886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4888 
      return
4889 
    iprot.readStructBegin()
4890 
    while True:
4891 
      (fname, ftype, fid) = iprot.readFieldBegin()
4892 
      if ftype == TType.STOP:
4893 
        break
4894 
      if fid == 1:
4895 
        if ftype == TType.STRUCT:
4896 
          self.item = Item()
4897 
          self.item.read(iprot)
4898 
        else:
4899 
          iprot.skip(ftype)
4900 
      else:
4901 
        iprot.skip(ftype)
4902 
      iprot.readFieldEnd()
4903 
    iprot.readStructEnd()
4904 
 
4905 
  def write(self, oprot):
4906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4908 
      return
4909 
    oprot.writeStructBegin('addItem_args')
4910 
    if self.item is not None:
4911 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
4912 
      self.item.write(oprot)
4913 
      oprot.writeFieldEnd()
4914 
    oprot.writeFieldStop()
4915 
    oprot.writeStructEnd()
4916 
 
4917 
  def validate(self):
4918 
    return
4919 
 
4920 
 
4921 
  def __repr__(self):
4922 
    L = ['%s=%r' % (key, value)
4923 
      for key, value in self.__dict__.iteritems()]
4924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4925 
 
4926 
  def __eq__(self, other):
4927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4928 
 
4929 
  def __ne__(self, other):
4930 
    return not (self == other)
4931 
 
4932 
class addItem_result:
4933 
  """
4934 
  Attributes:
4935 
   - success
4936 
   - cex
4937 
  """
4938 
 
4939 
  thrift_spec = (
4940 
    (0, TType.I64, 'success', None, None, ), # 0
4941 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
4942 
  )
4943 
 
4944 
  def __init__(self, success=None, cex=None,):
4945 
    self.success = success
4946 
    self.cex = cex
4947 
 
4948 
  def read(self, iprot):
4949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4951 
      return
4952 
    iprot.readStructBegin()
4953 
    while True:
4954 
      (fname, ftype, fid) = iprot.readFieldBegin()
4955 
      if ftype == TType.STOP:
4956 
        break
4957 
      if fid == 0:
4958 
        if ftype == TType.I64:
4959 
          self.success = iprot.readI64();
4960 
        else:
4961 
          iprot.skip(ftype)
4962 
      elif fid == 1:
4963 
        if ftype == TType.STRUCT:
4964 
          self.cex = CatalogServiceException()
4965 
          self.cex.read(iprot)
4966 
        else:
4967 
          iprot.skip(ftype)
4968 
      else:
4969 
        iprot.skip(ftype)
4970 
      iprot.readFieldEnd()
4971 
    iprot.readStructEnd()
4972 
 
4973 
  def write(self, oprot):
4974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4976 
      return
4977 
    oprot.writeStructBegin('addItem_result')
4978 
    if self.success is not None:
4979 
      oprot.writeFieldBegin('success', TType.I64, 0)
4980 
      oprot.writeI64(self.success)
4981 
      oprot.writeFieldEnd()
4982 
    if self.cex is not None:
4983 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4984 
      self.cex.write(oprot)
4985 
      oprot.writeFieldEnd()
4986 
    oprot.writeFieldStop()
4987 
    oprot.writeStructEnd()
4988 
 
4989 
  def validate(self):
4990 
    return
4991 
 
4992 
 
4993 
  def __repr__(self):
4994 
    L = ['%s=%r' % (key, value)
4995 
      for key, value in self.__dict__.iteritems()]
4996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4997 
 
4998 
  def __eq__(self, other):
4999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5000 
 
5001 
  def __ne__(self, other):
5002 
    return not (self == other)
5003 
 
5004 
class updateItem_args:
5005 
  """
5006 
  Attributes:
5007 
   - item
5008 
  """
5009 
 
5010 
  thrift_spec = (
5011 
    None, # 0
5012 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5013 
  )
5014 
 
5015 
  def __init__(self, item=None,):
5016 
    self.item = item
5017 
 
5018 
  def read(self, iprot):
5019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5021 
      return
5022 
    iprot.readStructBegin()
5023 
    while True:
5024 
      (fname, ftype, fid) = iprot.readFieldBegin()
5025 
      if ftype == TType.STOP:
5026 
        break
5027 
      if fid == 1:
5028 
        if ftype == TType.STRUCT:
5029 
          self.item = Item()
5030 
          self.item.read(iprot)
5031 
        else:
5032 
          iprot.skip(ftype)
5033 
      else:
5034 
        iprot.skip(ftype)
5035 
      iprot.readFieldEnd()
5036 
    iprot.readStructEnd()
5037 
 
5038 
  def write(self, oprot):
5039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5041 
      return
5042 
    oprot.writeStructBegin('updateItem_args')
5043 
    if self.item is not None:
5044 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5045 
      self.item.write(oprot)
5046 
      oprot.writeFieldEnd()
5047 
    oprot.writeFieldStop()
5048 
    oprot.writeStructEnd()
5049 
 
5050 
  def validate(self):
5051 
    return
5052 
 
5053 
 
5054 
  def __repr__(self):
5055 
    L = ['%s=%r' % (key, value)
5056 
      for key, value in self.__dict__.iteritems()]
5057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5058 
 
5059 
  def __eq__(self, other):
5060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5061 
 
5062 
  def __ne__(self, other):
5063 
    return not (self == other)
5064 
 
5065 
class updateItem_result:
5066 
  """
5067 
  Attributes:
5068 
   - success
5069 
   - cex
5070 
  """
5071 
 
5072 
  thrift_spec = (
5073 
    (0, TType.I64, 'success', None, None, ), # 0
5074 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5075 
  )
5076 
 
5077 
  def __init__(self, success=None, cex=None,):
5078 
    self.success = success
5079 
    self.cex = cex
5080 
 
5081 
  def read(self, iprot):
5082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5084 
      return
5085 
    iprot.readStructBegin()
5086 
    while True:
5087 
      (fname, ftype, fid) = iprot.readFieldBegin()
5088 
      if ftype == TType.STOP:
5089 
        break
5090 
      if fid == 0:
5091 
        if ftype == TType.I64:
5092 
          self.success = iprot.readI64();
5093 
        else:
5094 
          iprot.skip(ftype)
5095 
      elif fid == 1:
5096 
        if ftype == TType.STRUCT:
5097 
          self.cex = CatalogServiceException()
5098 
          self.cex.read(iprot)
5099 
        else:
5100 
          iprot.skip(ftype)
5101 
      else:
5102 
        iprot.skip(ftype)
5103 
      iprot.readFieldEnd()
5104 
    iprot.readStructEnd()
5105 
 
5106 
  def write(self, oprot):
5107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5109 
      return
5110 
    oprot.writeStructBegin('updateItem_result')
5111 
    if self.success is not None:
5112 
      oprot.writeFieldBegin('success', TType.I64, 0)
5113 
      oprot.writeI64(self.success)
5114 
      oprot.writeFieldEnd()
5115 
    if self.cex is not None:
5116 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5117 
      self.cex.write(oprot)
5118 
      oprot.writeFieldEnd()
5119 
    oprot.writeFieldStop()
5120 
    oprot.writeStructEnd()
5121 
 
5122 
  def validate(self):
5123 
    return
5124 
 
5125 
 
5126 
  def __repr__(self):
5127 
    L = ['%s=%r' % (key, value)
5128 
      for key, value in self.__dict__.iteritems()]
5129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5130 
 
5131 
  def __eq__(self, other):
5132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5133 
 
5134 
  def __ne__(self, other):
5135 
    return not (self == other)
5136 
 
5137 
class isActive_args:
5138 
  """
5139 
  Attributes:
5140 
   - itemId
5141 
  """
5142 
 
5143 
  thrift_spec = (
5144 
    None, # 0
5145 
    (1, TType.I64, 'itemId', None, None, ), # 1
5146 
  )
5147 
 
5148 
  def __init__(self, itemId=None,):
5149 
    self.itemId = itemId
5150 
 
5151 
  def read(self, iprot):
5152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5154 
      return
5155 
    iprot.readStructBegin()
5156 
    while True:
5157 
      (fname, ftype, fid) = iprot.readFieldBegin()
5158 
      if ftype == TType.STOP:
5159 
        break
5160 
      if fid == 1:
5161 
        if ftype == TType.I64:
5162 
          self.itemId = iprot.readI64();
5163 
        else:
5164 
          iprot.skip(ftype)
5165 
      else:
5166 
        iprot.skip(ftype)
5167 
      iprot.readFieldEnd()
5168 
    iprot.readStructEnd()
5169 
 
5170 
  def write(self, oprot):
5171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5173 
      return
5174 
    oprot.writeStructBegin('isActive_args')
5175 
    if self.itemId is not None:
5176 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5177 
      oprot.writeI64(self.itemId)
5178 
      oprot.writeFieldEnd()
5179 
    oprot.writeFieldStop()
5180 
    oprot.writeStructEnd()
5181 
 
5182 
  def validate(self):
5183 
    return
5184 
 
5185 
 
5186 
  def __repr__(self):
5187 
    L = ['%s=%r' % (key, value)
5188 
      for key, value in self.__dict__.iteritems()]
5189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5190 
 
5191 
  def __eq__(self, other):
5192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5193 
 
5194 
  def __ne__(self, other):
5195 
    return not (self == other)
5196 
 
5197 
class isActive_result:
5198 
  """
5199 
  Attributes:
5200 
   - success
5201 
   - isex
5202 
  """
5203 
 
5204 
  thrift_spec = (
5205 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5206 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5207 
  )
5208 
 
5209 
  def __init__(self, success=None, isex=None,):
5210 
    self.success = success
5211 
    self.isex = isex
5212 
 
5213 
  def read(self, iprot):
5214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5216 
      return
5217 
    iprot.readStructBegin()
5218 
    while True:
5219 
      (fname, ftype, fid) = iprot.readFieldBegin()
5220 
      if ftype == TType.STOP:
5221 
        break
5222 
      if fid == 0:
5223 
        if ftype == TType.STRUCT:
5224 
          self.success = ItemShippingInfo()
5225 
          self.success.read(iprot)
5226 
        else:
5227 
          iprot.skip(ftype)
5228 
      elif fid == 1:
5229 
        if ftype == TType.STRUCT:
5230 
          self.isex = CatalogServiceException()
5231 
          self.isex.read(iprot)
5232 
        else:
5233 
          iprot.skip(ftype)
5234 
      else:
5235 
        iprot.skip(ftype)
5236 
      iprot.readFieldEnd()
5237 
    iprot.readStructEnd()
5238 
 
5239 
  def write(self, oprot):
5240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5242 
      return
5243 
    oprot.writeStructBegin('isActive_result')
5244 
    if self.success is not None:
5245 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5246 
      self.success.write(oprot)
5247 
      oprot.writeFieldEnd()
5248 
    if self.isex is not None:
5249 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5250 
      self.isex.write(oprot)
5251 
      oprot.writeFieldEnd()
5252 
    oprot.writeFieldStop()
5253 
    oprot.writeStructEnd()
5254 
 
5255 
  def validate(self):
5256 
    return
5257 
 
5258 
 
5259 
  def __repr__(self):
5260 
    L = ['%s=%r' % (key, value)
5261 
      for key, value in self.__dict__.iteritems()]
5262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5263 
 
5264 
  def __eq__(self, other):
5265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5266 
 
5267 
  def __ne__(self, other):
5268 
    return not (self == other)
5269 
 
5270 
class getItemStatusDescription_args:
5271 
  """
5272 
  Attributes:
5273 
   - itemId
5274 
  """
5275 
 
5276 
  thrift_spec = (
5277 
    None, # 0
5278 
    (1, TType.I64, 'itemId', None, None, ), # 1
5279 
  )
5280 
 
5281 
  def __init__(self, itemId=None,):
5282 
    self.itemId = itemId
5283 
 
5284 
  def read(self, iprot):
5285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5287 
      return
5288 
    iprot.readStructBegin()
5289 
    while True:
5290 
      (fname, ftype, fid) = iprot.readFieldBegin()
5291 
      if ftype == TType.STOP:
5292 
        break
5293 
      if fid == 1:
5294 
        if ftype == TType.I64:
5295 
          self.itemId = iprot.readI64();
5296 
        else:
5297 
          iprot.skip(ftype)
5298 
      else:
5299 
        iprot.skip(ftype)
5300 
      iprot.readFieldEnd()
5301 
    iprot.readStructEnd()
5302 
 
5303 
  def write(self, oprot):
5304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5306 
      return
5307 
    oprot.writeStructBegin('getItemStatusDescription_args')
5308 
    if self.itemId is not None:
5309 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5310 
      oprot.writeI64(self.itemId)
5311 
      oprot.writeFieldEnd()
5312 
    oprot.writeFieldStop()
5313 
    oprot.writeStructEnd()
5314 
 
5315 
  def validate(self):
5316 
    return
5317 
 
5318 
 
5319 
  def __repr__(self):
5320 
    L = ['%s=%r' % (key, value)
5321 
      for key, value in self.__dict__.iteritems()]
5322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5323 
 
5324 
  def __eq__(self, other):
5325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5326 
 
5327 
  def __ne__(self, other):
5328 
    return not (self == other)
5329 
 
5330 
class getItemStatusDescription_result:
5331 
  """
5332 
  Attributes:
5333 
   - success
5334 
   - isex
5335 
  """
5336 
 
5337 
  thrift_spec = (
5338 
    (0, TType.STRING, 'success', None, None, ), # 0
5339 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5340 
  )
5341 
 
5342 
  def __init__(self, success=None, isex=None,):
5343 
    self.success = success
5344 
    self.isex = isex
5345 
 
5346 
  def read(self, iprot):
5347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5349 
      return
5350 
    iprot.readStructBegin()
5351 
    while True:
5352 
      (fname, ftype, fid) = iprot.readFieldBegin()
5353 
      if ftype == TType.STOP:
5354 
        break
5355 
      if fid == 0:
5356 
        if ftype == TType.STRING:
5357 
          self.success = iprot.readString();
5358 
        else:
5359 
          iprot.skip(ftype)
5360 
      elif fid == 1:
5361 
        if ftype == TType.STRUCT:
5362 
          self.isex = CatalogServiceException()
5363 
          self.isex.read(iprot)
5364 
        else:
5365 
          iprot.skip(ftype)
5366 
      else:
5367 
        iprot.skip(ftype)
5368 
      iprot.readFieldEnd()
5369 
    iprot.readStructEnd()
5370 
 
5371 
  def write(self, oprot):
5372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5374 
      return
5375 
    oprot.writeStructBegin('getItemStatusDescription_result')
5376 
    if self.success is not None:
5377 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5378 
      oprot.writeString(self.success)
5379 
      oprot.writeFieldEnd()
5380 
    if self.isex is not None:
5381 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5382 
      self.isex.write(oprot)
5383 
      oprot.writeFieldEnd()
5384 
    oprot.writeFieldStop()
5385 
    oprot.writeStructEnd()
5386 
 
5387 
  def validate(self):
5388 
    return
5389 
 
5390 
 
5391 
  def __repr__(self):
5392 
    L = ['%s=%r' % (key, value)
5393 
      for key, value in self.__dict__.iteritems()]
5394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5395 
 
5396 
  def __eq__(self, other):
5397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5398 
 
5399 
  def __ne__(self, other):
5400 
    return not (self == other)
5401 
 
5402 
class startItemOn_args:
5403 
  """
5404 
  Attributes:
5405 
   - item_id
5406 
   - timestamp
5407 
  """
5408 
 
5409 
  thrift_spec = (
5410 
    None, # 0
5411 
    (1, TType.I64, 'item_id', None, None, ), # 1
5412 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5413 
  )
5414 
 
5415 
  def __init__(self, item_id=None, timestamp=None,):
5416 
    self.item_id = item_id
5417 
    self.timestamp = timestamp
5418 
 
5419 
  def read(self, iprot):
5420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5422 
      return
5423 
    iprot.readStructBegin()
5424 
    while True:
5425 
      (fname, ftype, fid) = iprot.readFieldBegin()
5426 
      if ftype == TType.STOP:
5427 
        break
5428 
      if fid == 1:
5429 
        if ftype == TType.I64:
5430 
          self.item_id = iprot.readI64();
5431 
        else:
5432 
          iprot.skip(ftype)
5433 
      elif fid == 2:
5434 
        if ftype == TType.I64:
5435 
          self.timestamp = iprot.readI64();
5436 
        else:
5437 
          iprot.skip(ftype)
5438 
      else:
5439 
        iprot.skip(ftype)
5440 
      iprot.readFieldEnd()
5441 
    iprot.readStructEnd()
5442 
 
5443 
  def write(self, oprot):
5444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5446 
      return
5447 
    oprot.writeStructBegin('startItemOn_args')
5448 
    if self.item_id is not None:
5449 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5450 
      oprot.writeI64(self.item_id)
5451 
      oprot.writeFieldEnd()
5452 
    if self.timestamp is not None:
5453 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5454 
      oprot.writeI64(self.timestamp)
5455 
      oprot.writeFieldEnd()
5456 
    oprot.writeFieldStop()
5457 
    oprot.writeStructEnd()
5458 
 
5459 
  def validate(self):
5460 
    return
5461 
 
5462 
 
5463 
  def __repr__(self):
5464 
    L = ['%s=%r' % (key, value)
5465 
      for key, value in self.__dict__.iteritems()]
5466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5467 
 
5468 
  def __eq__(self, other):
5469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5470 
 
5471 
  def __ne__(self, other):
5472 
    return not (self == other)
5473 
 
5474 
class startItemOn_result:
5475 
  """
5476 
  Attributes:
5477 
   - cex
5478 
  """
5479 
 
5480 
  thrift_spec = (
5481 
    None, # 0
5482 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5483 
  )
5484 
 
5485 
  def __init__(self, cex=None,):
5486 
    self.cex = cex
5487 
 
5488 
  def read(self, iprot):
5489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5491 
      return
5492 
    iprot.readStructBegin()
5493 
    while True:
5494 
      (fname, ftype, fid) = iprot.readFieldBegin()
5495 
      if ftype == TType.STOP:
5496 
        break
5497 
      if fid == 1:
5498 
        if ftype == TType.STRUCT:
5499 
          self.cex = CatalogServiceException()
5500 
          self.cex.read(iprot)
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      else:
5504 
        iprot.skip(ftype)
5505 
      iprot.readFieldEnd()
5506 
    iprot.readStructEnd()
5507 
 
5508 
  def write(self, oprot):
5509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5511 
      return
5512 
    oprot.writeStructBegin('startItemOn_result')
5513 
    if self.cex is not None:
5514 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5515 
      self.cex.write(oprot)
5516 
      oprot.writeFieldEnd()
5517 
    oprot.writeFieldStop()
5518 
    oprot.writeStructEnd()
5519 
 
5520 
  def validate(self):
5521 
    return
5522 
 
5523 
 
5524 
  def __repr__(self):
5525 
    L = ['%s=%r' % (key, value)
5526 
      for key, value in self.__dict__.iteritems()]
5527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5528 
 
5529 
  def __eq__(self, other):
5530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5531 
 
5532 
  def __ne__(self, other):
5533 
    return not (self == other)
5534 
 
5535 
class retireItemOn_args:
5536 
  """
5537 
  Attributes:
5538 
   - item_id
5539 
   - timestamp
5540 
  """
5541 
 
5542 
  thrift_spec = (
5543 
    None, # 0
5544 
    (1, TType.I64, 'item_id', None, None, ), # 1
5545 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5546 
  )
5547 
 
5548 
  def __init__(self, item_id=None, timestamp=None,):
5549 
    self.item_id = item_id
5550 
    self.timestamp = timestamp
5551 
 
5552 
  def read(self, iprot):
5553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5555 
      return
5556 
    iprot.readStructBegin()
5557 
    while True:
5558 
      (fname, ftype, fid) = iprot.readFieldBegin()
5559 
      if ftype == TType.STOP:
5560 
        break
5561 
      if fid == 1:
5562 
        if ftype == TType.I64:
5563 
          self.item_id = iprot.readI64();
5564 
        else:
5565 
          iprot.skip(ftype)
5566 
      elif fid == 2:
5567 
        if ftype == TType.I64:
5568 
          self.timestamp = iprot.readI64();
5569 
        else:
5570 
          iprot.skip(ftype)
5571 
      else:
5572 
        iprot.skip(ftype)
5573 
      iprot.readFieldEnd()
5574 
    iprot.readStructEnd()
5575 
 
5576 
  def write(self, oprot):
5577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5579 
      return
5580 
    oprot.writeStructBegin('retireItemOn_args')
5581 
    if self.item_id is not None:
5582 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5583 
      oprot.writeI64(self.item_id)
5584 
      oprot.writeFieldEnd()
5585 
    if self.timestamp is not None:
5586 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5587 
      oprot.writeI64(self.timestamp)
5588 
      oprot.writeFieldEnd()
5589 
    oprot.writeFieldStop()
5590 
    oprot.writeStructEnd()
5591 
 
5592 
  def validate(self):
5593 
    return
5594 
 
5595 
 
5596 
  def __repr__(self):
5597 
    L = ['%s=%r' % (key, value)
5598 
      for key, value in self.__dict__.iteritems()]
5599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5600 
 
5601 
  def __eq__(self, other):
5602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5603 
 
5604 
  def __ne__(self, other):
5605 
    return not (self == other)
5606 
 
5607 
class retireItemOn_result:
5608 
  """
5609 
  Attributes:
5610 
   - cex
5611 
  """
5612 
 
5613 
  thrift_spec = (
5614 
    None, # 0
5615 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5616 
  )
5617 
 
5618 
  def __init__(self, cex=None,):
5619 
    self.cex = cex
5620 
 
5621 
  def read(self, iprot):
5622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5624 
      return
5625 
    iprot.readStructBegin()
5626 
    while True:
5627 
      (fname, ftype, fid) = iprot.readFieldBegin()
5628 
      if ftype == TType.STOP:
5629 
        break
5630 
      if fid == 1:
5631 
        if ftype == TType.STRUCT:
5632 
          self.cex = CatalogServiceException()
5633 
          self.cex.read(iprot)
5634 
        else:
5635 
          iprot.skip(ftype)
5636 
      else:
5637 
        iprot.skip(ftype)
5638 
      iprot.readFieldEnd()
5639 
    iprot.readStructEnd()
5640 
 
5641 
  def write(self, oprot):
5642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5644 
      return
5645 
    oprot.writeStructBegin('retireItemOn_result')
5646 
    if self.cex is not None:
5647 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5648 
      self.cex.write(oprot)
5649 
      oprot.writeFieldEnd()
5650 
    oprot.writeFieldStop()
5651 
    oprot.writeStructEnd()
5652 
 
5653 
  def validate(self):
5654 
    return
5655 
 
5656 
 
5657 
  def __repr__(self):
5658 
    L = ['%s=%r' % (key, value)
5659 
      for key, value in self.__dict__.iteritems()]
5660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5661 
 
5662 
  def __eq__(self, other):
5663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5664 
 
5665 
  def __ne__(self, other):
5666 
    return not (self == other)
5667 
 
5668 
class changeItemStatus_args:
5669 
  """
5670 
  Attributes:
5671 
   - item_id
5672 
   - timestamp
5673 
   - newstatus
5674 
  """
5675 
 
5676 
  thrift_spec = (
5677 
    None, # 0
5678 
    (1, TType.I64, 'item_id', None, None, ), # 1
5679 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5680 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5681 
  )
5682 
 
5683 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5684 
    self.item_id = item_id
5685 
    self.timestamp = timestamp
5686 
    self.newstatus = newstatus
5687 
 
5688 
  def read(self, iprot):
5689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5691 
      return
5692 
    iprot.readStructBegin()
5693 
    while True:
5694 
      (fname, ftype, fid) = iprot.readFieldBegin()
5695 
      if ftype == TType.STOP:
5696 
        break
5697 
      if fid == 1:
5698 
        if ftype == TType.I64:
5699 
          self.item_id = iprot.readI64();
5700 
        else:
5701 
          iprot.skip(ftype)
5702 
      elif fid == 2:
5703 
        if ftype == TType.I64:
5704 
          self.timestamp = iprot.readI64();
5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      elif fid == 3:
5708 
        if ftype == TType.I32:
5709 
          self.newstatus = iprot.readI32();
5710 
        else:
5711 
          iprot.skip(ftype)
5712 
      else:
5713 
        iprot.skip(ftype)
5714 
      iprot.readFieldEnd()
5715 
    iprot.readStructEnd()
5716 
 
5717 
  def write(self, oprot):
5718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5720 
      return
5721 
    oprot.writeStructBegin('changeItemStatus_args')
5722 
    if self.item_id is not None:
5723 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5724 
      oprot.writeI64(self.item_id)
5725 
      oprot.writeFieldEnd()
5726 
    if self.timestamp is not None:
5727 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5728 
      oprot.writeI64(self.timestamp)
5729 
      oprot.writeFieldEnd()
5730 
    if self.newstatus is not None:
5731 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5732 
      oprot.writeI32(self.newstatus)
5733 
      oprot.writeFieldEnd()
5734 
    oprot.writeFieldStop()
5735 
    oprot.writeStructEnd()
5736 
 
5737 
  def validate(self):
5738 
    return
5739 
 
5740 
 
5741 
  def __repr__(self):
5742 
    L = ['%s=%r' % (key, value)
5743 
      for key, value in self.__dict__.iteritems()]
5744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5745 
 
5746 
  def __eq__(self, other):
5747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5748 
 
5749 
  def __ne__(self, other):
5750 
    return not (self == other)
5751 
 
5752 
class changeItemStatus_result:
5753 
  """
5754 
  Attributes:
5755 
   - cex
5756 
  """
5757 
 
5758 
  thrift_spec = (
5759 
    None, # 0
5760 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5761 
  )
5762 
 
5763 
  def __init__(self, cex=None,):
5764 
    self.cex = cex
5765 
 
5766 
  def read(self, iprot):
5767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5769 
      return
5770 
    iprot.readStructBegin()
5771 
    while True:
5772 
      (fname, ftype, fid) = iprot.readFieldBegin()
5773 
      if ftype == TType.STOP:
5774 
        break
5775 
      if fid == 1:
5776 
        if ftype == TType.STRUCT:
5777 
          self.cex = CatalogServiceException()
5778 
          self.cex.read(iprot)
5779 
        else:
5780 
          iprot.skip(ftype)
5781 
      else:
5782 
        iprot.skip(ftype)
5783 
      iprot.readFieldEnd()
5784 
    iprot.readStructEnd()
5785 
 
5786 
  def write(self, oprot):
5787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5789 
      return
5790 
    oprot.writeStructBegin('changeItemStatus_result')
5791 
    if self.cex is not None:
5792 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5793 
      self.cex.write(oprot)
5794 
      oprot.writeFieldEnd()
5795 
    oprot.writeFieldStop()
5796 
    oprot.writeStructEnd()
5797 
 
5798 
  def validate(self):
5799 
    return
5800 
 
5801 
 
5802 
  def __repr__(self):
5803 
    L = ['%s=%r' % (key, value)
5804 
      for key, value in self.__dict__.iteritems()]
5805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5806 
 
5807 
  def __eq__(self, other):
5808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5809 
 
5810 
  def __ne__(self, other):
5811 
    return not (self == other)
5812 
 
5813 
class getItem_args:
5814 
  """
5815 
  Attributes:
5816 
   - item_id
5817 
  """
5818 
 
5819 
  thrift_spec = (
5820 
    None, # 0
5821 
    (1, TType.I64, 'item_id', None, None, ), # 1
5822 
  )
5823 
 
5824 
  def __init__(self, item_id=None,):
5825 
    self.item_id = item_id
5826 
 
5827 
  def read(self, iprot):
5828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5830 
      return
5831 
    iprot.readStructBegin()
5832 
    while True:
5833 
      (fname, ftype, fid) = iprot.readFieldBegin()
5834 
      if ftype == TType.STOP:
5835 
        break
5836 
      if fid == 1:
5837 
        if ftype == TType.I64:
5838 
          self.item_id = iprot.readI64();
5839 
        else:
5840 
          iprot.skip(ftype)
5841 
      else:
5842 
        iprot.skip(ftype)
5843 
      iprot.readFieldEnd()
5844 
    iprot.readStructEnd()
5845 
 
5846 
  def write(self, oprot):
5847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5849 
      return
5850 
    oprot.writeStructBegin('getItem_args')
5851 
    if self.item_id is not None:
5852 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5853 
      oprot.writeI64(self.item_id)
5854 
      oprot.writeFieldEnd()
5855 
    oprot.writeFieldStop()
5856 
    oprot.writeStructEnd()
5857 
 
5858 
  def validate(self):
5859 
    return
5860 
 
5861 
 
5862 
  def __repr__(self):
5863 
    L = ['%s=%r' % (key, value)
5864 
      for key, value in self.__dict__.iteritems()]
5865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5866 
 
5867 
  def __eq__(self, other):
5868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5869 
 
5870 
  def __ne__(self, other):
5871 
    return not (self == other)
5872 
 
5873 
class getItem_result:
5874 
  """
5875 
  Attributes:
5876 
   - success
5877 
   - cex
5878 
  """
5879 
 
5880 
  thrift_spec = (
5881 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
5882 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5883 
  )
5884 
 
5885 
  def __init__(self, success=None, cex=None,):
5886 
    self.success = success
5887 
    self.cex = cex
5888 
 
5889 
  def read(self, iprot):
5890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5892 
      return
5893 
    iprot.readStructBegin()
5894 
    while True:
5895 
      (fname, ftype, fid) = iprot.readFieldBegin()
5896 
      if ftype == TType.STOP:
5897 
        break
5898 
      if fid == 0:
5899 
        if ftype == TType.STRUCT:
5900 
          self.success = Item()
5901 
          self.success.read(iprot)
5902 
        else:
5903 
          iprot.skip(ftype)
5904 
      elif fid == 1:
5905 
        if ftype == TType.STRUCT:
5906 
          self.cex = CatalogServiceException()
5907 
          self.cex.read(iprot)
5908 
        else:
5909 
          iprot.skip(ftype)
5910 
      else:
5911 
        iprot.skip(ftype)
5912 
      iprot.readFieldEnd()
5913 
    iprot.readStructEnd()
5914 
 
5915 
  def write(self, oprot):
5916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5918 
      return
5919 
    oprot.writeStructBegin('getItem_result')
5920 
    if self.success is not None:
5921 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5922 
      self.success.write(oprot)
5923 
      oprot.writeFieldEnd()
5924 
    if self.cex is not None:
5925 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5926 
      self.cex.write(oprot)
5927 
      oprot.writeFieldEnd()
5928 
    oprot.writeFieldStop()
5929 
    oprot.writeStructEnd()
5930 
 
5931 
  def validate(self):
5932 
    return
5933 
 
5934 
 
5935 
  def __repr__(self):
5936 
    L = ['%s=%r' % (key, value)
5937 
      for key, value in self.__dict__.iteritems()]
5938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5939 
 
5940 
  def __eq__(self, other):
5941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5942 
 
5943 
  def __ne__(self, other):
5944 
    return not (self == other)
5945 
 
5946 
class getItemsByCatalogId_args:
5947 
  """
5948 
  Attributes:
5949 
   - catalog_item_id
5950 
  """
5951 
 
5952 
  thrift_spec = (
5953 
    None, # 0
5954 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
5955 
  )
5956 
 
5957 
  def __init__(self, catalog_item_id=None,):
5958 
    self.catalog_item_id = catalog_item_id
5959 
 
5960 
  def read(self, iprot):
5961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5963 
      return
5964 
    iprot.readStructBegin()
5965 
    while True:
5966 
      (fname, ftype, fid) = iprot.readFieldBegin()
5967 
      if ftype == TType.STOP:
5968 
        break
5969 
      if fid == 1:
5970 
        if ftype == TType.I64:
5971 
          self.catalog_item_id = iprot.readI64();
5972 
        else:
5973 
          iprot.skip(ftype)
5974 
      else:
5975 
        iprot.skip(ftype)
5976 
      iprot.readFieldEnd()
5977 
    iprot.readStructEnd()
5978 
 
5979 
  def write(self, oprot):
5980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5982 
      return
5983 
    oprot.writeStructBegin('getItemsByCatalogId_args')
5984 
    if self.catalog_item_id is not None:
5985 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
5986 
      oprot.writeI64(self.catalog_item_id)
5987 
      oprot.writeFieldEnd()
5988 
    oprot.writeFieldStop()
5989 
    oprot.writeStructEnd()
5990 
 
5991 
  def validate(self):
5992 
    return
5993 
 
5994 
 
5995 
  def __repr__(self):
5996 
    L = ['%s=%r' % (key, value)
5997 
      for key, value in self.__dict__.iteritems()]
5998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5999 
 
6000 
  def __eq__(self, other):
6001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6002 
 
6003 
  def __ne__(self, other):
6004 
    return not (self == other)
6005 
 
6006 
class getItemsByCatalogId_result:
6007 
  """
6008 
  Attributes:
6009 
   - success
6010 
   - cex
6011 
  """
6012 
 
6013 
  thrift_spec = (
6014 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6015 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6016 
  )
6017 
 
6018 
  def __init__(self, success=None, cex=None,):
6019 
    self.success = success
6020 
    self.cex = cex
6021 
 
6022 
  def read(self, iprot):
6023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6025 
      return
6026 
    iprot.readStructBegin()
6027 
    while True:
6028 
      (fname, ftype, fid) = iprot.readFieldBegin()
6029 
      if ftype == TType.STOP:
6030 
        break
6031 
      if fid == 0:
6032 
        if ftype == TType.LIST:
6033 
          self.success = []
6034 
          (_etype19, _size16) = iprot.readListBegin()
6035 
          for _i20 in xrange(_size16):
6036 
            _elem21 = Item()
6037 
            _elem21.read(iprot)
6038 
            self.success.append(_elem21)
6039 
          iprot.readListEnd()
6040 
        else:
6041 
          iprot.skip(ftype)
6042 
      elif fid == 1:
6043 
        if ftype == TType.STRUCT:
6044 
          self.cex = CatalogServiceException()
6045 
          self.cex.read(iprot)
6046 
        else:
6047 
          iprot.skip(ftype)
6048 
      else:
6049 
        iprot.skip(ftype)
6050 
      iprot.readFieldEnd()
6051 
    iprot.readStructEnd()
6052 
 
6053 
  def write(self, oprot):
6054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6056 
      return
6057 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6058 
    if self.success is not None:
6059 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6060 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6061 
      for iter22 in self.success:
6062 
        iter22.write(oprot)
6063 
      oprot.writeListEnd()
6064 
      oprot.writeFieldEnd()
6065 
    if self.cex is not None:
6066 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6067 
      self.cex.write(oprot)
6068 
      oprot.writeFieldEnd()
6069 
    oprot.writeFieldStop()
6070 
    oprot.writeStructEnd()
6071 
 
6072 
  def validate(self):
6073 
    return
6074 
 
6075 
 
6076 
  def __repr__(self):
6077 
    L = ['%s=%r' % (key, value)
6078 
      for key, value in self.__dict__.iteritems()]
6079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6080 
 
6081 
  def __eq__(self, other):
6082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6083 
 
6084 
  def __ne__(self, other):
6085 
    return not (self == other)
6086 
 
6087 
class getValidItemsByCatalogId_args:
6088 
  """
6089 
  Attributes:
6090 
   - catalog_item_id
6091 
  """
6092 
 
6093 
  thrift_spec = (
6094 
    None, # 0
6095 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6096 
  )
6097 
 
6098 
  def __init__(self, catalog_item_id=None,):
6099 
    self.catalog_item_id = catalog_item_id
6100 
 
6101 
  def read(self, iprot):
6102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6104 
      return
6105 
    iprot.readStructBegin()
6106 
    while True:
6107 
      (fname, ftype, fid) = iprot.readFieldBegin()
6108 
      if ftype == TType.STOP:
6109 
        break
6110 
      if fid == 1:
6111 
        if ftype == TType.I64:
6112 
          self.catalog_item_id = iprot.readI64();
6113 
        else:
6114 
          iprot.skip(ftype)
6115 
      else:
6116 
        iprot.skip(ftype)
6117 
      iprot.readFieldEnd()
6118 
    iprot.readStructEnd()
6119 
 
6120 
  def write(self, oprot):
6121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6123 
      return
6124 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6125 
    if self.catalog_item_id is not None:
6126 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6127 
      oprot.writeI64(self.catalog_item_id)
6128 
      oprot.writeFieldEnd()
6129 
    oprot.writeFieldStop()
6130 
    oprot.writeStructEnd()
6131 
 
6132 
  def validate(self):
6133 
    return
6134 
 
6135 
 
6136 
  def __repr__(self):
6137 
    L = ['%s=%r' % (key, value)
6138 
      for key, value in self.__dict__.iteritems()]
6139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6140 
 
6141 
  def __eq__(self, other):
6142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6143 
 
6144 
  def __ne__(self, other):
6145 
    return not (self == other)
6146 
 
6147 
class getValidItemsByCatalogId_result:
6148 
  """
6149 
  Attributes:
6150 
   - success
6151 
   - cex
6152 
  """
6153 
 
6154 
  thrift_spec = (
6155 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6156 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6157 
  )
6158 
 
6159 
  def __init__(self, success=None, cex=None,):
6160 
    self.success = success
6161 
    self.cex = cex
6162 
 
6163 
  def read(self, iprot):
6164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6166 
      return
6167 
    iprot.readStructBegin()
6168 
    while True:
6169 
      (fname, ftype, fid) = iprot.readFieldBegin()
6170 
      if ftype == TType.STOP:
6171 
        break
6172 
      if fid == 0:
6173 
        if ftype == TType.LIST:
6174 
          self.success = []
6175 
          (_etype26, _size23) = iprot.readListBegin()
6176 
          for _i27 in xrange(_size23):
6177 
            _elem28 = Item()
6178 
            _elem28.read(iprot)
6179 
            self.success.append(_elem28)
6180 
          iprot.readListEnd()
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      elif fid == 1:
6184 
        if ftype == TType.STRUCT:
6185 
          self.cex = CatalogServiceException()
6186 
          self.cex.read(iprot)
6187 
        else:
6188 
          iprot.skip(ftype)
6189 
      else:
6190 
        iprot.skip(ftype)
6191 
      iprot.readFieldEnd()
6192 
    iprot.readStructEnd()
6193 
 
6194 
  def write(self, oprot):
6195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6197 
      return
6198 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6199 
    if self.success is not None:
6200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6202 
      for iter29 in self.success:
6203 
        iter29.write(oprot)
6204 
      oprot.writeListEnd()
6205 
      oprot.writeFieldEnd()
6206 
    if self.cex is not None:
6207 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6208 
      self.cex.write(oprot)
6209 
      oprot.writeFieldEnd()
6210 
    oprot.writeFieldStop()
6211 
    oprot.writeStructEnd()
6212 
 
6213 
  def validate(self):
6214 
    return
6215 
 
6216 
 
6217 
  def __repr__(self):
6218 
    L = ['%s=%r' % (key, value)
6219 
      for key, value in self.__dict__.iteritems()]
6220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6221 
 
6222 
  def __eq__(self, other):
6223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6224 
 
6225 
  def __ne__(self, other):
6226 
    return not (self == other)
6227 
 
6228 
class getAllItems_args:
6229 
  """
6230 
  Attributes:
6231 
   - isActive
6232 
  """
6233 
 
6234 
  thrift_spec = (
6235 
    None, # 0
6236 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6237 
  )
6238 
 
6239 
  def __init__(self, isActive=None,):
6240 
    self.isActive = isActive
6241 
 
6242 
  def read(self, iprot):
6243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6245 
      return
6246 
    iprot.readStructBegin()
6247 
    while True:
6248 
      (fname, ftype, fid) = iprot.readFieldBegin()
6249 
      if ftype == TType.STOP:
6250 
        break
6251 
      if fid == 1:
6252 
        if ftype == TType.BOOL:
6253 
          self.isActive = iprot.readBool();
6254 
        else:
6255 
          iprot.skip(ftype)
6256 
      else:
6257 
        iprot.skip(ftype)
6258 
      iprot.readFieldEnd()
6259 
    iprot.readStructEnd()
6260 
 
6261 
  def write(self, oprot):
6262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6264 
      return
6265 
    oprot.writeStructBegin('getAllItems_args')
6266 
    if self.isActive is not None:
6267 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6268 
      oprot.writeBool(self.isActive)
6269 
      oprot.writeFieldEnd()
6270 
    oprot.writeFieldStop()
6271 
    oprot.writeStructEnd()
6272 
 
6273 
  def validate(self):
6274 
    return
6275 
 
6276 
 
6277 
  def __repr__(self):
6278 
    L = ['%s=%r' % (key, value)
6279 
      for key, value in self.__dict__.iteritems()]
6280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6281 
 
6282 
  def __eq__(self, other):
6283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6284 
 
6285 
  def __ne__(self, other):
6286 
    return not (self == other)
6287 
 
6288 
class getAllItems_result:
6289 
  """
6290 
  Attributes:
6291 
   - success
6292 
   - cex
6293 
  """
6294 
 
6295 
  thrift_spec = (
6296 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6297 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6298 
  )
6299 
 
6300 
  def __init__(self, success=None, cex=None,):
6301 
    self.success = success
6302 
    self.cex = cex
6303 
 
6304 
  def read(self, iprot):
6305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6307 
      return
6308 
    iprot.readStructBegin()
6309 
    while True:
6310 
      (fname, ftype, fid) = iprot.readFieldBegin()
6311 
      if ftype == TType.STOP:
6312 
        break
6313 
      if fid == 0:
6314 
        if ftype == TType.LIST:
6315 
          self.success = []
6316 
          (_etype33, _size30) = iprot.readListBegin()
6317 
          for _i34 in xrange(_size30):
6318 
            _elem35 = Item()
6319 
            _elem35.read(iprot)
6320 
            self.success.append(_elem35)
6321 
          iprot.readListEnd()
6322 
        else:
6323 
          iprot.skip(ftype)
6324 
      elif fid == 1:
6325 
        if ftype == TType.STRUCT:
6326 
          self.cex = CatalogServiceException()
6327 
          self.cex.read(iprot)
6328 
        else:
6329 
          iprot.skip(ftype)
6330 
      else:
6331 
        iprot.skip(ftype)
6332 
      iprot.readFieldEnd()
6333 
    iprot.readStructEnd()
6334 
 
6335 
  def write(self, oprot):
6336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6338 
      return
6339 
    oprot.writeStructBegin('getAllItems_result')
6340 
    if self.success is not None:
6341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6342 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6343 
      for iter36 in self.success:
6344 
        iter36.write(oprot)
6345 
      oprot.writeListEnd()
6346 
      oprot.writeFieldEnd()
6347 
    if self.cex is not None:
6348 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6349 
      self.cex.write(oprot)
6350 
      oprot.writeFieldEnd()
6351 
    oprot.writeFieldStop()
6352 
    oprot.writeStructEnd()
6353 
 
6354 
  def validate(self):
6355 
    return
6356 
 
6357 
 
6358 
  def __repr__(self):
6359 
    L = ['%s=%r' % (key, value)
6360 
      for key, value in self.__dict__.iteritems()]
6361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6362 
 
6363 
  def __eq__(self, other):
6364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6365 
 
6366 
  def __ne__(self, other):
6367 
    return not (self == other)
6368 
 
6369 
class getAllItemsByStatus_args:
6370 
  """
6371 
  Attributes:
6372 
   - itemStatus
6373 
  """
6374 
 
6375 
  thrift_spec = (
6376 
    None, # 0
6377 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6378 
  )
6379 
 
6380 
  def __init__(self, itemStatus=None,):
6381 
    self.itemStatus = itemStatus
6382 
 
6383 
  def read(self, iprot):
6384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6386 
      return
6387 
    iprot.readStructBegin()
6388 
    while True:
6389 
      (fname, ftype, fid) = iprot.readFieldBegin()
6390 
      if ftype == TType.STOP:
6391 
        break
6392 
      if fid == 1:
6393 
        if ftype == TType.I32:
6394 
          self.itemStatus = iprot.readI32();
6395 
        else:
6396 
          iprot.skip(ftype)
6397 
      else:
6398 
        iprot.skip(ftype)
6399 
      iprot.readFieldEnd()
6400 
    iprot.readStructEnd()
6401 
 
6402 
  def write(self, oprot):
6403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6405 
      return
6406 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6407 
    if self.itemStatus is not None:
6408 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6409 
      oprot.writeI32(self.itemStatus)
6410 
      oprot.writeFieldEnd()
6411 
    oprot.writeFieldStop()
6412 
    oprot.writeStructEnd()
6413 
 
6414 
  def validate(self):
6415 
    return
6416 
 
6417 
 
6418 
  def __repr__(self):
6419 
    L = ['%s=%r' % (key, value)
6420 
      for key, value in self.__dict__.iteritems()]
6421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6422 
 
6423 
  def __eq__(self, other):
6424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6425 
 
6426 
  def __ne__(self, other):
6427 
    return not (self == other)
6428 
 
6429 
class getAllItemsByStatus_result:
6430 
  """
6431 
  Attributes:
6432 
   - success
6433 
   - cex
6434 
  """
6435 
 
6436 
  thrift_spec = (
6437 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6438 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6439 
  )
6440 
 
6441 
  def __init__(self, success=None, cex=None,):
6442 
    self.success = success
6443 
    self.cex = cex
6444 
 
6445 
  def read(self, iprot):
6446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6448 
      return
6449 
    iprot.readStructBegin()
6450 
    while True:
6451 
      (fname, ftype, fid) = iprot.readFieldBegin()
6452 
      if ftype == TType.STOP:
6453 
        break
6454 
      if fid == 0:
6455 
        if ftype == TType.LIST:
6456 
          self.success = []
6457 
          (_etype40, _size37) = iprot.readListBegin()
6458 
          for _i41 in xrange(_size37):
6459 
            _elem42 = Item()
6460 
            _elem42.read(iprot)
6461 
            self.success.append(_elem42)
6462 
          iprot.readListEnd()
6463 
        else:
6464 
          iprot.skip(ftype)
6465 
      elif fid == 1:
6466 
        if ftype == TType.STRUCT:
6467 
          self.cex = CatalogServiceException()
6468 
          self.cex.read(iprot)
6469 
        else:
6470 
          iprot.skip(ftype)
6471 
      else:
6472 
        iprot.skip(ftype)
6473 
      iprot.readFieldEnd()
6474 
    iprot.readStructEnd()
6475 
 
6476 
  def write(self, oprot):
6477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6479 
      return
6480 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6481 
    if self.success is not None:
6482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6484 
      for iter43 in self.success:
6485 
        iter43.write(oprot)
6486 
      oprot.writeListEnd()
6487 
      oprot.writeFieldEnd()
6488 
    if self.cex is not None:
6489 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6490 
      self.cex.write(oprot)
6491 
      oprot.writeFieldEnd()
6492 
    oprot.writeFieldStop()
6493 
    oprot.writeStructEnd()
6494 
 
6495 
  def validate(self):
6496 
    return
6497 
 
6498 
 
6499 
  def __repr__(self):
6500 
    L = ['%s=%r' % (key, value)
6501 
      for key, value in self.__dict__.iteritems()]
6502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6503 
 
6504 
  def __eq__(self, other):
6505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6506 
 
6507 
  def __ne__(self, other):
6508 
    return not (self == other)
6509 
 
6510 
class markItemAsContentComplete_args:
6511 
  """
6512 
  Attributes:
6513 
   - entityId
6514 
   - category
6515 
   - brand
6516 
   - modelName
6517 
   - modelNumber
6518 
  """
6519 
 
6520 
  thrift_spec = (
6521 
    None, # 0
6522 
    (1, TType.I64, 'entityId', None, None, ), # 1
6523 
    (2, TType.I64, 'category', None, None, ), # 2
6524 
    (3, TType.STRING, 'brand', None, None, ), # 3
6525 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6526 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6527 
  )
6528 
 
6529 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6530 
    self.entityId = entityId
6531 
    self.category = category
6532 
    self.brand = brand
6533 
    self.modelName = modelName
6534 
    self.modelNumber = modelNumber
6535 
 
6536 
  def read(self, iprot):
6537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6539 
      return
6540 
    iprot.readStructBegin()
6541 
    while True:
6542 
      (fname, ftype, fid) = iprot.readFieldBegin()
6543 
      if ftype == TType.STOP:
6544 
        break
6545 
      if fid == 1:
6546 
        if ftype == TType.I64:
6547 
          self.entityId = iprot.readI64();
6548 
        else:
6549 
          iprot.skip(ftype)
6550 
      elif fid == 2:
6551 
        if ftype == TType.I64:
6552 
          self.category = iprot.readI64();
6553 
        else:
6554 
          iprot.skip(ftype)
6555 
      elif fid == 3:
6556 
        if ftype == TType.STRING:
6557 
          self.brand = iprot.readString();
6558 
        else:
6559 
          iprot.skip(ftype)
6560 
      elif fid == 4:
6561 
        if ftype == TType.STRING:
6562 
          self.modelName = iprot.readString();
6563 
        else:
6564 
          iprot.skip(ftype)
6565 
      elif fid == 5:
6566 
        if ftype == TType.STRING:
6567 
          self.modelNumber = iprot.readString();
6568 
        else:
6569 
          iprot.skip(ftype)
6570 
      else:
6571 
        iprot.skip(ftype)
6572 
      iprot.readFieldEnd()
6573 
    iprot.readStructEnd()
6574 
 
6575 
  def write(self, oprot):
6576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6578 
      return
6579 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6580 
    if self.entityId is not None:
6581 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6582 
      oprot.writeI64(self.entityId)
6583 
      oprot.writeFieldEnd()
6584 
    if self.category is not None:
6585 
      oprot.writeFieldBegin('category', TType.I64, 2)
6586 
      oprot.writeI64(self.category)
6587 
      oprot.writeFieldEnd()
6588 
    if self.brand is not None:
6589 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6590 
      oprot.writeString(self.brand)
6591 
      oprot.writeFieldEnd()
6592 
    if self.modelName is not None:
6593 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6594 
      oprot.writeString(self.modelName)
6595 
      oprot.writeFieldEnd()
6596 
    if self.modelNumber is not None:
6597 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6598 
      oprot.writeString(self.modelNumber)
6599 
      oprot.writeFieldEnd()
6600 
    oprot.writeFieldStop()
6601 
    oprot.writeStructEnd()
6602 
 
6603 
  def validate(self):
6604 
    return
6605 
 
6606 
 
6607 
  def __repr__(self):
6608 
    L = ['%s=%r' % (key, value)
6609 
      for key, value in self.__dict__.iteritems()]
6610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6611 
 
6612 
  def __eq__(self, other):
6613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6614 
 
6615 
  def __ne__(self, other):
6616 
    return not (self == other)
6617 
 
6618 
class markItemAsContentComplete_result:
6619 
  """
6620 
  Attributes:
6621 
   - success
6622 
   - cex
6623 
  """
6624 
 
6625 
  thrift_spec = (
6626 
    (0, TType.BOOL, 'success', None, None, ), # 0
6627 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6628 
  )
6629 
 
6630 
  def __init__(self, success=None, cex=None,):
6631 
    self.success = success
6632 
    self.cex = cex
6633 
 
6634 
  def read(self, iprot):
6635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6637 
      return
6638 
    iprot.readStructBegin()
6639 
    while True:
6640 
      (fname, ftype, fid) = iprot.readFieldBegin()
6641 
      if ftype == TType.STOP:
6642 
        break
6643 
      if fid == 0:
6644 
        if ftype == TType.BOOL:
6645 
          self.success = iprot.readBool();
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('markItemAsContentComplete_result')
6664 
    if self.success is not None:
6665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6666 
      oprot.writeBool(self.success)
6667 
      oprot.writeFieldEnd()
6668 
    if self.cex is not None:
6669 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6670 
      self.cex.write(oprot)
6671 
      oprot.writeFieldEnd()
6672 
    oprot.writeFieldStop()
6673 
    oprot.writeStructEnd()
6674 
 
6675 
  def validate(self):
6676 
    return
6677 
 
6678 
 
6679 
  def __repr__(self):
6680 
    L = ['%s=%r' % (key, value)
6681 
      for key, value in self.__dict__.iteritems()]
6682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6683 
 
6684 
  def __eq__(self, other):
6685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6686 
 
6687 
  def __ne__(self, other):
6688 
    return not (self == other)
6689 
 
6690 
class getAllItemsInRange_args:
6691 
  """
6692 
  Attributes:
6693 
   - offset
6694 
   - limit
6695 
  """
6696 
 
6697 
  thrift_spec = (
6698 
    None, # 0
6699 
    (1, TType.I64, 'offset', None, None, ), # 1
6700 
    (2, TType.I64, 'limit', None, None, ), # 2
6701 
  )
6702 
 
6703 
  def __init__(self, offset=None, limit=None,):
6704 
    self.offset = offset
6705 
    self.limit = limit
6706 
 
6707 
  def read(self, iprot):
6708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6710 
      return
6711 
    iprot.readStructBegin()
6712 
    while True:
6713 
      (fname, ftype, fid) = iprot.readFieldBegin()
6714 
      if ftype == TType.STOP:
6715 
        break
6716 
      if fid == 1:
6717 
        if ftype == TType.I64:
6718 
          self.offset = iprot.readI64();
6719 
        else:
6720 
          iprot.skip(ftype)
6721 
      elif fid == 2:
6722 
        if ftype == TType.I64:
6723 
          self.limit = iprot.readI64();
6724 
        else:
6725 
          iprot.skip(ftype)
6726 
      else:
6727 
        iprot.skip(ftype)
6728 
      iprot.readFieldEnd()
6729 
    iprot.readStructEnd()
6730 
 
6731 
  def write(self, oprot):
6732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6734 
      return
6735 
    oprot.writeStructBegin('getAllItemsInRange_args')
6736 
    if self.offset is not None:
6737 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6738 
      oprot.writeI64(self.offset)
6739 
      oprot.writeFieldEnd()
6740 
    if self.limit is not None:
6741 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6742 
      oprot.writeI64(self.limit)
6743 
      oprot.writeFieldEnd()
6744 
    oprot.writeFieldStop()
6745 
    oprot.writeStructEnd()
6746 
 
6747 
  def validate(self):
6748 
    return
6749 
 
6750 
 
6751 
  def __repr__(self):
6752 
    L = ['%s=%r' % (key, value)
6753 
      for key, value in self.__dict__.iteritems()]
6754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6755 
 
6756 
  def __eq__(self, other):
6757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6758 
 
6759 
  def __ne__(self, other):
6760 
    return not (self == other)
6761 
 
6762 
class getAllItemsInRange_result:
6763 
  """
6764 
  Attributes:
6765 
   - success
6766 
   - cex
6767 
  """
6768 
 
6769 
  thrift_spec = (
6770 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6771 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6772 
  )
6773 
 
6774 
  def __init__(self, success=None, cex=None,):
6775 
    self.success = success
6776 
    self.cex = cex
6777 
 
6778 
  def read(self, iprot):
6779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6781 
      return
6782 
    iprot.readStructBegin()
6783 
    while True:
6784 
      (fname, ftype, fid) = iprot.readFieldBegin()
6785 
      if ftype == TType.STOP:
6786 
        break
6787 
      if fid == 0:
6788 
        if ftype == TType.LIST:
6789 
          self.success = []
6790 
          (_etype47, _size44) = iprot.readListBegin()
6791 
          for _i48 in xrange(_size44):
6792 
            _elem49 = Item()
6793 
            _elem49.read(iprot)
6794 
            self.success.append(_elem49)
6795 
          iprot.readListEnd()
6796 
        else:
6797 
          iprot.skip(ftype)
6798 
      elif fid == 1:
6799 
        if ftype == TType.STRUCT:
6800 
          self.cex = CatalogServiceException()
6801 
          self.cex.read(iprot)
6802 
        else:
6803 
          iprot.skip(ftype)
6804 
      else:
6805 
        iprot.skip(ftype)
6806 
      iprot.readFieldEnd()
6807 
    iprot.readStructEnd()
6808 
 
6809 
  def write(self, oprot):
6810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6812 
      return
6813 
    oprot.writeStructBegin('getAllItemsInRange_result')
6814 
    if self.success is not None:
6815 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6816 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6817 
      for iter50 in self.success:
6818 
        iter50.write(oprot)
6819 
      oprot.writeListEnd()
6820 
      oprot.writeFieldEnd()
6821 
    if self.cex is not None:
6822 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6823 
      self.cex.write(oprot)
6824 
      oprot.writeFieldEnd()
6825 
    oprot.writeFieldStop()
6826 
    oprot.writeStructEnd()
6827 
 
6828 
  def validate(self):
6829 
    return
6830 
 
6831 
 
6832 
  def __repr__(self):
6833 
    L = ['%s=%r' % (key, value)
6834 
      for key, value in self.__dict__.iteritems()]
6835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6836 
 
6837 
  def __eq__(self, other):
6838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6839 
 
6840 
  def __ne__(self, other):
6841 
    return not (self == other)
6842 
 
6843 
class getAllItemsByStatusInRange_args:
6844 
  """
6845 
  Attributes:
6846 
   - itemStatus
6847 
   - offset
6848 
   - limit
6849 
  """
6850 
 
6851 
  thrift_spec = (
6852 
    None, # 0
6853 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6854 
    (2, TType.I64, 'offset', None, None, ), # 2
6855 
    (3, TType.I64, 'limit', None, None, ), # 3
6856 
  )
6857 
 
6858 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
6859 
    self.itemStatus = itemStatus
6860 
    self.offset = offset
6861 
    self.limit = limit
6862 
 
6863 
  def read(self, iprot):
6864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6866 
      return
6867 
    iprot.readStructBegin()
6868 
    while True:
6869 
      (fname, ftype, fid) = iprot.readFieldBegin()
6870 
      if ftype == TType.STOP:
6871 
        break
6872 
      if fid == 1:
6873 
        if ftype == TType.I32:
6874 
          self.itemStatus = iprot.readI32();
6875 
        else:
6876 
          iprot.skip(ftype)
6877 
      elif fid == 2:
6878 
        if ftype == TType.I64:
6879 
          self.offset = iprot.readI64();
6880 
        else:
6881 
          iprot.skip(ftype)
6882 
      elif fid == 3:
6883 
        if ftype == TType.I64:
6884 
          self.limit = iprot.readI64();
6885 
        else:
6886 
          iprot.skip(ftype)
6887 
      else:
6888 
        iprot.skip(ftype)
6889 
      iprot.readFieldEnd()
6890 
    iprot.readStructEnd()
6891 
 
6892 
  def write(self, oprot):
6893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6895 
      return
6896 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
6897 
    if self.itemStatus is not None:
6898 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6899 
      oprot.writeI32(self.itemStatus)
6900 
      oprot.writeFieldEnd()
6901 
    if self.offset is not None:
6902 
      oprot.writeFieldBegin('offset', TType.I64, 2)
6903 
      oprot.writeI64(self.offset)
6904 
      oprot.writeFieldEnd()
6905 
    if self.limit is not None:
6906 
      oprot.writeFieldBegin('limit', TType.I64, 3)
6907 
      oprot.writeI64(self.limit)
6908 
      oprot.writeFieldEnd()
6909 
    oprot.writeFieldStop()
6910 
    oprot.writeStructEnd()
6911 
 
6912 
  def validate(self):
6913 
    return
6914 
 
6915 
 
6916 
  def __repr__(self):
6917 
    L = ['%s=%r' % (key, value)
6918 
      for key, value in self.__dict__.iteritems()]
6919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6920 
 
6921 
  def __eq__(self, other):
6922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6923 
 
6924 
  def __ne__(self, other):
6925 
    return not (self == other)
6926 
 
6927 
class getAllItemsByStatusInRange_result:
6928 
  """
6929 
  Attributes:
6930 
   - success
6931 
   - cex
6932 
  """
6933 
 
6934 
  thrift_spec = (
6935 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6936 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6937 
  )
6938 
 
6939 
  def __init__(self, success=None, cex=None,):
6940 
    self.success = success
6941 
    self.cex = cex
6942 
 
6943 
  def read(self, iprot):
6944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6946 
      return
6947 
    iprot.readStructBegin()
6948 
    while True:
6949 
      (fname, ftype, fid) = iprot.readFieldBegin()
6950 
      if ftype == TType.STOP:
6951 
        break
6952 
      if fid == 0:
6953 
        if ftype == TType.LIST:
6954 
          self.success = []
6955 
          (_etype54, _size51) = iprot.readListBegin()
6956 
          for _i55 in xrange(_size51):
6957 
            _elem56 = Item()
6958 
            _elem56.read(iprot)
6959 
            self.success.append(_elem56)
6960 
          iprot.readListEnd()
6961 
        else:
6962 
          iprot.skip(ftype)
6963 
      elif fid == 1:
6964 
        if ftype == TType.STRUCT:
6965 
          self.cex = CatalogServiceException()
6966 
          self.cex.read(iprot)
6967 
        else:
6968 
          iprot.skip(ftype)
6969 
      else:
6970 
        iprot.skip(ftype)
6971 
      iprot.readFieldEnd()
6972 
    iprot.readStructEnd()
6973 
 
6974 
  def write(self, oprot):
6975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6977 
      return
6978 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
6979 
    if self.success is not None:
6980 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6981 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6982 
      for iter57 in self.success:
6983 
        iter57.write(oprot)
6984 
      oprot.writeListEnd()
6985 
      oprot.writeFieldEnd()
6986 
    if self.cex is not None:
6987 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6988 
      self.cex.write(oprot)
6989 
      oprot.writeFieldEnd()
6990 
    oprot.writeFieldStop()
6991 
    oprot.writeStructEnd()
6992 
 
6993 
  def validate(self):
6994 
    return
6995 
 
6996 
 
6997 
  def __repr__(self):
6998 
    L = ['%s=%r' % (key, value)
6999 
      for key, value in self.__dict__.iteritems()]
7000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7001 
 
7002 
  def __eq__(self, other):
7003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7004 
 
7005 
  def __ne__(self, other):
7006 
    return not (self == other)
7007 
 
7008 
class getItemCountByStatus_args:
7009 
  """
7010 
  Attributes:
7011 
   - useStatus
7012 
   - itemStatus
7013 
  """
7014 
 
7015 
  thrift_spec = (
7016 
    None, # 0
7017 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7018 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7019 
  )
7020 
 
7021 
  def __init__(self, useStatus=None, itemStatus=None,):
7022 
    self.useStatus = useStatus
7023 
    self.itemStatus = itemStatus
7024 
 
7025 
  def read(self, iprot):
7026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7028 
      return
7029 
    iprot.readStructBegin()
7030 
    while True:
7031 
      (fname, ftype, fid) = iprot.readFieldBegin()
7032 
      if ftype == TType.STOP:
7033 
        break
7034 
      if fid == 1:
7035 
        if ftype == TType.BOOL:
7036 
          self.useStatus = iprot.readBool();
7037 
        else:
7038 
          iprot.skip(ftype)
7039 
      elif fid == 2:
7040 
        if ftype == TType.I32:
7041 
          self.itemStatus = iprot.readI32();
7042 
        else:
7043 
          iprot.skip(ftype)
7044 
      else:
7045 
        iprot.skip(ftype)
7046 
      iprot.readFieldEnd()
7047 
    iprot.readStructEnd()
7048 
 
7049 
  def write(self, oprot):
7050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7052 
      return
7053 
    oprot.writeStructBegin('getItemCountByStatus_args')
7054 
    if self.useStatus is not None:
7055 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7056 
      oprot.writeBool(self.useStatus)
7057 
      oprot.writeFieldEnd()
7058 
    if self.itemStatus is not None:
7059 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7060 
      oprot.writeI32(self.itemStatus)
7061 
      oprot.writeFieldEnd()
7062 
    oprot.writeFieldStop()
7063 
    oprot.writeStructEnd()
7064 
 
7065 
  def validate(self):
7066 
    return
7067 
 
7068 
 
7069 
  def __repr__(self):
7070 
    L = ['%s=%r' % (key, value)
7071 
      for key, value in self.__dict__.iteritems()]
7072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7073 
 
7074 
  def __eq__(self, other):
7075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7076 
 
7077 
  def __ne__(self, other):
7078 
    return not (self == other)
7079 
 
7080 
class getItemCountByStatus_result:
7081 
  """
7082 
  Attributes:
7083 
   - success
7084 
  """
7085 
 
7086 
  thrift_spec = (
7087 
    (0, TType.I32, 'success', None, None, ), # 0
7088 
  )
7089 
 
7090 
  def __init__(self, success=None,):
7091 
    self.success = success
7092 
 
7093 
  def read(self, iprot):
7094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7096 
      return
7097 
    iprot.readStructBegin()
7098 
    while True:
7099 
      (fname, ftype, fid) = iprot.readFieldBegin()
7100 
      if ftype == TType.STOP:
7101 
        break
7102 
      if fid == 0:
7103 
        if ftype == TType.I32:
7104 
          self.success = iprot.readI32();
7105 
        else:
7106 
          iprot.skip(ftype)
7107 
      else:
7108 
        iprot.skip(ftype)
7109 
      iprot.readFieldEnd()
7110 
    iprot.readStructEnd()
7111 
 
7112 
  def write(self, oprot):
7113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7115 
      return
7116 
    oprot.writeStructBegin('getItemCountByStatus_result')
7117 
    if self.success is not None:
7118 
      oprot.writeFieldBegin('success', TType.I32, 0)
7119 
      oprot.writeI32(self.success)
7120 
      oprot.writeFieldEnd()
7121 
    oprot.writeFieldStop()
7122 
    oprot.writeStructEnd()
7123 
 
7124 
  def validate(self):
7125 
    return
7126 
 
7127 
 
7128 
  def __repr__(self):
7129 
    L = ['%s=%r' % (key, value)
7130 
      for key, value in self.__dict__.iteritems()]
7131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7132 
 
7133 
  def __eq__(self, other):
7134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7135 
 
7136 
  def __ne__(self, other):
7137 
    return not (self == other)
7138 
 
7139 
class getBestSellers_args:
7140 
 
7141 
  thrift_spec = (
7142 
  )
7143 
 
7144 
  def read(self, iprot):
7145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7147 
      return
7148 
    iprot.readStructBegin()
7149 
    while True:
7150 
      (fname, ftype, fid) = iprot.readFieldBegin()
7151 
      if ftype == TType.STOP:
7152 
        break
7153 
      else:
7154 
        iprot.skip(ftype)
7155 
      iprot.readFieldEnd()
7156 
    iprot.readStructEnd()
7157 
 
7158 
  def write(self, oprot):
7159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7161 
      return
7162 
    oprot.writeStructBegin('getBestSellers_args')
7163 
    oprot.writeFieldStop()
7164 
    oprot.writeStructEnd()
7165 
 
7166 
  def validate(self):
7167 
    return
7168 
 
7169 
 
7170 
  def __repr__(self):
7171 
    L = ['%s=%r' % (key, value)
7172 
      for key, value in self.__dict__.iteritems()]
7173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7174 
 
7175 
  def __eq__(self, other):
7176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7177 
 
7178 
  def __ne__(self, other):
7179 
    return not (self == other)
7180 
 
7181 
class getBestSellers_result:
7182 
  """
7183 
  Attributes:
7184 
   - success
7185 
   - isex
7186 
  """
7187 
 
7188 
  thrift_spec = (
7189 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7190 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7191 
  )
7192 
 
7193 
  def __init__(self, success=None, isex=None,):
7194 
    self.success = success
7195 
    self.isex = isex
7196 
 
7197 
  def read(self, iprot):
7198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7200 
      return
7201 
    iprot.readStructBegin()
7202 
    while True:
7203 
      (fname, ftype, fid) = iprot.readFieldBegin()
7204 
      if ftype == TType.STOP:
7205 
        break
7206 
      if fid == 0:
7207 
        if ftype == TType.LIST:
7208 
          self.success = []
7209 
          (_etype61, _size58) = iprot.readListBegin()
7210 
          for _i62 in xrange(_size58):
7211 
            _elem63 = Item()
7212 
            _elem63.read(iprot)
7213 
            self.success.append(_elem63)
7214 
          iprot.readListEnd()
7215 
        else:
7216 
          iprot.skip(ftype)
7217 
      elif fid == 1:
7218 
        if ftype == TType.STRUCT:
7219 
          self.isex = CatalogServiceException()
7220 
          self.isex.read(iprot)
7221 
        else:
7222 
          iprot.skip(ftype)
7223 
      else:
7224 
        iprot.skip(ftype)
7225 
      iprot.readFieldEnd()
7226 
    iprot.readStructEnd()
7227 
 
7228 
  def write(self, oprot):
7229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7231 
      return
7232 
    oprot.writeStructBegin('getBestSellers_result')
7233 
    if self.success is not None:
7234 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7235 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7236 
      for iter64 in self.success:
7237 
        iter64.write(oprot)
7238 
      oprot.writeListEnd()
7239 
      oprot.writeFieldEnd()
7240 
    if self.isex is not None:
7241 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7242 
      self.isex.write(oprot)
7243 
      oprot.writeFieldEnd()
7244 
    oprot.writeFieldStop()
7245 
    oprot.writeStructEnd()
7246 
 
7247 
  def validate(self):
7248 
    return
7249 
 
7250 
 
7251 
  def __repr__(self):
7252 
    L = ['%s=%r' % (key, value)
7253 
      for key, value in self.__dict__.iteritems()]
7254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7255 
 
7256 
  def __eq__(self, other):
7257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7258 
 
7259 
  def __ne__(self, other):
7260 
    return not (self == other)
7261 
 
7262 
class getBestSellersCatalogIds_args:
7263 
  """
7264 
  Attributes:
7265 
   - beginIndex
7266 
   - totalItems
7267 
   - brand
7268 
   - category
7269 
  """
7270 
 
7271 
  thrift_spec = (
7272 
    None, # 0
7273 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7274 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7275 
    (3, TType.STRING, 'brand', None, None, ), # 3
7276 
    (4, TType.I64, 'category', None, None, ), # 4
7277 
  )
7278 
 
7279 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7280 
    self.beginIndex = beginIndex
7281 
    self.totalItems = totalItems
7282 
    self.brand = brand
7283 
    self.category = category
7284 
 
7285 
  def read(self, iprot):
7286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7288 
      return
7289 
    iprot.readStructBegin()
7290 
    while True:
7291 
      (fname, ftype, fid) = iprot.readFieldBegin()
7292 
      if ftype == TType.STOP:
7293 
        break
7294 
      if fid == 1:
7295 
        if ftype == TType.I64:
7296 
          self.beginIndex = iprot.readI64();
7297 
        else:
7298 
          iprot.skip(ftype)
7299 
      elif fid == 2:
7300 
        if ftype == TType.I64:
7301 
          self.totalItems = iprot.readI64();
7302 
        else:
7303 
          iprot.skip(ftype)
7304 
      elif fid == 3:
7305 
        if ftype == TType.STRING:
7306 
          self.brand = iprot.readString();
7307 
        else:
7308 
          iprot.skip(ftype)
7309 
      elif fid == 4:
7310 
        if ftype == TType.I64:
7311 
          self.category = iprot.readI64();
7312 
        else:
7313 
          iprot.skip(ftype)
7314 
      else:
7315 
        iprot.skip(ftype)
7316 
      iprot.readFieldEnd()
7317 
    iprot.readStructEnd()
7318 
 
7319 
  def write(self, oprot):
7320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7322 
      return
7323 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7324 
    if self.beginIndex is not None:
7325 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7326 
      oprot.writeI64(self.beginIndex)
7327 
      oprot.writeFieldEnd()
7328 
    if self.totalItems is not None:
7329 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7330 
      oprot.writeI64(self.totalItems)
7331 
      oprot.writeFieldEnd()
7332 
    if self.brand is not None:
7333 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7334 
      oprot.writeString(self.brand)
7335 
      oprot.writeFieldEnd()
7336 
    if self.category is not None:
7337 
      oprot.writeFieldBegin('category', TType.I64, 4)
7338 
      oprot.writeI64(self.category)
7339 
      oprot.writeFieldEnd()
7340 
    oprot.writeFieldStop()
7341 
    oprot.writeStructEnd()
7342 
 
7343 
  def validate(self):
7344 
    return
7345 
 
7346 
 
7347 
  def __repr__(self):
7348 
    L = ['%s=%r' % (key, value)
7349 
      for key, value in self.__dict__.iteritems()]
7350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7351 
 
7352 
  def __eq__(self, other):
7353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7354 
 
7355 
  def __ne__(self, other):
7356 
    return not (self == other)
7357 
 
7358 
class getBestSellersCatalogIds_result:
7359 
  """
7360 
  Attributes:
7361 
   - success
7362 
   - cex
7363 
  """
7364 
 
7365 
  thrift_spec = (
7366 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7367 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7368 
  )
7369 
 
7370 
  def __init__(self, success=None, cex=None,):
7371 
    self.success = success
7372 
    self.cex = cex
7373 
 
7374 
  def read(self, iprot):
7375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7377 
      return
7378 
    iprot.readStructBegin()
7379 
    while True:
7380 
      (fname, ftype, fid) = iprot.readFieldBegin()
7381 
      if ftype == TType.STOP:
7382 
        break
7383 
      if fid == 0:
7384 
        if ftype == TType.LIST:
7385 
          self.success = []
7386 
          (_etype68, _size65) = iprot.readListBegin()
7387 
          for _i69 in xrange(_size65):
7388 
            _elem70 = iprot.readI64();
7389 
            self.success.append(_elem70)
7390 
          iprot.readListEnd()
7391 
        else:
7392 
          iprot.skip(ftype)
7393 
      elif fid == 1:
7394 
        if ftype == TType.STRUCT:
7395 
          self.cex = CatalogServiceException()
7396 
          self.cex.read(iprot)
7397 
        else:
7398 
          iprot.skip(ftype)
7399 
      else:
7400 
        iprot.skip(ftype)
7401 
      iprot.readFieldEnd()
7402 
    iprot.readStructEnd()
7403 
 
7404 
  def write(self, oprot):
7405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7407 
      return
7408 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7409 
    if self.success is not None:
7410 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7411 
      oprot.writeListBegin(TType.I64, len(self.success))
7412 
      for iter71 in self.success:
7413 
        oprot.writeI64(iter71)
7414 
      oprot.writeListEnd()
7415 
      oprot.writeFieldEnd()
7416 
    if self.cex is not None:
7417 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7418 
      self.cex.write(oprot)
7419 
      oprot.writeFieldEnd()
7420 
    oprot.writeFieldStop()
7421 
    oprot.writeStructEnd()
7422 
 
7423 
  def validate(self):
7424 
    return
7425 
 
7426 
 
7427 
  def __repr__(self):
7428 
    L = ['%s=%r' % (key, value)
7429 
      for key, value in self.__dict__.iteritems()]
7430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7431 
 
7432 
  def __eq__(self, other):
7433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7434 
 
7435 
  def __ne__(self, other):
7436 
    return not (self == other)
7437 
 
7438 
class getBestSellersCount_args:
7439 
 
7440 
  thrift_spec = (
7441 
  )
7442 
 
7443 
  def read(self, iprot):
7444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7446 
      return
7447 
    iprot.readStructBegin()
7448 
    while True:
7449 
      (fname, ftype, fid) = iprot.readFieldBegin()
7450 
      if ftype == TType.STOP:
7451 
        break
7452 
      else:
7453 
        iprot.skip(ftype)
7454 
      iprot.readFieldEnd()
7455 
    iprot.readStructEnd()
7456 
 
7457 
  def write(self, oprot):
7458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7460 
      return
7461 
    oprot.writeStructBegin('getBestSellersCount_args')
7462 
    oprot.writeFieldStop()
7463 
    oprot.writeStructEnd()
7464 
 
7465 
  def validate(self):
7466 
    return
7467 
 
7468 
 
7469 
  def __repr__(self):
7470 
    L = ['%s=%r' % (key, value)
7471 
      for key, value in self.__dict__.iteritems()]
7472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7473 
 
7474 
  def __eq__(self, other):
7475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7476 
 
7477 
  def __ne__(self, other):
7478 
    return not (self == other)
7479 
 
7480 
class getBestSellersCount_result:
7481 
  """
7482 
  Attributes:
7483 
   - success
7484 
   - cex
7485 
  """
7486 
 
7487 
  thrift_spec = (
7488 
    (0, TType.I64, 'success', None, None, ), # 0
7489 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7490 
  )
7491 
 
7492 
  def __init__(self, success=None, cex=None,):
7493 
    self.success = success
7494 
    self.cex = cex
7495 
 
7496 
  def read(self, iprot):
7497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7499 
      return
7500 
    iprot.readStructBegin()
7501 
    while True:
7502 
      (fname, ftype, fid) = iprot.readFieldBegin()
7503 
      if ftype == TType.STOP:
7504 
        break
7505 
      if fid == 0:
7506 
        if ftype == TType.I64:
7507 
          self.success = iprot.readI64();
7508 
        else:
7509 
          iprot.skip(ftype)
7510 
      elif fid == 1:
7511 
        if ftype == TType.STRUCT:
7512 
          self.cex = CatalogServiceException()
7513 
          self.cex.read(iprot)
7514 
        else:
7515 
          iprot.skip(ftype)
7516 
      else:
7517 
        iprot.skip(ftype)
7518 
      iprot.readFieldEnd()
7519 
    iprot.readStructEnd()
7520 
 
7521 
  def write(self, oprot):
7522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7524 
      return
7525 
    oprot.writeStructBegin('getBestSellersCount_result')
7526 
    if self.success is not None:
7527 
      oprot.writeFieldBegin('success', TType.I64, 0)
7528 
      oprot.writeI64(self.success)
7529 
      oprot.writeFieldEnd()
7530 
    if self.cex is not None:
7531 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7532 
      self.cex.write(oprot)
7533 
      oprot.writeFieldEnd()
7534 
    oprot.writeFieldStop()
7535 
    oprot.writeStructEnd()
7536 
 
7537 
  def validate(self):
7538 
    return
7539 
 
7540 
 
7541 
  def __repr__(self):
7542 
    L = ['%s=%r' % (key, value)
7543 
      for key, value in self.__dict__.iteritems()]
7544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7545 
 
7546 
  def __eq__(self, other):
7547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7548 
 
7549 
  def __ne__(self, other):
7550 
    return not (self == other)
7551 
 
7552 
class getBestDeals_args:
7553 
 
7554 
  thrift_spec = (
7555 
  )
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 
      else:
7567 
        iprot.skip(ftype)
7568 
      iprot.readFieldEnd()
7569 
    iprot.readStructEnd()
7570 
 
7571 
  def write(self, oprot):
7572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7574 
      return
7575 
    oprot.writeStructBegin('getBestDeals_args')
7576 
    oprot.writeFieldStop()
7577 
    oprot.writeStructEnd()
7578 
 
7579 
  def validate(self):
7580 
    return
7581 
 
7582 
 
7583 
  def __repr__(self):
7584 
    L = ['%s=%r' % (key, value)
7585 
      for key, value in self.__dict__.iteritems()]
7586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7587 
 
7588 
  def __eq__(self, other):
7589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7590 
 
7591 
  def __ne__(self, other):
7592 
    return not (self == other)
7593 
 
7594 
class getBestDeals_result:
7595 
  """
7596 
  Attributes:
7597 
   - success
7598 
   - isex
7599 
  """
7600 
 
7601 
  thrift_spec = (
7602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7603 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7604 
  )
7605 
 
7606 
  def __init__(self, success=None, isex=None,):
7607 
    self.success = success
7608 
    self.isex = isex
7609 
 
7610 
  def read(self, iprot):
7611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7613 
      return
7614 
    iprot.readStructBegin()
7615 
    while True:
7616 
      (fname, ftype, fid) = iprot.readFieldBegin()
7617 
      if ftype == TType.STOP:
7618 
        break
7619 
      if fid == 0:
7620 
        if ftype == TType.LIST:
7621 
          self.success = []
7622 
          (_etype75, _size72) = iprot.readListBegin()
7623 
          for _i76 in xrange(_size72):
7624 
            _elem77 = Item()
7625 
            _elem77.read(iprot)
7626 
            self.success.append(_elem77)
7627 
          iprot.readListEnd()
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      elif fid == 1:
7631 
        if ftype == TType.STRUCT:
7632 
          self.isex = CatalogServiceException()
7633 
          self.isex.read(iprot)
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      else:
7637 
        iprot.skip(ftype)
7638 
      iprot.readFieldEnd()
7639 
    iprot.readStructEnd()
7640 
 
7641 
  def write(self, oprot):
7642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7644 
      return
7645 
    oprot.writeStructBegin('getBestDeals_result')
7646 
    if self.success is not None:
7647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7649 
      for iter78 in self.success:
7650 
        iter78.write(oprot)
7651 
      oprot.writeListEnd()
7652 
      oprot.writeFieldEnd()
7653 
    if self.isex is not None:
7654 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7655 
      self.isex.write(oprot)
7656 
      oprot.writeFieldEnd()
7657 
    oprot.writeFieldStop()
7658 
    oprot.writeStructEnd()
7659 
 
7660 
  def validate(self):
7661 
    return
7662 
 
7663 
 
7664 
  def __repr__(self):
7665 
    L = ['%s=%r' % (key, value)
7666 
      for key, value in self.__dict__.iteritems()]
7667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7668 
 
7669 
  def __eq__(self, other):
7670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7671 
 
7672 
  def __ne__(self, other):
7673 
    return not (self == other)
7674 
 
7675 
class getBestDealsCatalogIds_args:
7676 
  """
7677 
  Attributes:
7678 
   - beginIndex
7679 
   - totalItems
7680 
   - brand
7681 
   - category
7682 
  """
7683 
 
7684 
  thrift_spec = (
7685 
    None, # 0
7686 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7687 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7688 
    (3, TType.STRING, 'brand', None, None, ), # 3
7689 
    (4, TType.I64, 'category', None, None, ), # 4
7690 
  )
7691 
 
7692 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7693 
    self.beginIndex = beginIndex
7694 
    self.totalItems = totalItems
7695 
    self.brand = brand
7696 
    self.category = category
7697 
 
7698 
  def read(self, iprot):
7699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7701 
      return
7702 
    iprot.readStructBegin()
7703 
    while True:
7704 
      (fname, ftype, fid) = iprot.readFieldBegin()
7705 
      if ftype == TType.STOP:
7706 
        break
7707 
      if fid == 1:
7708 
        if ftype == TType.I64:
7709 
          self.beginIndex = iprot.readI64();
7710 
        else:
7711 
          iprot.skip(ftype)
7712 
      elif fid == 2:
7713 
        if ftype == TType.I64:
7714 
          self.totalItems = iprot.readI64();
7715 
        else:
7716 
          iprot.skip(ftype)
7717 
      elif fid == 3:
7718 
        if ftype == TType.STRING:
7719 
          self.brand = iprot.readString();
7720 
        else:
7721 
          iprot.skip(ftype)
7722 
      elif fid == 4:
7723 
        if ftype == TType.I64:
7724 
          self.category = iprot.readI64();
7725 
        else:
7726 
          iprot.skip(ftype)
7727 
      else:
7728 
        iprot.skip(ftype)
7729 
      iprot.readFieldEnd()
7730 
    iprot.readStructEnd()
7731 
 
7732 
  def write(self, oprot):
7733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7735 
      return
7736 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7737 
    if self.beginIndex is not None:
7738 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7739 
      oprot.writeI64(self.beginIndex)
7740 
      oprot.writeFieldEnd()
7741 
    if self.totalItems is not None:
7742 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7743 
      oprot.writeI64(self.totalItems)
7744 
      oprot.writeFieldEnd()
7745 
    if self.brand is not None:
7746 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7747 
      oprot.writeString(self.brand)
7748 
      oprot.writeFieldEnd()
7749 
    if self.category is not None:
7750 
      oprot.writeFieldBegin('category', TType.I64, 4)
7751 
      oprot.writeI64(self.category)
7752 
      oprot.writeFieldEnd()
7753 
    oprot.writeFieldStop()
7754 
    oprot.writeStructEnd()
7755 
 
7756 
  def validate(self):
7757 
    return
7758 
 
7759 
 
7760 
  def __repr__(self):
7761 
    L = ['%s=%r' % (key, value)
7762 
      for key, value in self.__dict__.iteritems()]
7763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7764 
 
7765 
  def __eq__(self, other):
7766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7767 
 
7768 
  def __ne__(self, other):
7769 
    return not (self == other)
7770 
 
7771 
class getBestDealsCatalogIds_result:
7772 
  """
7773 
  Attributes:
7774 
   - success
7775 
   - cex
7776 
  """
7777 
 
7778 
  thrift_spec = (
7779 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7780 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7781 
  )
7782 
 
7783 
  def __init__(self, success=None, cex=None,):
7784 
    self.success = success
7785 
    self.cex = cex
7786 
 
7787 
  def read(self, iprot):
7788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7790 
      return
7791 
    iprot.readStructBegin()
7792 
    while True:
7793 
      (fname, ftype, fid) = iprot.readFieldBegin()
7794 
      if ftype == TType.STOP:
7795 
        break
7796 
      if fid == 0:
7797 
        if ftype == TType.LIST:
7798 
          self.success = []
7799 
          (_etype82, _size79) = iprot.readListBegin()
7800 
          for _i83 in xrange(_size79):
7801 
            _elem84 = iprot.readI64();
7802 
            self.success.append(_elem84)
7803 
          iprot.readListEnd()
7804 
        else:
7805 
          iprot.skip(ftype)
7806 
      elif fid == 1:
7807 
        if ftype == TType.STRUCT:
7808 
          self.cex = CatalogServiceException()
7809 
          self.cex.read(iprot)
7810 
        else:
7811 
          iprot.skip(ftype)
7812 
      else:
7813 
        iprot.skip(ftype)
7814 
      iprot.readFieldEnd()
7815 
    iprot.readStructEnd()
7816 
 
7817 
  def write(self, oprot):
7818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7820 
      return
7821 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
7822 
    if self.success is not None:
7823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7824 
      oprot.writeListBegin(TType.I64, len(self.success))
7825 
      for iter85 in self.success:
7826 
        oprot.writeI64(iter85)
7827 
      oprot.writeListEnd()
7828 
      oprot.writeFieldEnd()
7829 
    if self.cex is not None:
7830 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7831 
      self.cex.write(oprot)
7832 
      oprot.writeFieldEnd()
7833 
    oprot.writeFieldStop()
7834 
    oprot.writeStructEnd()
7835 
 
7836 
  def validate(self):
7837 
    return
7838 
 
7839 
 
7840 
  def __repr__(self):
7841 
    L = ['%s=%r' % (key, value)
7842 
      for key, value in self.__dict__.iteritems()]
7843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7844 
 
7845 
  def __eq__(self, other):
7846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7847 
 
7848 
  def __ne__(self, other):
7849 
    return not (self == other)
7850 
 
7851 
class getBestDealsCount_args:
7852 
 
7853 
  thrift_spec = (
7854 
  )
7855 
 
7856 
  def read(self, iprot):
7857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7859 
      return
7860 
    iprot.readStructBegin()
7861 
    while True:
7862 
      (fname, ftype, fid) = iprot.readFieldBegin()
7863 
      if ftype == TType.STOP:
7864 
        break
7865 
      else:
7866 
        iprot.skip(ftype)
7867 
      iprot.readFieldEnd()
7868 
    iprot.readStructEnd()
7869 
 
7870 
  def write(self, oprot):
7871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7873 
      return
7874 
    oprot.writeStructBegin('getBestDealsCount_args')
7875 
    oprot.writeFieldStop()
7876 
    oprot.writeStructEnd()
7877 
 
7878 
  def validate(self):
7879 
    return
7880 
 
7881 
 
7882 
  def __repr__(self):
7883 
    L = ['%s=%r' % (key, value)
7884 
      for key, value in self.__dict__.iteritems()]
7885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7886 
 
7887 
  def __eq__(self, other):
7888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7889 
 
7890 
  def __ne__(self, other):
7891 
    return not (self == other)
7892 
 
7893 
class getBestDealsCount_result:
7894 
  """
7895 
  Attributes:
7896 
   - success
7897 
   - cex
7898 
  """
7899 
 
7900 
  thrift_spec = (
7901 
    (0, TType.I64, 'success', None, None, ), # 0
7902 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7903 
  )
7904 
 
7905 
  def __init__(self, success=None, cex=None,):
7906 
    self.success = success
7907 
    self.cex = cex
7908 
 
7909 
  def read(self, iprot):
7910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7912 
      return
7913 
    iprot.readStructBegin()
7914 
    while True:
7915 
      (fname, ftype, fid) = iprot.readFieldBegin()
7916 
      if ftype == TType.STOP:
7917 
        break
7918 
      if fid == 0:
7919 
        if ftype == TType.I64:
7920 
          self.success = iprot.readI64();
7921 
        else:
7922 
          iprot.skip(ftype)
7923 
      elif fid == 1:
7924 
        if ftype == TType.STRUCT:
7925 
          self.cex = CatalogServiceException()
7926 
          self.cex.read(iprot)
7927 
        else:
7928 
          iprot.skip(ftype)
7929 
      else:
7930 
        iprot.skip(ftype)
7931 
      iprot.readFieldEnd()
7932 
    iprot.readStructEnd()
7933 
 
7934 
  def write(self, oprot):
7935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7937 
      return
7938 
    oprot.writeStructBegin('getBestDealsCount_result')
7939 
    if self.success is not None:
7940 
      oprot.writeFieldBegin('success', TType.I64, 0)
7941 
      oprot.writeI64(self.success)
7942 
      oprot.writeFieldEnd()
7943 
    if self.cex is not None:
7944 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7945 
      self.cex.write(oprot)
7946 
      oprot.writeFieldEnd()
7947 
    oprot.writeFieldStop()
7948 
    oprot.writeStructEnd()
7949 
 
7950 
  def validate(self):
7951 
    return
7952 
 
7953 
 
7954 
  def __repr__(self):
7955 
    L = ['%s=%r' % (key, value)
7956 
      for key, value in self.__dict__.iteritems()]
7957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7958 
 
7959 
  def __eq__(self, other):
7960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7961 
 
7962 
  def __ne__(self, other):
7963 
    return not (self == other)
7964 
 
7965 
class getComingSoon_args:
7966 
 
7967 
  thrift_spec = (
7968 
  )
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 
      else:
7980 
        iprot.skip(ftype)
7981 
      iprot.readFieldEnd()
7982 
    iprot.readStructEnd()
7983 
 
7984 
  def write(self, oprot):
7985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7987 
      return
7988 
    oprot.writeStructBegin('getComingSoon_args')
7989 
    oprot.writeFieldStop()
7990 
    oprot.writeStructEnd()
7991 
 
7992 
  def validate(self):
7993 
    return
7994 
 
7995 
 
7996 
  def __repr__(self):
7997 
    L = ['%s=%r' % (key, value)
7998 
      for key, value in self.__dict__.iteritems()]
7999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8000 
 
8001 
  def __eq__(self, other):
8002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8003 
 
8004 
  def __ne__(self, other):
8005 
    return not (self == other)
8006 
 
8007 
class getComingSoon_result:
8008 
  """
8009 
  Attributes:
8010 
   - success
8011 
   - isex
8012 
  """
8013 
 
8014 
  thrift_spec = (
8015 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8016 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8017 
  )
8018 
 
8019 
  def __init__(self, success=None, isex=None,):
8020 
    self.success = success
8021 
    self.isex = isex
8022 
 
8023 
  def read(self, iprot):
8024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8026 
      return
8027 
    iprot.readStructBegin()
8028 
    while True:
8029 
      (fname, ftype, fid) = iprot.readFieldBegin()
8030 
      if ftype == TType.STOP:
8031 
        break
8032 
      if fid == 0:
8033 
        if ftype == TType.LIST:
8034 
          self.success = []
8035 
          (_etype89, _size86) = iprot.readListBegin()
8036 
          for _i90 in xrange(_size86):
8037 
            _elem91 = Item()
8038 
            _elem91.read(iprot)
8039 
            self.success.append(_elem91)
8040 
          iprot.readListEnd()
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      elif fid == 1:
8044 
        if ftype == TType.STRUCT:
8045 
          self.isex = CatalogServiceException()
8046 
          self.isex.read(iprot)
8047 
        else:
8048 
          iprot.skip(ftype)
8049 
      else:
8050 
        iprot.skip(ftype)
8051 
      iprot.readFieldEnd()
8052 
    iprot.readStructEnd()
8053 
 
8054 
  def write(self, oprot):
8055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8057 
      return
8058 
    oprot.writeStructBegin('getComingSoon_result')
8059 
    if self.success is not None:
8060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8061 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8062 
      for iter92 in self.success:
8063 
        iter92.write(oprot)
8064 
      oprot.writeListEnd()
8065 
      oprot.writeFieldEnd()
8066 
    if self.isex is not None:
8067 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8068 
      self.isex.write(oprot)
8069 
      oprot.writeFieldEnd()
8070 
    oprot.writeFieldStop()
8071 
    oprot.writeStructEnd()
8072 
 
8073 
  def validate(self):
8074 
    return
8075 
 
8076 
 
8077 
  def __repr__(self):
8078 
    L = ['%s=%r' % (key, value)
8079 
      for key, value in self.__dict__.iteritems()]
8080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8081 
 
8082 
  def __eq__(self, other):
8083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8084 
 
8085 
  def __ne__(self, other):
8086 
    return not (self == other)
8087 
 
8088 
class getComingSoonCatalogIds_args:
8089 
  """
8090 
  Attributes:
8091 
   - beginIndex
8092 
   - totalItems
8093 
   - brand
8094 
   - category
8095 
  """
8096 
 
8097 
  thrift_spec = (
8098 
    None, # 0
8099 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8100 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8101 
    (3, TType.STRING, 'brand', None, None, ), # 3
8102 
    (4, TType.I64, 'category', None, None, ), # 4
8103 
  )
8104 
 
8105 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8106 
    self.beginIndex = beginIndex
8107 
    self.totalItems = totalItems
8108 
    self.brand = brand
8109 
    self.category = category
8110 
 
8111 
  def read(self, iprot):
8112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8114 
      return
8115 
    iprot.readStructBegin()
8116 
    while True:
8117 
      (fname, ftype, fid) = iprot.readFieldBegin()
8118 
      if ftype == TType.STOP:
8119 
        break
8120 
      if fid == 1:
8121 
        if ftype == TType.I64:
8122 
          self.beginIndex = iprot.readI64();
8123 
        else:
8124 
          iprot.skip(ftype)
8125 
      elif fid == 2:
8126 
        if ftype == TType.I64:
8127 
          self.totalItems = iprot.readI64();
8128 
        else:
8129 
          iprot.skip(ftype)
8130 
      elif fid == 3:
8131 
        if ftype == TType.STRING:
8132 
          self.brand = iprot.readString();
8133 
        else:
8134 
          iprot.skip(ftype)
8135 
      elif fid == 4:
8136 
        if ftype == TType.I64:
8137 
          self.category = iprot.readI64();
8138 
        else:
8139 
          iprot.skip(ftype)
8140 
      else:
8141 
        iprot.skip(ftype)
8142 
      iprot.readFieldEnd()
8143 
    iprot.readStructEnd()
8144 
 
8145 
  def write(self, oprot):
8146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8148 
      return
8149 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8150 
    if self.beginIndex is not None:
8151 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8152 
      oprot.writeI64(self.beginIndex)
8153 
      oprot.writeFieldEnd()
8154 
    if self.totalItems is not None:
8155 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8156 
      oprot.writeI64(self.totalItems)
8157 
      oprot.writeFieldEnd()
8158 
    if self.brand is not None:
8159 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8160 
      oprot.writeString(self.brand)
8161 
      oprot.writeFieldEnd()
8162 
    if self.category is not None:
8163 
      oprot.writeFieldBegin('category', TType.I64, 4)
8164 
      oprot.writeI64(self.category)
8165 
      oprot.writeFieldEnd()
8166 
    oprot.writeFieldStop()
8167 
    oprot.writeStructEnd()
8168 
 
8169 
  def validate(self):
8170 
    return
8171 
 
8172 
 
8173 
  def __repr__(self):
8174 
    L = ['%s=%r' % (key, value)
8175 
      for key, value in self.__dict__.iteritems()]
8176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8177 
 
8178 
  def __eq__(self, other):
8179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8180 
 
8181 
  def __ne__(self, other):
8182 
    return not (self == other)
8183 
 
8184 
class getComingSoonCatalogIds_result:
8185 
  """
8186 
  Attributes:
8187 
   - success
8188 
   - cex
8189 
  """
8190 
 
8191 
  thrift_spec = (
8192 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8193 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8194 
  )
8195 
 
8196 
  def __init__(self, success=None, cex=None,):
8197 
    self.success = success
8198 
    self.cex = cex
8199 
 
8200 
  def read(self, iprot):
8201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8203 
      return
8204 
    iprot.readStructBegin()
8205 
    while True:
8206 
      (fname, ftype, fid) = iprot.readFieldBegin()
8207 
      if ftype == TType.STOP:
8208 
        break
8209 
      if fid == 0:
8210 
        if ftype == TType.LIST:
8211 
          self.success = []
8212 
          (_etype96, _size93) = iprot.readListBegin()
8213 
          for _i97 in xrange(_size93):
8214 
            _elem98 = iprot.readI64();
8215 
            self.success.append(_elem98)
8216 
          iprot.readListEnd()
8217 
        else:
8218 
          iprot.skip(ftype)
8219 
      elif fid == 1:
8220 
        if ftype == TType.STRUCT:
8221 
          self.cex = CatalogServiceException()
8222 
          self.cex.read(iprot)
8223 
        else:
8224 
          iprot.skip(ftype)
8225 
      else:
8226 
        iprot.skip(ftype)
8227 
      iprot.readFieldEnd()
8228 
    iprot.readStructEnd()
8229 
 
8230 
  def write(self, oprot):
8231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8233 
      return
8234 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8235 
    if self.success is not None:
8236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8237 
      oprot.writeListBegin(TType.I64, len(self.success))
8238 
      for iter99 in self.success:
8239 
        oprot.writeI64(iter99)
8240 
      oprot.writeListEnd()
8241 
      oprot.writeFieldEnd()
8242 
    if self.cex is not None:
8243 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8244 
      self.cex.write(oprot)
8245 
      oprot.writeFieldEnd()
8246 
    oprot.writeFieldStop()
8247 
    oprot.writeStructEnd()
8248 
 
8249 
  def validate(self):
8250 
    return
8251 
 
8252 
 
8253 
  def __repr__(self):
8254 
    L = ['%s=%r' % (key, value)
8255 
      for key, value in self.__dict__.iteritems()]
8256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8257 
 
8258 
  def __eq__(self, other):
8259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8260 
 
8261 
  def __ne__(self, other):
8262 
    return not (self == other)
8263 
 
8264 
class getComingSoonCount_args:
8265 
 
8266 
  thrift_spec = (
8267 
  )
8268 
 
8269 
  def read(self, iprot):
8270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8272 
      return
8273 
    iprot.readStructBegin()
8274 
    while True:
8275 
      (fname, ftype, fid) = iprot.readFieldBegin()
8276 
      if ftype == TType.STOP:
8277 
        break
8278 
      else:
8279 
        iprot.skip(ftype)
8280 
      iprot.readFieldEnd()
8281 
    iprot.readStructEnd()
8282 
 
8283 
  def write(self, oprot):
8284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8286 
      return
8287 
    oprot.writeStructBegin('getComingSoonCount_args')
8288 
    oprot.writeFieldStop()
8289 
    oprot.writeStructEnd()
8290 
 
8291 
  def validate(self):
8292 
    return
8293 
 
8294 
 
8295 
  def __repr__(self):
8296 
    L = ['%s=%r' % (key, value)
8297 
      for key, value in self.__dict__.iteritems()]
8298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8299 
 
8300 
  def __eq__(self, other):
8301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8302 
 
8303 
  def __ne__(self, other):
8304 
    return not (self == other)
8305 
 
8306 
class getComingSoonCount_result:
8307 
  """
8308 
  Attributes:
8309 
   - success
8310 
   - cex
8311 
  """
8312 
 
8313 
  thrift_spec = (
8314 
    (0, TType.I64, 'success', None, None, ), # 0
8315 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8316 
  )
8317 
 
8318 
  def __init__(self, success=None, cex=None,):
8319 
    self.success = success
8320 
    self.cex = cex
8321 
 
8322 
  def read(self, iprot):
8323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8325 
      return
8326 
    iprot.readStructBegin()
8327 
    while True:
8328 
      (fname, ftype, fid) = iprot.readFieldBegin()
8329 
      if ftype == TType.STOP:
8330 
        break
8331 
      if fid == 0:
8332 
        if ftype == TType.I64:
8333 
          self.success = iprot.readI64();
8334 
        else:
8335 
          iprot.skip(ftype)
8336 
      elif fid == 1:
8337 
        if ftype == TType.STRUCT:
8338 
          self.cex = CatalogServiceException()
8339 
          self.cex.read(iprot)
8340 
        else:
8341 
          iprot.skip(ftype)
8342 
      else:
8343 
        iprot.skip(ftype)
8344 
      iprot.readFieldEnd()
8345 
    iprot.readStructEnd()
8346 
 
8347 
  def write(self, oprot):
8348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8350 
      return
8351 
    oprot.writeStructBegin('getComingSoonCount_result')
8352 
    if self.success is not None:
8353 
      oprot.writeFieldBegin('success', TType.I64, 0)
8354 
      oprot.writeI64(self.success)
8355 
      oprot.writeFieldEnd()
8356 
    if self.cex is not None:
8357 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8358 
      self.cex.write(oprot)
8359 
      oprot.writeFieldEnd()
8360 
    oprot.writeFieldStop()
8361 
    oprot.writeStructEnd()
8362 
 
8363 
  def validate(self):
8364 
    return
8365 
 
8366 
 
8367 
  def __repr__(self):
8368 
    L = ['%s=%r' % (key, value)
8369 
      for key, value in self.__dict__.iteritems()]
8370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8371 
 
8372 
  def __eq__(self, other):
8373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8374 
 
8375 
  def __ne__(self, other):
8376 
    return not (self == other)
8377 
 
8378 
class getLatestArrivals_args:
8379 
 
8380 
  thrift_spec = (
8381 
  )
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 
      else:
8393 
        iprot.skip(ftype)
8394 
      iprot.readFieldEnd()
8395 
    iprot.readStructEnd()
8396 
 
8397 
  def write(self, oprot):
8398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8400 
      return
8401 
    oprot.writeStructBegin('getLatestArrivals_args')
8402 
    oprot.writeFieldStop()
8403 
    oprot.writeStructEnd()
8404 
 
8405 
  def validate(self):
8406 
    return
8407 
 
8408 
 
8409 
  def __repr__(self):
8410 
    L = ['%s=%r' % (key, value)
8411 
      for key, value in self.__dict__.iteritems()]
8412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8413 
 
8414 
  def __eq__(self, other):
8415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8416 
 
8417 
  def __ne__(self, other):
8418 
    return not (self == other)
8419 
 
8420 
class getLatestArrivals_result:
8421 
  """
8422 
  Attributes:
8423 
   - success
8424 
   - isex
8425 
  """
8426 
 
8427 
  thrift_spec = (
8428 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8429 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8430 
  )
8431 
 
8432 
  def __init__(self, success=None, isex=None,):
8433 
    self.success = success
8434 
    self.isex = isex
8435 
 
8436 
  def read(self, iprot):
8437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8439 
      return
8440 
    iprot.readStructBegin()
8441 
    while True:
8442 
      (fname, ftype, fid) = iprot.readFieldBegin()
8443 
      if ftype == TType.STOP:
8444 
        break
8445 
      if fid == 0:
8446 
        if ftype == TType.LIST:
8447 
          self.success = []
8448 
          (_etype103, _size100) = iprot.readListBegin()
8449 
          for _i104 in xrange(_size100):
8450 
            _elem105 = Item()
8451 
            _elem105.read(iprot)
8452 
            self.success.append(_elem105)
8453 
          iprot.readListEnd()
8454 
        else:
8455 
          iprot.skip(ftype)
8456 
      elif fid == 1:
8457 
        if ftype == TType.STRUCT:
8458 
          self.isex = CatalogServiceException()
8459 
          self.isex.read(iprot)
8460 
        else:
8461 
          iprot.skip(ftype)
8462 
      else:
8463 
        iprot.skip(ftype)
8464 
      iprot.readFieldEnd()
8465 
    iprot.readStructEnd()
8466 
 
8467 
  def write(self, oprot):
8468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8470 
      return
8471 
    oprot.writeStructBegin('getLatestArrivals_result')
8472 
    if self.success is not None:
8473 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8474 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8475 
      for iter106 in self.success:
8476 
        iter106.write(oprot)
8477 
      oprot.writeListEnd()
8478 
      oprot.writeFieldEnd()
8479 
    if self.isex is not None:
8480 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8481 
      self.isex.write(oprot)
8482 
      oprot.writeFieldEnd()
8483 
    oprot.writeFieldStop()
8484 
    oprot.writeStructEnd()
8485 
 
8486 
  def validate(self):
8487 
    return
8488 
 
8489 
 
8490 
  def __repr__(self):
8491 
    L = ['%s=%r' % (key, value)
8492 
      for key, value in self.__dict__.iteritems()]
8493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8494 
 
8495 
  def __eq__(self, other):
8496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8497 
 
8498 
  def __ne__(self, other):
8499 
    return not (self == other)
8500 
 
8501 
class getLatestArrivalsCatalogIds_args:
8502 
  """
8503 
  Attributes:
8504 
   - beginIndex
8505 
   - totalItems
8506 
   - brand
8507 
   - categories
8508 
  """
8509 
 
8510 
  thrift_spec = (
8511 
    None, # 0
8512 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8513 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8514 
    (3, TType.STRING, 'brand', None, None, ), # 3
8515 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8516 
  )
8517 
 
8518 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8519 
    self.beginIndex = beginIndex
8520 
    self.totalItems = totalItems
8521 
    self.brand = brand
8522 
    self.categories = categories
8523 
 
8524 
  def read(self, iprot):
8525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8527 
      return
8528 
    iprot.readStructBegin()
8529 
    while True:
8530 
      (fname, ftype, fid) = iprot.readFieldBegin()
8531 
      if ftype == TType.STOP:
8532 
        break
8533 
      if fid == 1:
8534 
        if ftype == TType.I64:
8535 
          self.beginIndex = iprot.readI64();
8536 
        else:
8537 
          iprot.skip(ftype)
8538 
      elif fid == 2:
8539 
        if ftype == TType.I64:
8540 
          self.totalItems = iprot.readI64();
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      elif fid == 3:
8544 
        if ftype == TType.STRING:
8545 
          self.brand = iprot.readString();
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      elif fid == 4:
8549 
        if ftype == TType.LIST:
8550 
          self.categories = []
8551 
          (_etype110, _size107) = iprot.readListBegin()
8552 
          for _i111 in xrange(_size107):
8553 
            _elem112 = iprot.readI64();
8554 
            self.categories.append(_elem112)
8555 
          iprot.readListEnd()
8556 
        else:
8557 
          iprot.skip(ftype)
8558 
      else:
8559 
        iprot.skip(ftype)
8560 
      iprot.readFieldEnd()
8561 
    iprot.readStructEnd()
8562 
 
8563 
  def write(self, oprot):
8564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8566 
      return
8567 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8568 
    if self.beginIndex is not None:
8569 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8570 
      oprot.writeI64(self.beginIndex)
8571 
      oprot.writeFieldEnd()
8572 
    if self.totalItems is not None:
8573 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8574 
      oprot.writeI64(self.totalItems)
8575 
      oprot.writeFieldEnd()
8576 
    if self.brand is not None:
8577 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8578 
      oprot.writeString(self.brand)
8579 
      oprot.writeFieldEnd()
8580 
    if self.categories is not None:
8581 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8582 
      oprot.writeListBegin(TType.I64, len(self.categories))
8583 
      for iter113 in self.categories:
8584 
        oprot.writeI64(iter113)
8585 
      oprot.writeListEnd()
8586 
      oprot.writeFieldEnd()
8587 
    oprot.writeFieldStop()
8588 
    oprot.writeStructEnd()
8589 
 
8590 
  def validate(self):
8591 
    return
8592 
 
8593 
 
8594 
  def __repr__(self):
8595 
    L = ['%s=%r' % (key, value)
8596 
      for key, value in self.__dict__.iteritems()]
8597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8598 
 
8599 
  def __eq__(self, other):
8600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8601 
 
8602 
  def __ne__(self, other):
8603 
    return not (self == other)
8604 
 
8605 
class getLatestArrivalsCatalogIds_result:
8606 
  """
8607 
  Attributes:
8608 
   - success
8609 
   - cex
8610 
  """
8611 
 
8612 
  thrift_spec = (
8613 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8614 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8615 
  )
8616 
 
8617 
  def __init__(self, success=None, cex=None,):
8618 
    self.success = success
8619 
    self.cex = cex
8620 
 
8621 
  def read(self, iprot):
8622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8624 
      return
8625 
    iprot.readStructBegin()
8626 
    while True:
8627 
      (fname, ftype, fid) = iprot.readFieldBegin()
8628 
      if ftype == TType.STOP:
8629 
        break
8630 
      if fid == 0:
8631 
        if ftype == TType.LIST:
8632 
          self.success = []
8633 
          (_etype117, _size114) = iprot.readListBegin()
8634 
          for _i118 in xrange(_size114):
8635 
            _elem119 = iprot.readI64();
8636 
            self.success.append(_elem119)
8637 
          iprot.readListEnd()
8638 
        else:
8639 
          iprot.skip(ftype)
8640 
      elif fid == 1:
8641 
        if ftype == TType.STRUCT:
8642 
          self.cex = CatalogServiceException()
8643 
          self.cex.read(iprot)
8644 
        else:
8645 
          iprot.skip(ftype)
8646 
      else:
8647 
        iprot.skip(ftype)
8648 
      iprot.readFieldEnd()
8649 
    iprot.readStructEnd()
8650 
 
8651 
  def write(self, oprot):
8652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8654 
      return
8655 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8656 
    if self.success is not None:
8657 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8658 
      oprot.writeListBegin(TType.I64, len(self.success))
8659 
      for iter120 in self.success:
8660 
        oprot.writeI64(iter120)
8661 
      oprot.writeListEnd()
8662 
      oprot.writeFieldEnd()
8663 
    if self.cex is not None:
8664 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8665 
      self.cex.write(oprot)
8666 
      oprot.writeFieldEnd()
8667 
    oprot.writeFieldStop()
8668 
    oprot.writeStructEnd()
8669 
 
8670 
  def validate(self):
8671 
    return
8672 
 
8673 
 
8674 
  def __repr__(self):
8675 
    L = ['%s=%r' % (key, value)
8676 
      for key, value in self.__dict__.iteritems()]
8677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8678 
 
8679 
  def __eq__(self, other):
8680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8681 
 
8682 
  def __ne__(self, other):
8683 
    return not (self == other)
8684 
 
8685 
class getLatestArrivalsCount_args:
8686 
 
8687 
  thrift_spec = (
8688 
  )
8689 
 
8690 
  def read(self, iprot):
8691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8693 
      return
8694 
    iprot.readStructBegin()
8695 
    while True:
8696 
      (fname, ftype, fid) = iprot.readFieldBegin()
8697 
      if ftype == TType.STOP:
8698 
        break
8699 
      else:
8700 
        iprot.skip(ftype)
8701 
      iprot.readFieldEnd()
8702 
    iprot.readStructEnd()
8703 
 
8704 
  def write(self, oprot):
8705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8707 
      return
8708 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8709 
    oprot.writeFieldStop()
8710 
    oprot.writeStructEnd()
8711 
 
8712 
  def validate(self):
8713 
    return
8714 
 
8715 
 
8716 
  def __repr__(self):
8717 
    L = ['%s=%r' % (key, value)
8718 
      for key, value in self.__dict__.iteritems()]
8719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8720 
 
8721 
  def __eq__(self, other):
8722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8723 
 
8724 
  def __ne__(self, other):
8725 
    return not (self == other)
8726 
 
8727 
class getLatestArrivalsCount_result:
8728 
  """
8729 
  Attributes:
8730 
   - success
8731 
   - cex
8732 
  """
8733 
 
8734 
  thrift_spec = (
8735 
    (0, TType.I64, 'success', None, None, ), # 0
8736 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8737 
  )
8738 
 
8739 
  def __init__(self, success=None, cex=None,):
8740 
    self.success = success
8741 
    self.cex = cex
8742 
 
8743 
  def read(self, iprot):
8744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8746 
      return
8747 
    iprot.readStructBegin()
8748 
    while True:
8749 
      (fname, ftype, fid) = iprot.readFieldBegin()
8750 
      if ftype == TType.STOP:
8751 
        break
8752 
      if fid == 0:
8753 
        if ftype == TType.I64:
8754 
          self.success = iprot.readI64();
8755 
        else:
8756 
          iprot.skip(ftype)
8757 
      elif fid == 1:
8758 
        if ftype == TType.STRUCT:
8759 
          self.cex = CatalogServiceException()
8760 
          self.cex.read(iprot)
8761 
        else:
8762 
          iprot.skip(ftype)
8763 
      else:
8764 
        iprot.skip(ftype)
8765 
      iprot.readFieldEnd()
8766 
    iprot.readStructEnd()
8767 
 
8768 
  def write(self, oprot):
8769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8771 
      return
8772 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8773 
    if self.success is not None:
8774 
      oprot.writeFieldBegin('success', TType.I64, 0)
8775 
      oprot.writeI64(self.success)
8776 
      oprot.writeFieldEnd()
8777 
    if self.cex is not None:
8778 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8779 
      self.cex.write(oprot)
8780 
      oprot.writeFieldEnd()
8781 
    oprot.writeFieldStop()
8782 
    oprot.writeStructEnd()
8783 
 
8784 
  def validate(self):
8785 
    return
8786 
 
8787 
 
8788 
  def __repr__(self):
8789 
    L = ['%s=%r' % (key, value)
8790 
      for key, value in self.__dict__.iteritems()]
8791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8792 
 
8793 
  def __eq__(self, other):
8794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8795 
 
8796 
  def __ne__(self, other):
8797 
    return not (self == other)
8798 
 
8799 
class generateNewEntityID_args:
8800 
 
8801 
  thrift_spec = (
8802 
  )
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 
      else:
8814 
        iprot.skip(ftype)
8815 
      iprot.readFieldEnd()
8816 
    iprot.readStructEnd()
8817 
 
8818 
  def write(self, oprot):
8819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8821 
      return
8822 
    oprot.writeStructBegin('generateNewEntityID_args')
8823 
    oprot.writeFieldStop()
8824 
    oprot.writeStructEnd()
8825 
 
8826 
  def validate(self):
8827 
    return
8828 
 
8829 
 
8830 
  def __repr__(self):
8831 
    L = ['%s=%r' % (key, value)
8832 
      for key, value in self.__dict__.iteritems()]
8833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8834 
 
8835 
  def __eq__(self, other):
8836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8837 
 
8838 
  def __ne__(self, other):
8839 
    return not (self == other)
8840 
 
8841 
class generateNewEntityID_result:
8842 
  """
8843 
  Attributes:
8844 
   - success
8845 
  """
8846 
 
8847 
  thrift_spec = (
8848 
    (0, TType.I64, 'success', None, None, ), # 0
8849 
  )
8850 
 
8851 
  def __init__(self, success=None,):
8852 
    self.success = success
8853 
 
8854 
  def read(self, iprot):
8855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8857 
      return
8858 
    iprot.readStructBegin()
8859 
    while True:
8860 
      (fname, ftype, fid) = iprot.readFieldBegin()
8861 
      if ftype == TType.STOP:
8862 
        break
8863 
      if fid == 0:
8864 
        if ftype == TType.I64:
8865 
          self.success = iprot.readI64();
8866 
        else:
8867 
          iprot.skip(ftype)
8868 
      else:
8869 
        iprot.skip(ftype)
8870 
      iprot.readFieldEnd()
8871 
    iprot.readStructEnd()
8872 
 
8873 
  def write(self, oprot):
8874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8876 
      return
8877 
    oprot.writeStructBegin('generateNewEntityID_result')
8878 
    if self.success is not None:
8879 
      oprot.writeFieldBegin('success', TType.I64, 0)
8880 
      oprot.writeI64(self.success)
8881 
      oprot.writeFieldEnd()
8882 
    oprot.writeFieldStop()
8883 
    oprot.writeStructEnd()
8884 
 
8885 
  def validate(self):
8886 
    return
8887 
 
8888 
 
8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
8900 
class addCategory_args:
8901 
  """
8902 
  Attributes:
8903 
   - category
8904 
  """
8905 
 
8906 
  thrift_spec = (
8907 
    None, # 0
8908 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
8909 
  )
8910 
 
8911 
  def __init__(self, category=None,):
8912 
    self.category = category
8913 
 
8914 
  def read(self, iprot):
8915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8917 
      return
8918 
    iprot.readStructBegin()
8919 
    while True:
8920 
      (fname, ftype, fid) = iprot.readFieldBegin()
8921 
      if ftype == TType.STOP:
8922 
        break
8923 
      if fid == 1:
8924 
        if ftype == TType.STRUCT:
8925 
          self.category = Category()
8926 
          self.category.read(iprot)
8927 
        else:
8928 
          iprot.skip(ftype)
8929 
      else:
8930 
        iprot.skip(ftype)
8931 
      iprot.readFieldEnd()
8932 
    iprot.readStructEnd()
8933 
 
8934 
  def write(self, oprot):
8935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8937 
      return
8938 
    oprot.writeStructBegin('addCategory_args')
8939 
    if self.category is not None:
8940 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
8941 
      self.category.write(oprot)
8942 
      oprot.writeFieldEnd()
8943 
    oprot.writeFieldStop()
8944 
    oprot.writeStructEnd()
8945 
 
8946 
  def validate(self):
8947 
    return
8948 
 
8949 
 
8950 
  def __repr__(self):
8951 
    L = ['%s=%r' % (key, value)
8952 
      for key, value in self.__dict__.iteritems()]
8953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8954 
 
8955 
  def __eq__(self, other):
8956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8957 
 
8958 
  def __ne__(self, other):
8959 
    return not (self == other)
8960 
 
8961 
class addCategory_result:
8962 
  """
8963 
  Attributes:
8964 
   - success
8965 
  """
8966 
 
8967 
  thrift_spec = (
8968 
    (0, TType.BOOL, 'success', None, None, ), # 0
8969 
  )
8970 
 
8971 
  def __init__(self, success=None,):
8972 
    self.success = success
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 0:
8984 
        if ftype == TType.BOOL:
8985 
          self.success = iprot.readBool();
8986 
        else:
8987 
          iprot.skip(ftype)
8988 
      else:
8989 
        iprot.skip(ftype)
8990 
      iprot.readFieldEnd()
8991 
    iprot.readStructEnd()
8992 
 
8993 
  def write(self, oprot):
8994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8996 
      return
8997 
    oprot.writeStructBegin('addCategory_result')
8998 
    if self.success is not None:
8999 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9000 
      oprot.writeBool(self.success)
9001 
      oprot.writeFieldEnd()
9002 
    oprot.writeFieldStop()
9003 
    oprot.writeStructEnd()
9004 
 
9005 
  def validate(self):
9006 
    return
9007 
 
9008 
 
9009 
  def __repr__(self):
9010 
    L = ['%s=%r' % (key, value)
9011 
      for key, value in self.__dict__.iteritems()]
9012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9013 
 
9014 
  def __eq__(self, other):
9015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9016 
 
9017 
  def __ne__(self, other):
9018 
    return not (self == other)
9019 
 
9020 
class getCategory_args:
9021 
  """
9022 
  Attributes:
9023 
   - id
9024 
  """
9025 
 
9026 
  thrift_spec = (
9027 
    None, # 0
9028 
    (1, TType.I64, 'id', None, None, ), # 1
9029 
  )
9030 
 
9031 
  def __init__(self, id=None,):
9032 
    self.id = id
9033 
 
9034 
  def read(self, iprot):
9035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9037 
      return
9038 
    iprot.readStructBegin()
9039 
    while True:
9040 
      (fname, ftype, fid) = iprot.readFieldBegin()
9041 
      if ftype == TType.STOP:
9042 
        break
9043 
      if fid == 1:
9044 
        if ftype == TType.I64:
9045 
          self.id = iprot.readI64();
9046 
        else:
9047 
          iprot.skip(ftype)
9048 
      else:
9049 
        iprot.skip(ftype)
9050 
      iprot.readFieldEnd()
9051 
    iprot.readStructEnd()
9052 
 
9053 
  def write(self, oprot):
9054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9056 
      return
9057 
    oprot.writeStructBegin('getCategory_args')
9058 
    if self.id is not None:
9059 
      oprot.writeFieldBegin('id', TType.I64, 1)
9060 
      oprot.writeI64(self.id)
9061 
      oprot.writeFieldEnd()
9062 
    oprot.writeFieldStop()
9063 
    oprot.writeStructEnd()
9064 
 
9065 
  def validate(self):
9066 
    return
9067 
 
9068 
 
9069 
  def __repr__(self):
9070 
    L = ['%s=%r' % (key, value)
9071 
      for key, value in self.__dict__.iteritems()]
9072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9073 
 
9074 
  def __eq__(self, other):
9075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9076 
 
9077 
  def __ne__(self, other):
9078 
    return not (self == other)
9079 
 
9080 
class getCategory_result:
9081 
  """
9082 
  Attributes:
9083 
   - success
9084 
  """
9085 
 
9086 
  thrift_spec = (
9087 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9088 
  )
9089 
 
9090 
  def __init__(self, success=None,):
9091 
    self.success = success
9092 
 
9093 
  def read(self, iprot):
9094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9096 
      return
9097 
    iprot.readStructBegin()
9098 
    while True:
9099 
      (fname, ftype, fid) = iprot.readFieldBegin()
9100 
      if ftype == TType.STOP:
9101 
        break
9102 
      if fid == 0:
9103 
        if ftype == TType.STRUCT:
9104 
          self.success = Category()
9105 
          self.success.read(iprot)
9106 
        else:
9107 
          iprot.skip(ftype)
9108 
      else:
9109 
        iprot.skip(ftype)
9110 
      iprot.readFieldEnd()
9111 
    iprot.readStructEnd()
9112 
 
9113 
  def write(self, oprot):
9114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9116 
      return
9117 
    oprot.writeStructBegin('getCategory_result')
9118 
    if self.success is not None:
9119 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9120 
      self.success.write(oprot)
9121 
      oprot.writeFieldEnd()
9122 
    oprot.writeFieldStop()
9123 
    oprot.writeStructEnd()
9124 
 
9125 
  def validate(self):
9126 
    return
9127 
 
9128 
 
9129 
  def __repr__(self):
9130 
    L = ['%s=%r' % (key, value)
9131 
      for key, value in self.__dict__.iteritems()]
9132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9133 
 
9134 
  def __eq__(self, other):
9135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9136 
 
9137 
  def __ne__(self, other):
9138 
    return not (self == other)
9139 
 
9140 
class getAllCategories_args:
9141 
 
9142 
  thrift_spec = (
9143 
  )
9144 
 
9145 
  def read(self, iprot):
9146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9148 
      return
9149 
    iprot.readStructBegin()
9150 
    while True:
9151 
      (fname, ftype, fid) = iprot.readFieldBegin()
9152 
      if ftype == TType.STOP:
9153 
        break
9154 
      else:
9155 
        iprot.skip(ftype)
9156 
      iprot.readFieldEnd()
9157 
    iprot.readStructEnd()
9158 
 
9159 
  def write(self, oprot):
9160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9162 
      return
9163 
    oprot.writeStructBegin('getAllCategories_args')
9164 
    oprot.writeFieldStop()
9165 
    oprot.writeStructEnd()
9166 
 
9167 
  def validate(self):
9168 
    return
9169 
 
9170 
 
9171 
  def __repr__(self):
9172 
    L = ['%s=%r' % (key, value)
9173 
      for key, value in self.__dict__.iteritems()]
9174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9175 
 
9176 
  def __eq__(self, other):
9177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9178 
 
9179 
  def __ne__(self, other):
9180 
    return not (self == other)
9181 
 
9182 
class getAllCategories_result:
9183 
  """
9184 
  Attributes:
9185 
   - success
9186 
  """
9187 
 
9188 
  thrift_spec = (
9189 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9190 
  )
9191 
 
9192 
  def __init__(self, success=None,):
9193 
    self.success = success
9194 
 
9195 
  def read(self, iprot):
9196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9198 
      return
9199 
    iprot.readStructBegin()
9200 
    while True:
9201 
      (fname, ftype, fid) = iprot.readFieldBegin()
9202 
      if ftype == TType.STOP:
9203 
        break
9204 
      if fid == 0:
9205 
        if ftype == TType.LIST:
9206 
          self.success = []
9207 
          (_etype124, _size121) = iprot.readListBegin()
9208 
          for _i125 in xrange(_size121):
9209 
            _elem126 = Category()
9210 
            _elem126.read(iprot)
9211 
            self.success.append(_elem126)
9212 
          iprot.readListEnd()
9213 
        else:
9214 
          iprot.skip(ftype)
9215 
      else:
9216 
        iprot.skip(ftype)
9217 
      iprot.readFieldEnd()
9218 
    iprot.readStructEnd()
9219 
 
9220 
  def write(self, oprot):
9221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9223 
      return
9224 
    oprot.writeStructBegin('getAllCategories_result')
9225 
    if self.success is not None:
9226 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9227 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9228 
      for iter127 in self.success:
9229 
        iter127.write(oprot)
9230 
      oprot.writeListEnd()
9231 
      oprot.writeFieldEnd()
9232 
    oprot.writeFieldStop()
9233 
    oprot.writeStructEnd()
9234 
 
9235 
  def validate(self):
9236 
    return
9237 
 
9238 
 
9239 
  def __repr__(self):
9240 
    L = ['%s=%r' % (key, value)
9241 
      for key, value in self.__dict__.iteritems()]
9242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9243 
 
9244 
  def __eq__(self, other):
9245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9246 
 
9247 
  def __ne__(self, other):
9248 
    return not (self == other)
9249 
 
9250 
class getAllSimilarItems_args:
9251 
  """
9252 
  Attributes:
9253 
   - itemId
9254 
  """
9255 
 
9256 
  thrift_spec = (
9257 
    None, # 0
9258 
    (1, TType.I64, 'itemId', None, None, ), # 1
9259 
  )
9260 
 
9261 
  def __init__(self, itemId=None,):
9262 
    self.itemId = itemId
9263 
 
9264 
  def read(self, iprot):
9265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9267 
      return
9268 
    iprot.readStructBegin()
9269 
    while True:
9270 
      (fname, ftype, fid) = iprot.readFieldBegin()
9271 
      if ftype == TType.STOP:
9272 
        break
9273 
      if fid == 1:
9274 
        if ftype == TType.I64:
9275 
          self.itemId = iprot.readI64();
9276 
        else:
9277 
          iprot.skip(ftype)
9278 
      else:
9279 
        iprot.skip(ftype)
9280 
      iprot.readFieldEnd()
9281 
    iprot.readStructEnd()
9282 
 
9283 
  def write(self, oprot):
9284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9286 
      return
9287 
    oprot.writeStructBegin('getAllSimilarItems_args')
9288 
    if self.itemId is not None:
9289 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9290 
      oprot.writeI64(self.itemId)
9291 
      oprot.writeFieldEnd()
9292 
    oprot.writeFieldStop()
9293 
    oprot.writeStructEnd()
9294 
 
9295 
  def validate(self):
9296 
    return
9297 
 
9298 
 
9299 
  def __repr__(self):
9300 
    L = ['%s=%r' % (key, value)
9301 
      for key, value in self.__dict__.iteritems()]
9302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9303 
 
9304 
  def __eq__(self, other):
9305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9306 
 
9307 
  def __ne__(self, other):
9308 
    return not (self == other)
9309 
 
9310 
class getAllSimilarItems_result:
9311 
  """
9312 
  Attributes:
9313 
   - success
9314 
  """
9315 
 
9316 
  thrift_spec = (
9317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9318 
  )
9319 
 
9320 
  def __init__(self, success=None,):
9321 
    self.success = success
9322 
 
9323 
  def read(self, iprot):
9324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9326 
      return
9327 
    iprot.readStructBegin()
9328 
    while True:
9329 
      (fname, ftype, fid) = iprot.readFieldBegin()
9330 
      if ftype == TType.STOP:
9331 
        break
9332 
      if fid == 0:
9333 
        if ftype == TType.LIST:
9334 
          self.success = []
9335 
          (_etype131, _size128) = iprot.readListBegin()
9336 
          for _i132 in xrange(_size128):
9337 
            _elem133 = Item()
9338 
            _elem133.read(iprot)
9339 
            self.success.append(_elem133)
9340 
          iprot.readListEnd()
9341 
        else:
9342 
          iprot.skip(ftype)
9343 
      else:
9344 
        iprot.skip(ftype)
9345 
      iprot.readFieldEnd()
9346 
    iprot.readStructEnd()
9347 
 
9348 
  def write(self, oprot):
9349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9351 
      return
9352 
    oprot.writeStructBegin('getAllSimilarItems_result')
9353 
    if self.success is not None:
9354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9356 
      for iter134 in self.success:
9357 
        iter134.write(oprot)
9358 
      oprot.writeListEnd()
9359 
      oprot.writeFieldEnd()
9360 
    oprot.writeFieldStop()
9361 
    oprot.writeStructEnd()
9362 
 
9363 
  def validate(self):
9364 
    return
9365 
 
9366 
 
9367 
  def __repr__(self):
9368 
    L = ['%s=%r' % (key, value)
9369 
      for key, value in self.__dict__.iteritems()]
9370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9371 
 
9372 
  def __eq__(self, other):
9373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9374 
 
9375 
  def __ne__(self, other):
9376 
    return not (self == other)
9377 
 
9378 
class addSimilarItem_args:
9379 
  """
9380 
  Attributes:
9381 
   - itemId
9382 
   - catalogItemId
9383 
  """
9384 
 
9385 
  thrift_spec = (
9386 
    None, # 0
9387 
    (1, TType.I64, 'itemId', None, None, ), # 1
9388 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9389 
  )
9390 
 
9391 
  def __init__(self, itemId=None, catalogItemId=None,):
9392 
    self.itemId = itemId
9393 
    self.catalogItemId = catalogItemId
9394 
 
9395 
  def read(self, iprot):
9396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9398 
      return
9399 
    iprot.readStructBegin()
9400 
    while True:
9401 
      (fname, ftype, fid) = iprot.readFieldBegin()
9402 
      if ftype == TType.STOP:
9403 
        break
9404 
      if fid == 1:
9405 
        if ftype == TType.I64:
9406 
          self.itemId = iprot.readI64();
9407 
        else:
9408 
          iprot.skip(ftype)
9409 
      elif fid == 2:
9410 
        if ftype == TType.I64:
9411 
          self.catalogItemId = iprot.readI64();
9412 
        else:
9413 
          iprot.skip(ftype)
9414 
      else:
9415 
        iprot.skip(ftype)
9416 
      iprot.readFieldEnd()
9417 
    iprot.readStructEnd()
9418 
 
9419 
  def write(self, oprot):
9420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9422 
      return
9423 
    oprot.writeStructBegin('addSimilarItem_args')
9424 
    if self.itemId is not None:
9425 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9426 
      oprot.writeI64(self.itemId)
9427 
      oprot.writeFieldEnd()
9428 
    if self.catalogItemId is not None:
9429 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9430 
      oprot.writeI64(self.catalogItemId)
9431 
      oprot.writeFieldEnd()
9432 
    oprot.writeFieldStop()
9433 
    oprot.writeStructEnd()
9434 
 
9435 
  def validate(self):
9436 
    return
9437 
 
9438 
 
9439 
  def __repr__(self):
9440 
    L = ['%s=%r' % (key, value)
9441 
      for key, value in self.__dict__.iteritems()]
9442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9443 
 
9444 
  def __eq__(self, other):
9445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9446 
 
9447 
  def __ne__(self, other):
9448 
    return not (self == other)
9449 
 
9450 
class addSimilarItem_result:
9451 
  """
9452 
  Attributes:
9453 
   - success
9454 
   - cex
9455 
  """
9456 
 
9457 
  thrift_spec = (
9458 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9459 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9460 
  )
9461 
 
9462 
  def __init__(self, success=None, cex=None,):
9463 
    self.success = success
9464 
    self.cex = cex
9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 0:
9476 
        if ftype == TType.STRUCT:
9477 
          self.success = Item()
9478 
          self.success.read(iprot)
9479 
        else:
9480 
          iprot.skip(ftype)
9481 
      elif fid == 1:
9482 
        if ftype == TType.STRUCT:
9483 
          self.cex = CatalogServiceException()
9484 
          self.cex.read(iprot)
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      else:
9488 
        iprot.skip(ftype)
9489 
      iprot.readFieldEnd()
9490 
    iprot.readStructEnd()
9491 
 
9492 
  def write(self, oprot):
9493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9495 
      return
9496 
    oprot.writeStructBegin('addSimilarItem_result')
9497 
    if self.success is not None:
9498 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9499 
      self.success.write(oprot)
9500 
      oprot.writeFieldEnd()
9501 
    if self.cex is not None:
9502 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9503 
      self.cex.write(oprot)
9504 
      oprot.writeFieldEnd()
9505 
    oprot.writeFieldStop()
9506 
    oprot.writeStructEnd()
9507 
 
9508 
  def validate(self):
9509 
    return
9510 
 
9511 
 
9512 
  def __repr__(self):
9513 
    L = ['%s=%r' % (key, value)
9514 
      for key, value in self.__dict__.iteritems()]
9515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9516 
 
9517 
  def __eq__(self, other):
9518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9519 
 
9520 
  def __ne__(self, other):
9521 
    return not (self == other)
9522 
 
6512 kshitij.so 9523 
class addTag_args:
9524 
  """
9525 
  Attributes:
9526 
   - displayName
9527 
   - itemId
9528 
  """
9529 
 
9530 
  thrift_spec = (
9531 
    None, # 0
9532 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9533 
    (2, TType.I64, 'itemId', None, None, ), # 2
9534 
  )
9535 
 
9536 
  def __init__(self, displayName=None, itemId=None,):
9537 
    self.displayName = displayName
9538 
    self.itemId = itemId
9539 
 
9540 
  def read(self, iprot):
9541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9543 
      return
9544 
    iprot.readStructBegin()
9545 
    while True:
9546 
      (fname, ftype, fid) = iprot.readFieldBegin()
9547 
      if ftype == TType.STOP:
9548 
        break
9549 
      if fid == 1:
9550 
        if ftype == TType.STRING:
9551 
          self.displayName = iprot.readString();
9552 
        else:
9553 
          iprot.skip(ftype)
9554 
      elif fid == 2:
9555 
        if ftype == TType.I64:
9556 
          self.itemId = iprot.readI64();
9557 
        else:
9558 
          iprot.skip(ftype)
9559 
      else:
9560 
        iprot.skip(ftype)
9561 
      iprot.readFieldEnd()
9562 
    iprot.readStructEnd()
9563 
 
9564 
  def write(self, oprot):
9565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9567 
      return
9568 
    oprot.writeStructBegin('addTag_args')
9569 
    if self.displayName is not None:
9570 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9571 
      oprot.writeString(self.displayName)
9572 
      oprot.writeFieldEnd()
9573 
    if self.itemId is not None:
9574 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9575 
      oprot.writeI64(self.itemId)
9576 
      oprot.writeFieldEnd()
9577 
    oprot.writeFieldStop()
9578 
    oprot.writeStructEnd()
9579 
 
9580 
  def validate(self):
9581 
    return
9582 
 
9583 
 
9584 
  def __repr__(self):
9585 
    L = ['%s=%r' % (key, value)
9586 
      for key, value in self.__dict__.iteritems()]
9587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9588 
 
9589 
  def __eq__(self, other):
9590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9591 
 
9592 
  def __ne__(self, other):
9593 
    return not (self == other)
9594 
 
9595 
class addTag_result:
9596 
  """
9597 
  Attributes:
9598 
   - success
9599 
  """
9600 
 
9601 
  thrift_spec = (
9602 
    (0, TType.BOOL, 'success', None, None, ), # 0
9603 
  )
9604 
 
9605 
  def __init__(self, success=None,):
9606 
    self.success = success
9607 
 
9608 
  def read(self, iprot):
9609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9611 
      return
9612 
    iprot.readStructBegin()
9613 
    while True:
9614 
      (fname, ftype, fid) = iprot.readFieldBegin()
9615 
      if ftype == TType.STOP:
9616 
        break
9617 
      if fid == 0:
9618 
        if ftype == TType.BOOL:
9619 
          self.success = iprot.readBool();
9620 
        else:
9621 
          iprot.skip(ftype)
9622 
      else:
9623 
        iprot.skip(ftype)
9624 
      iprot.readFieldEnd()
9625 
    iprot.readStructEnd()
9626 
 
9627 
  def write(self, oprot):
9628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9630 
      return
9631 
    oprot.writeStructBegin('addTag_result')
9632 
    if self.success is not None:
9633 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9634 
      oprot.writeBool(self.success)
9635 
      oprot.writeFieldEnd()
9636 
    oprot.writeFieldStop()
9637 
    oprot.writeStructEnd()
9638 
 
9639 
  def validate(self):
9640 
    return
9641 
 
9642 
 
9643 
  def __repr__(self):
9644 
    L = ['%s=%r' % (key, value)
9645 
      for key, value in self.__dict__.iteritems()]
9646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9647 
 
9648 
  def __eq__(self, other):
9649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9650 
 
9651 
  def __ne__(self, other):
9652 
    return not (self == other)
9653 
 
9654 
class deleteEntityTag_args:
9655 
  """
9656 
  Attributes:
9657 
   - displayName
9658 
   - itemId
9659 
  """
9660 
 
9661 
  thrift_spec = (
9662 
    None, # 0
9663 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9664 
    (2, TType.I64, 'itemId', None, None, ), # 2
9665 
  )
9666 
 
9667 
  def __init__(self, displayName=None, itemId=None,):
9668 
    self.displayName = displayName
9669 
    self.itemId = itemId
9670 
 
9671 
  def read(self, iprot):
9672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9674 
      return
9675 
    iprot.readStructBegin()
9676 
    while True:
9677 
      (fname, ftype, fid) = iprot.readFieldBegin()
9678 
      if ftype == TType.STOP:
9679 
        break
9680 
      if fid == 1:
9681 
        if ftype == TType.STRING:
9682 
          self.displayName = iprot.readString();
9683 
        else:
9684 
          iprot.skip(ftype)
9685 
      elif fid == 2:
9686 
        if ftype == TType.I64:
9687 
          self.itemId = iprot.readI64();
9688 
        else:
9689 
          iprot.skip(ftype)
9690 
      else:
9691 
        iprot.skip(ftype)
9692 
      iprot.readFieldEnd()
9693 
    iprot.readStructEnd()
9694 
 
9695 
  def write(self, oprot):
9696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9698 
      return
9699 
    oprot.writeStructBegin('deleteEntityTag_args')
9700 
    if self.displayName is not None:
9701 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9702 
      oprot.writeString(self.displayName)
9703 
      oprot.writeFieldEnd()
9704 
    if self.itemId is not None:
9705 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9706 
      oprot.writeI64(self.itemId)
9707 
      oprot.writeFieldEnd()
9708 
    oprot.writeFieldStop()
9709 
    oprot.writeStructEnd()
9710 
 
9711 
  def validate(self):
9712 
    return
9713 
 
9714 
 
9715 
  def __repr__(self):
9716 
    L = ['%s=%r' % (key, value)
9717 
      for key, value in self.__dict__.iteritems()]
9718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9719 
 
9720 
  def __eq__(self, other):
9721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9722 
 
9723 
  def __ne__(self, other):
9724 
    return not (self == other)
9725 
 
9726 
class deleteEntityTag_result:
9727 
  """
9728 
  Attributes:
9729 
   - success
9730 
  """
9731 
 
9732 
  thrift_spec = (
9733 
    (0, TType.BOOL, 'success', None, None, ), # 0
9734 
  )
9735 
 
9736 
  def __init__(self, success=None,):
9737 
    self.success = success
9738 
 
9739 
  def read(self, iprot):
9740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9742 
      return
9743 
    iprot.readStructBegin()
9744 
    while True:
9745 
      (fname, ftype, fid) = iprot.readFieldBegin()
9746 
      if ftype == TType.STOP:
9747 
        break
9748 
      if fid == 0:
9749 
        if ftype == TType.BOOL:
9750 
          self.success = iprot.readBool();
9751 
        else:
9752 
          iprot.skip(ftype)
9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
9762 
    oprot.writeStructBegin('deleteEntityTag_result')
9763 
    if self.success is not None:
9764 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9765 
      oprot.writeBool(self.success)
9766 
      oprot.writeFieldEnd()
9767 
    oprot.writeFieldStop()
9768 
    oprot.writeStructEnd()
9769 
 
9770 
  def validate(self):
9771 
    return
9772 
 
9773 
 
9774 
  def __repr__(self):
9775 
    L = ['%s=%r' % (key, value)
9776 
      for key, value in self.__dict__.iteritems()]
9777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9778 
 
9779 
  def __eq__(self, other):
9780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9781 
 
9782 
  def __ne__(self, other):
9783 
    return not (self == other)
9784 
 
9785 
class deleteTag_args:
9786 
  """
9787 
  Attributes:
9788 
   - displayName
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    None, # 0
9793 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, displayName=None,):
9797 
    self.displayName = displayName
9798 
 
9799 
  def read(self, iprot):
9800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9802 
      return
9803 
    iprot.readStructBegin()
9804 
    while True:
9805 
      (fname, ftype, fid) = iprot.readFieldBegin()
9806 
      if ftype == TType.STOP:
9807 
        break
9808 
      if fid == 1:
9809 
        if ftype == TType.STRING:
9810 
          self.displayName = iprot.readString();
9811 
        else:
9812 
          iprot.skip(ftype)
9813 
      else:
9814 
        iprot.skip(ftype)
9815 
      iprot.readFieldEnd()
9816 
    iprot.readStructEnd()
9817 
 
9818 
  def write(self, oprot):
9819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9821 
      return
9822 
    oprot.writeStructBegin('deleteTag_args')
9823 
    if self.displayName is not None:
9824 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9825 
      oprot.writeString(self.displayName)
9826 
      oprot.writeFieldEnd()
9827 
    oprot.writeFieldStop()
9828 
    oprot.writeStructEnd()
9829 
 
9830 
  def validate(self):
9831 
    return
9832 
 
9833 
 
9834 
  def __repr__(self):
9835 
    L = ['%s=%r' % (key, value)
9836 
      for key, value in self.__dict__.iteritems()]
9837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9838 
 
9839 
  def __eq__(self, other):
9840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9841 
 
9842 
  def __ne__(self, other):
9843 
    return not (self == other)
9844 
 
9845 
class deleteTag_result:
9846 
  """
9847 
  Attributes:
9848 
   - success
9849 
  """
9850 
 
9851 
  thrift_spec = (
9852 
    (0, TType.BOOL, 'success', None, None, ), # 0
9853 
  )
9854 
 
9855 
  def __init__(self, success=None,):
9856 
    self.success = success
9857 
 
9858 
  def read(self, iprot):
9859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9861 
      return
9862 
    iprot.readStructBegin()
9863 
    while True:
9864 
      (fname, ftype, fid) = iprot.readFieldBegin()
9865 
      if ftype == TType.STOP:
9866 
        break
9867 
      if fid == 0:
9868 
        if ftype == TType.BOOL:
9869 
          self.success = iprot.readBool();
9870 
        else:
9871 
          iprot.skip(ftype)
9872 
      else:
9873 
        iprot.skip(ftype)
9874 
      iprot.readFieldEnd()
9875 
    iprot.readStructEnd()
9876 
 
9877 
  def write(self, oprot):
9878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9880 
      return
9881 
    oprot.writeStructBegin('deleteTag_result')
9882 
    if self.success is not None:
9883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9884 
      oprot.writeBool(self.success)
9885 
      oprot.writeFieldEnd()
9886 
    oprot.writeFieldStop()
9887 
    oprot.writeStructEnd()
9888 
 
9889 
  def validate(self):
9890 
    return
9891 
 
9892 
 
9893 
  def __repr__(self):
9894 
    L = ['%s=%r' % (key, value)
9895 
      for key, value in self.__dict__.iteritems()]
9896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9897 
 
9898 
  def __eq__(self, other):
9899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9900 
 
9901 
  def __ne__(self, other):
9902 
    return not (self == other)
9903 
 
9904 
class getAllTags_args:
9905 
 
9906 
  thrift_spec = (
9907 
  )
9908 
 
9909 
  def read(self, iprot):
9910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9912 
      return
9913 
    iprot.readStructBegin()
9914 
    while True:
9915 
      (fname, ftype, fid) = iprot.readFieldBegin()
9916 
      if ftype == TType.STOP:
9917 
        break
9918 
      else:
9919 
        iprot.skip(ftype)
9920 
      iprot.readFieldEnd()
9921 
    iprot.readStructEnd()
9922 
 
9923 
  def write(self, oprot):
9924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9926 
      return
9927 
    oprot.writeStructBegin('getAllTags_args')
9928 
    oprot.writeFieldStop()
9929 
    oprot.writeStructEnd()
9930 
 
9931 
  def validate(self):
9932 
    return
9933 
 
9934 
 
9935 
  def __repr__(self):
9936 
    L = ['%s=%r' % (key, value)
9937 
      for key, value in self.__dict__.iteritems()]
9938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9939 
 
9940 
  def __eq__(self, other):
9941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9942 
 
9943 
  def __ne__(self, other):
9944 
    return not (self == other)
9945 
 
9946 
class getAllTags_result:
9947 
  """
9948 
  Attributes:
9949 
   - success
9950 
  """
9951 
 
9952 
  thrift_spec = (
9953 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
9954 
  )
9955 
 
9956 
  def __init__(self, success=None,):
9957 
    self.success = success
9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 0:
9969 
        if ftype == TType.LIST:
9970 
          self.success = []
9971 
          (_etype138, _size135) = iprot.readListBegin()
9972 
          for _i139 in xrange(_size135):
9973 
            _elem140 = iprot.readString();
9974 
            self.success.append(_elem140)
9975 
          iprot.readListEnd()
9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      else:
9979 
        iprot.skip(ftype)
9980 
      iprot.readFieldEnd()
9981 
    iprot.readStructEnd()
9982 
 
9983 
  def write(self, oprot):
9984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9986 
      return
9987 
    oprot.writeStructBegin('getAllTags_result')
9988 
    if self.success is not None:
9989 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9990 
      oprot.writeListBegin(TType.STRING, len(self.success))
9991 
      for iter141 in self.success:
9992 
        oprot.writeString(iter141)
9993 
      oprot.writeListEnd()
9994 
      oprot.writeFieldEnd()
9995 
    oprot.writeFieldStop()
9996 
    oprot.writeStructEnd()
9997 
 
9998 
  def validate(self):
9999 
    return
10000 
 
10001 
 
10002 
  def __repr__(self):
10003 
    L = ['%s=%r' % (key, value)
10004 
      for key, value in self.__dict__.iteritems()]
10005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10006 
 
10007 
  def __eq__(self, other):
10008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10009 
 
10010 
  def __ne__(self, other):
10011 
    return not (self == other)
10012 
 
10013 
class getAllEntitiesByTagName_args:
10014 
  """
10015 
  Attributes:
10016 
   - displayName
10017 
  """
10018 
 
10019 
  thrift_spec = (
10020 
    None, # 0
10021 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10022 
  )
10023 
 
10024 
  def __init__(self, displayName=None,):
10025 
    self.displayName = displayName
10026 
 
10027 
  def read(self, iprot):
10028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10030 
      return
10031 
    iprot.readStructBegin()
10032 
    while True:
10033 
      (fname, ftype, fid) = iprot.readFieldBegin()
10034 
      if ftype == TType.STOP:
10035 
        break
10036 
      if fid == 1:
10037 
        if ftype == TType.STRING:
10038 
          self.displayName = iprot.readString();
10039 
        else:
10040 
          iprot.skip(ftype)
10041 
      else:
10042 
        iprot.skip(ftype)
10043 
      iprot.readFieldEnd()
10044 
    iprot.readStructEnd()
10045 
 
10046 
  def write(self, oprot):
10047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10049 
      return
10050 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10051 
    if self.displayName is not None:
10052 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10053 
      oprot.writeString(self.displayName)
10054 
      oprot.writeFieldEnd()
10055 
    oprot.writeFieldStop()
10056 
    oprot.writeStructEnd()
10057 
 
10058 
  def validate(self):
10059 
    return
10060 
 
10061 
 
10062 
  def __repr__(self):
10063 
    L = ['%s=%r' % (key, value)
10064 
      for key, value in self.__dict__.iteritems()]
10065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10066 
 
10067 
  def __eq__(self, other):
10068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10069 
 
10070 
  def __ne__(self, other):
10071 
    return not (self == other)
10072 
 
10073 
class getAllEntitiesByTagName_result:
10074 
  """
10075 
  Attributes:
10076 
   - success
10077 
  """
10078 
 
10079 
  thrift_spec = (
10080 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10081 
  )
10082 
 
10083 
  def __init__(self, success=None,):
10084 
    self.success = success
10085 
 
10086 
  def read(self, iprot):
10087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10089 
      return
10090 
    iprot.readStructBegin()
10091 
    while True:
10092 
      (fname, ftype, fid) = iprot.readFieldBegin()
10093 
      if ftype == TType.STOP:
10094 
        break
10095 
      if fid == 0:
10096 
        if ftype == TType.LIST:
10097 
          self.success = []
10098 
          (_etype145, _size142) = iprot.readListBegin()
10099 
          for _i146 in xrange(_size142):
10100 
            _elem147 = iprot.readI64();
10101 
            self.success.append(_elem147)
10102 
          iprot.readListEnd()
10103 
        else:
10104 
          iprot.skip(ftype)
10105 
      else:
10106 
        iprot.skip(ftype)
10107 
      iprot.readFieldEnd()
10108 
    iprot.readStructEnd()
10109 
 
10110 
  def write(self, oprot):
10111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10113 
      return
10114 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10115 
    if self.success is not None:
10116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10117 
      oprot.writeListBegin(TType.I64, len(self.success))
10118 
      for iter148 in self.success:
10119 
        oprot.writeI64(iter148)
10120 
      oprot.writeListEnd()
10121 
      oprot.writeFieldEnd()
10122 
    oprot.writeFieldStop()
10123 
    oprot.writeStructEnd()
10124 
 
10125 
  def validate(self):
10126 
    return
10127 
 
10128 
 
10129 
  def __repr__(self):
10130 
    L = ['%s=%r' % (key, value)
10131 
      for key, value in self.__dict__.iteritems()]
10132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10133 
 
10134 
  def __eq__(self, other):
10135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10136 
 
10137 
  def __ne__(self, other):
10138 
    return not (self == other)
10139 
 
6845 amit.gupta 10140 
class getAllEntityTags_args:
10141 
 
10142 
  thrift_spec = (
10143 
  )
10144 
 
10145 
  def read(self, iprot):
10146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10148 
      return
10149 
    iprot.readStructBegin()
10150 
    while True:
10151 
      (fname, ftype, fid) = iprot.readFieldBegin()
10152 
      if ftype == TType.STOP:
10153 
        break
10154 
      else:
10155 
        iprot.skip(ftype)
10156 
      iprot.readFieldEnd()
10157 
    iprot.readStructEnd()
10158 
 
10159 
  def write(self, oprot):
10160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10162 
      return
10163 
    oprot.writeStructBegin('getAllEntityTags_args')
10164 
    oprot.writeFieldStop()
10165 
    oprot.writeStructEnd()
10166 
 
10167 
  def validate(self):
10168 
    return
10169 
 
10170 
 
10171 
  def __repr__(self):
10172 
    L = ['%s=%r' % (key, value)
10173 
      for key, value in self.__dict__.iteritems()]
10174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10175 
 
10176 
  def __eq__(self, other):
10177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10178 
 
10179 
  def __ne__(self, other):
10180 
    return not (self == other)
10181 
 
10182 
class getAllEntityTags_result:
10183 
  """
10184 
  Attributes:
10185 
   - success
10186 
  """
10187 
 
10188 
  thrift_spec = (
10189 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10190 
  )
10191 
 
10192 
  def __init__(self, success=None,):
10193 
    self.success = success
10194 
 
10195 
  def read(self, iprot):
10196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10198 
      return
10199 
    iprot.readStructBegin()
10200 
    while True:
10201 
      (fname, ftype, fid) = iprot.readFieldBegin()
10202 
      if ftype == TType.STOP:
10203 
        break
10204 
      if fid == 0:
10205 
        if ftype == TType.MAP:
10206 
          self.success = {}
10207 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10208 
          for _i153 in xrange(_size149):
10209 
            _key154 = iprot.readI64();
10210 
            _val155 = []
10211 
            (_etype159, _size156) = iprot.readListBegin()
10212 
            for _i160 in xrange(_size156):
10213 
              _elem161 = iprot.readString();
10214 
              _val155.append(_elem161)
10215 
            iprot.readListEnd()
10216 
            self.success[_key154] = _val155
10217 
          iprot.readMapEnd()
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      else:
10221 
        iprot.skip(ftype)
10222 
      iprot.readFieldEnd()
10223 
    iprot.readStructEnd()
10224 
 
10225 
  def write(self, oprot):
10226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10228 
      return
10229 
    oprot.writeStructBegin('getAllEntityTags_result')
10230 
    if self.success is not None:
10231 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10232 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10233 
      for kiter162,viter163 in self.success.items():
10234 
        oprot.writeI64(kiter162)
10235 
        oprot.writeListBegin(TType.STRING, len(viter163))
10236 
        for iter164 in viter163:
10237 
          oprot.writeString(iter164)
10238 
        oprot.writeListEnd()
10239 
      oprot.writeMapEnd()
10240 
      oprot.writeFieldEnd()
10241 
    oprot.writeFieldStop()
10242 
    oprot.writeStructEnd()
10243 
 
10244 
  def validate(self):
10245 
    return
10246 
 
10247 
 
10248 
  def __repr__(self):
10249 
    L = ['%s=%r' % (key, value)
10250 
      for key, value in self.__dict__.iteritems()]
10251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10252 
 
10253 
  def __eq__(self, other):
10254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10255 
 
10256 
  def __ne__(self, other):
10257 
    return not (self == other)
10258 
 
6850 kshitij.so 10259 
class addBanner_args:
10260 
  """
10261 
  Attributes:
10262 
   - bannerName
10263 
   - imageName
10264 
   - link
10265 
   - priority
10266 
   - isActive
10267 
   - hasMap
10268 
  """
10269 
 
10270 
  thrift_spec = (
10271 
    None, # 0
10272 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10273 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10274 
    (3, TType.STRING, 'link', None, None, ), # 3
10275 
    (4, TType.I64, 'priority', None, None, ), # 4
10276 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10277 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10278 
  )
10279 
 
10280 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10281 
    self.bannerName = bannerName
10282 
    self.imageName = imageName
10283 
    self.link = link
10284 
    self.priority = priority
10285 
    self.isActive = isActive
10286 
    self.hasMap = hasMap
10287 
 
10288 
  def read(self, iprot):
10289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10291 
      return
10292 
    iprot.readStructBegin()
10293 
    while True:
10294 
      (fname, ftype, fid) = iprot.readFieldBegin()
10295 
      if ftype == TType.STOP:
10296 
        break
10297 
      if fid == 1:
10298 
        if ftype == TType.STRING:
10299 
          self.bannerName = iprot.readString();
10300 
        else:
10301 
          iprot.skip(ftype)
10302 
      elif fid == 2:
10303 
        if ftype == TType.STRING:
10304 
          self.imageName = iprot.readString();
10305 
        else:
10306 
          iprot.skip(ftype)
10307 
      elif fid == 3:
10308 
        if ftype == TType.STRING:
10309 
          self.link = iprot.readString();
10310 
        else:
10311 
          iprot.skip(ftype)
10312 
      elif fid == 4:
10313 
        if ftype == TType.I64:
10314 
          self.priority = iprot.readI64();
10315 
        else:
10316 
          iprot.skip(ftype)
10317 
      elif fid == 5:
10318 
        if ftype == TType.BOOL:
10319 
          self.isActive = iprot.readBool();
10320 
        else:
10321 
          iprot.skip(ftype)
10322 
      elif fid == 6:
10323 
        if ftype == TType.BOOL:
10324 
          self.hasMap = iprot.readBool();
10325 
        else:
10326 
          iprot.skip(ftype)
10327 
      else:
10328 
        iprot.skip(ftype)
10329 
      iprot.readFieldEnd()
10330 
    iprot.readStructEnd()
10331 
 
10332 
  def write(self, oprot):
10333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10335 
      return
10336 
    oprot.writeStructBegin('addBanner_args')
10337 
    if self.bannerName is not None:
10338 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10339 
      oprot.writeString(self.bannerName)
10340 
      oprot.writeFieldEnd()
10341 
    if self.imageName is not None:
10342 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10343 
      oprot.writeString(self.imageName)
10344 
      oprot.writeFieldEnd()
10345 
    if self.link is not None:
10346 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10347 
      oprot.writeString(self.link)
10348 
      oprot.writeFieldEnd()
10349 
    if self.priority is not None:
10350 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10351 
      oprot.writeI64(self.priority)
10352 
      oprot.writeFieldEnd()
10353 
    if self.isActive is not None:
10354 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10355 
      oprot.writeBool(self.isActive)
10356 
      oprot.writeFieldEnd()
10357 
    if self.hasMap is not None:
10358 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10359 
      oprot.writeBool(self.hasMap)
10360 
      oprot.writeFieldEnd()
10361 
    oprot.writeFieldStop()
10362 
    oprot.writeStructEnd()
10363 
 
10364 
  def validate(self):
10365 
    return
10366 
 
10367 
 
10368 
  def __repr__(self):
10369 
    L = ['%s=%r' % (key, value)
10370 
      for key, value in self.__dict__.iteritems()]
10371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10372 
 
10373 
  def __eq__(self, other):
10374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10375 
 
10376 
  def __ne__(self, other):
10377 
    return not (self == other)
10378 
 
10379 
class addBanner_result:
10380 
  """
10381 
  Attributes:
10382 
   - success
10383 
  """
10384 
 
10385 
  thrift_spec = (
10386 
    (0, TType.BOOL, 'success', None, None, ), # 0
10387 
  )
10388 
 
10389 
  def __init__(self, success=None,):
10390 
    self.success = success
10391 
 
10392 
  def read(self, iprot):
10393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10395 
      return
10396 
    iprot.readStructBegin()
10397 
    while True:
10398 
      (fname, ftype, fid) = iprot.readFieldBegin()
10399 
      if ftype == TType.STOP:
10400 
        break
10401 
      if fid == 0:
10402 
        if ftype == TType.BOOL:
10403 
          self.success = iprot.readBool();
10404 
        else:
10405 
          iprot.skip(ftype)
10406 
      else:
10407 
        iprot.skip(ftype)
10408 
      iprot.readFieldEnd()
10409 
    iprot.readStructEnd()
10410 
 
10411 
  def write(self, oprot):
10412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10414 
      return
10415 
    oprot.writeStructBegin('addBanner_result')
10416 
    if self.success is not None:
10417 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10418 
      oprot.writeBool(self.success)
10419 
      oprot.writeFieldEnd()
10420 
    oprot.writeFieldStop()
10421 
    oprot.writeStructEnd()
10422 
 
10423 
  def validate(self):
10424 
    return
10425 
 
10426 
 
10427 
  def __repr__(self):
10428 
    L = ['%s=%r' % (key, value)
10429 
      for key, value in self.__dict__.iteritems()]
10430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10431 
 
10432 
  def __eq__(self, other):
10433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10434 
 
10435 
  def __ne__(self, other):
10436 
    return not (self == other)
10437 
 
10438 
class getAllBanners_args:
10439 
 
10440 
  thrift_spec = (
10441 
  )
10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      else:
10453 
        iprot.skip(ftype)
10454 
      iprot.readFieldEnd()
10455 
    iprot.readStructEnd()
10456 
 
10457 
  def write(self, oprot):
10458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10460 
      return
10461 
    oprot.writeStructBegin('getAllBanners_args')
10462 
    oprot.writeFieldStop()
10463 
    oprot.writeStructEnd()
10464 
 
10465 
  def validate(self):
10466 
    return
10467 
 
10468 
 
10469 
  def __repr__(self):
10470 
    L = ['%s=%r' % (key, value)
10471 
      for key, value in self.__dict__.iteritems()]
10472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10473 
 
10474 
  def __eq__(self, other):
10475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10476 
 
10477 
  def __ne__(self, other):
10478 
    return not (self == other)
10479 
 
10480 
class getAllBanners_result:
10481 
  """
10482 
  Attributes:
10483 
   - success
10484 
  """
10485 
 
10486 
  thrift_spec = (
10487 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10488 
  )
10489 
 
10490 
  def __init__(self, success=None,):
10491 
    self.success = success
10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 0:
10503 
        if ftype == TType.LIST:
10504 
          self.success = []
10505 
          (_etype168, _size165) = iprot.readListBegin()
10506 
          for _i169 in xrange(_size165):
10507 
            _elem170 = iprot.readString();
10508 
            self.success.append(_elem170)
10509 
          iprot.readListEnd()
10510 
        else:
10511 
          iprot.skip(ftype)
10512 
      else:
10513 
        iprot.skip(ftype)
10514 
      iprot.readFieldEnd()
10515 
    iprot.readStructEnd()
10516 
 
10517 
  def write(self, oprot):
10518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10520 
      return
10521 
    oprot.writeStructBegin('getAllBanners_result')
10522 
    if self.success is not None:
10523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10524 
      oprot.writeListBegin(TType.STRING, len(self.success))
10525 
      for iter171 in self.success:
10526 
        oprot.writeString(iter171)
10527 
      oprot.writeListEnd()
10528 
      oprot.writeFieldEnd()
10529 
    oprot.writeFieldStop()
10530 
    oprot.writeStructEnd()
10531 
 
10532 
  def validate(self):
10533 
    return
10534 
 
10535 
 
10536 
  def __repr__(self):
10537 
    L = ['%s=%r' % (key, value)
10538 
      for key, value in self.__dict__.iteritems()]
10539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10540 
 
10541 
  def __eq__(self, other):
10542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10543 
 
10544 
  def __ne__(self, other):
10545 
    return not (self == other)
10546 
 
10547 
class deleteBanner_args:
10548 
  """
10549 
  Attributes:
10550 
   - bannerName
10551 
  """
10552 
 
10553 
  thrift_spec = (
10554 
    None, # 0
10555 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10556 
  )
10557 
 
10558 
  def __init__(self, bannerName=None,):
10559 
    self.bannerName = bannerName
10560 
 
10561 
  def read(self, iprot):
10562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10564 
      return
10565 
    iprot.readStructBegin()
10566 
    while True:
10567 
      (fname, ftype, fid) = iprot.readFieldBegin()
10568 
      if ftype == TType.STOP:
10569 
        break
10570 
      if fid == 1:
10571 
        if ftype == TType.STRING:
10572 
          self.bannerName = iprot.readString();
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      else:
10576 
        iprot.skip(ftype)
10577 
      iprot.readFieldEnd()
10578 
    iprot.readStructEnd()
10579 
 
10580 
  def write(self, oprot):
10581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10583 
      return
10584 
    oprot.writeStructBegin('deleteBanner_args')
10585 
    if self.bannerName is not None:
10586 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10587 
      oprot.writeString(self.bannerName)
10588 
      oprot.writeFieldEnd()
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
10592 
  def validate(self):
10593 
    return
10594 
 
10595 
 
10596 
  def __repr__(self):
10597 
    L = ['%s=%r' % (key, value)
10598 
      for key, value in self.__dict__.iteritems()]
10599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10600 
 
10601 
  def __eq__(self, other):
10602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10603 
 
10604 
  def __ne__(self, other):
10605 
    return not (self == other)
10606 
 
10607 
class deleteBanner_result:
10608 
  """
10609 
  Attributes:
10610 
   - success
10611 
  """
10612 
 
10613 
  thrift_spec = (
10614 
    (0, TType.BOOL, 'success', None, None, ), # 0
10615 
  )
10616 
 
10617 
  def __init__(self, success=None,):
10618 
    self.success = success
10619 
 
10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
10629 
      if fid == 0:
10630 
        if ftype == TType.BOOL:
10631 
          self.success = iprot.readBool();
10632 
        else:
10633 
          iprot.skip(ftype)
10634 
      else:
10635 
        iprot.skip(ftype)
10636 
      iprot.readFieldEnd()
10637 
    iprot.readStructEnd()
10638 
 
10639 
  def write(self, oprot):
10640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10642 
      return
10643 
    oprot.writeStructBegin('deleteBanner_result')
10644 
    if self.success is not None:
10645 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10646 
      oprot.writeBool(self.success)
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class getBannerDetails_args:
10667 
  """
10668 
  Attributes:
10669 
   - bannerName
10670 
  """
10671 
 
10672 
  thrift_spec = (
10673 
    None, # 0
10674 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10675 
  )
10676 
 
10677 
  def __init__(self, bannerName=None,):
10678 
    self.bannerName = bannerName
10679 
 
10680 
  def read(self, iprot):
10681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10683 
      return
10684 
    iprot.readStructBegin()
10685 
    while True:
10686 
      (fname, ftype, fid) = iprot.readFieldBegin()
10687 
      if ftype == TType.STOP:
10688 
        break
10689 
      if fid == 1:
10690 
        if ftype == TType.STRING:
10691 
          self.bannerName = iprot.readString();
10692 
        else:
10693 
          iprot.skip(ftype)
10694 
      else:
10695 
        iprot.skip(ftype)
10696 
      iprot.readFieldEnd()
10697 
    iprot.readStructEnd()
10698 
 
10699 
  def write(self, oprot):
10700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10702 
      return
10703 
    oprot.writeStructBegin('getBannerDetails_args')
10704 
    if self.bannerName is not None:
10705 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10706 
      oprot.writeString(self.bannerName)
10707 
      oprot.writeFieldEnd()
10708 
    oprot.writeFieldStop()
10709 
    oprot.writeStructEnd()
10710 
 
10711 
  def validate(self):
10712 
    return
10713 
 
10714 
 
10715 
  def __repr__(self):
10716 
    L = ['%s=%r' % (key, value)
10717 
      for key, value in self.__dict__.iteritems()]
10718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10719 
 
10720 
  def __eq__(self, other):
10721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10722 
 
10723 
  def __ne__(self, other):
10724 
    return not (self == other)
10725 
 
10726 
class getBannerDetails_result:
10727 
  """
10728 
  Attributes:
10729 
   - success
10730 
  """
10731 
 
10732 
  thrift_spec = (
10733 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10734 
  )
10735 
 
10736 
  def __init__(self, success=None,):
10737 
    self.success = success
10738 
 
10739 
  def read(self, iprot):
10740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10742 
      return
10743 
    iprot.readStructBegin()
10744 
    while True:
10745 
      (fname, ftype, fid) = iprot.readFieldBegin()
10746 
      if ftype == TType.STOP:
10747 
        break
10748 
      if fid == 0:
10749 
        if ftype == TType.STRUCT:
10750 
          self.success = Banner()
10751 
          self.success.read(iprot)
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      else:
10755 
        iprot.skip(ftype)
10756 
      iprot.readFieldEnd()
10757 
    iprot.readStructEnd()
10758 
 
10759 
  def write(self, oprot):
10760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10762 
      return
10763 
    oprot.writeStructBegin('getBannerDetails_result')
10764 
    if self.success is not None:
10765 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10766 
      self.success.write(oprot)
10767 
      oprot.writeFieldEnd()
10768 
    oprot.writeFieldStop()
10769 
    oprot.writeStructEnd()
10770 
 
10771 
  def validate(self):
10772 
    return
10773 
 
10774 
 
10775 
  def __repr__(self):
10776 
    L = ['%s=%r' % (key, value)
10777 
      for key, value in self.__dict__.iteritems()]
10778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10779 
 
10780 
  def __eq__(self, other):
10781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10782 
 
10783 
  def __ne__(self, other):
10784 
    return not (self == other)
10785 
 
10786 
class getActiveBanners_args:
10787 
 
10788 
  thrift_spec = (
10789 
  )
10790 
 
10791 
  def read(self, iprot):
10792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10794 
      return
10795 
    iprot.readStructBegin()
10796 
    while True:
10797 
      (fname, ftype, fid) = iprot.readFieldBegin()
10798 
      if ftype == TType.STOP:
10799 
        break
10800 
      else:
10801 
        iprot.skip(ftype)
10802 
      iprot.readFieldEnd()
10803 
    iprot.readStructEnd()
10804 
 
10805 
  def write(self, oprot):
10806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10808 
      return
10809 
    oprot.writeStructBegin('getActiveBanners_args')
10810 
    oprot.writeFieldStop()
10811 
    oprot.writeStructEnd()
10812 
 
10813 
  def validate(self):
10814 
    return
10815 
 
10816 
 
10817 
  def __repr__(self):
10818 
    L = ['%s=%r' % (key, value)
10819 
      for key, value in self.__dict__.iteritems()]
10820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10821 
 
10822 
  def __eq__(self, other):
10823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10824 
 
10825 
  def __ne__(self, other):
10826 
    return not (self == other)
10827 
 
10828 
class getActiveBanners_result:
10829 
  """
10830 
  Attributes:
10831 
   - success
10832 
  """
10833 
 
10834 
  thrift_spec = (
10835 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
10836 
  )
10837 
 
10838 
  def __init__(self, success=None,):
10839 
    self.success = success
10840 
 
10841 
  def read(self, iprot):
10842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10844 
      return
10845 
    iprot.readStructBegin()
10846 
    while True:
10847 
      (fname, ftype, fid) = iprot.readFieldBegin()
10848 
      if ftype == TType.STOP:
10849 
        break
10850 
      if fid == 0:
10851 
        if ftype == TType.LIST:
10852 
          self.success = []
10853 
          (_etype175, _size172) = iprot.readListBegin()
10854 
          for _i176 in xrange(_size172):
10855 
            _elem177 = Banner()
10856 
            _elem177.read(iprot)
10857 
            self.success.append(_elem177)
10858 
          iprot.readListEnd()
10859 
        else:
10860 
          iprot.skip(ftype)
10861 
      else:
10862 
        iprot.skip(ftype)
10863 
      iprot.readFieldEnd()
10864 
    iprot.readStructEnd()
10865 
 
10866 
  def write(self, oprot):
10867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10869 
      return
10870 
    oprot.writeStructBegin('getActiveBanners_result')
10871 
    if self.success is not None:
10872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10874 
      for iter178 in self.success:
10875 
        iter178.write(oprot)
10876 
      oprot.writeListEnd()
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
6849 kshitij.so 10896 
class addBannerMap_args:
10897 
  """
10898 
  Attributes:
10899 
   - bannerName
10900 
   - mapLink
10901 
   - coordinates
10902 
  """
10903 
 
10904 
  thrift_spec = (
10905 
    None, # 0
10906 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10907 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
10908 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
10909 
  )
10910 
 
10911 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
10912 
    self.bannerName = bannerName
10913 
    self.mapLink = mapLink
10914 
    self.coordinates = coordinates
10915 
 
10916 
  def read(self, iprot):
10917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10919 
      return
10920 
    iprot.readStructBegin()
10921 
    while True:
10922 
      (fname, ftype, fid) = iprot.readFieldBegin()
10923 
      if ftype == TType.STOP:
10924 
        break
10925 
      if fid == 1:
10926 
        if ftype == TType.STRING:
10927 
          self.bannerName = iprot.readString();
10928 
        else:
10929 
          iprot.skip(ftype)
10930 
      elif fid == 2:
10931 
        if ftype == TType.STRING:
10932 
          self.mapLink = iprot.readString();
10933 
        else:
10934 
          iprot.skip(ftype)
10935 
      elif fid == 3:
10936 
        if ftype == TType.STRING:
10937 
          self.coordinates = iprot.readString();
10938 
        else:
10939 
          iprot.skip(ftype)
10940 
      else:
10941 
        iprot.skip(ftype)
10942 
      iprot.readFieldEnd()
10943 
    iprot.readStructEnd()
10944 
 
10945 
  def write(self, oprot):
10946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10948 
      return
10949 
    oprot.writeStructBegin('addBannerMap_args')
10950 
    if self.bannerName is not None:
10951 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10952 
      oprot.writeString(self.bannerName)
10953 
      oprot.writeFieldEnd()
10954 
    if self.mapLink is not None:
10955 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
10956 
      oprot.writeString(self.mapLink)
10957 
      oprot.writeFieldEnd()
10958 
    if self.coordinates is not None:
10959 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
10960 
      oprot.writeString(self.coordinates)
10961 
      oprot.writeFieldEnd()
10962 
    oprot.writeFieldStop()
10963 
    oprot.writeStructEnd()
10964 
 
10965 
  def validate(self):
10966 
    return
10967 
 
10968 
 
10969 
  def __repr__(self):
10970 
    L = ['%s=%r' % (key, value)
10971 
      for key, value in self.__dict__.iteritems()]
10972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10973 
 
10974 
  def __eq__(self, other):
10975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10976 
 
10977 
  def __ne__(self, other):
10978 
    return not (self == other)
10979 
 
10980 
class addBannerMap_result:
10981 
  """
10982 
  Attributes:
10983 
   - success
10984 
  """
10985 
 
10986 
  thrift_spec = (
10987 
    (0, TType.BOOL, 'success', None, None, ), # 0
10988 
  )
10989 
 
10990 
  def __init__(self, success=None,):
10991 
    self.success = success
10992 
 
10993 
  def read(self, iprot):
10994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10996 
      return
10997 
    iprot.readStructBegin()
10998 
    while True:
10999 
      (fname, ftype, fid) = iprot.readFieldBegin()
11000 
      if ftype == TType.STOP:
11001 
        break
11002 
      if fid == 0:
11003 
        if ftype == TType.BOOL:
11004 
          self.success = iprot.readBool();
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      else:
11008 
        iprot.skip(ftype)
11009 
      iprot.readFieldEnd()
11010 
    iprot.readStructEnd()
11011 
 
11012 
  def write(self, oprot):
11013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11015 
      return
11016 
    oprot.writeStructBegin('addBannerMap_result')
11017 
    if self.success is not None:
11018 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11019 
      oprot.writeBool(self.success)
11020 
      oprot.writeFieldEnd()
11021 
    oprot.writeFieldStop()
11022 
    oprot.writeStructEnd()
11023 
 
11024 
  def validate(self):
11025 
    return
11026 
 
11027 
 
11028 
  def __repr__(self):
11029 
    L = ['%s=%r' % (key, value)
11030 
      for key, value in self.__dict__.iteritems()]
11031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11032 
 
11033 
  def __eq__(self, other):
11034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11035 
 
11036 
  def __ne__(self, other):
11037 
    return not (self == other)
11038 
 
11039 
class deleteBannerMap_args:
11040 
  """
11041 
  Attributes:
11042 
   - bannerName
11043 
  """
11044 
 
11045 
  thrift_spec = (
11046 
    None, # 0
11047 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11048 
  )
11049 
 
11050 
  def __init__(self, bannerName=None,):
11051 
    self.bannerName = bannerName
11052 
 
11053 
  def read(self, iprot):
11054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11056 
      return
11057 
    iprot.readStructBegin()
11058 
    while True:
11059 
      (fname, ftype, fid) = iprot.readFieldBegin()
11060 
      if ftype == TType.STOP:
11061 
        break
11062 
      if fid == 1:
11063 
        if ftype == TType.STRING:
11064 
          self.bannerName = iprot.readString();
11065 
        else:
11066 
          iprot.skip(ftype)
11067 
      else:
11068 
        iprot.skip(ftype)
11069 
      iprot.readFieldEnd()
11070 
    iprot.readStructEnd()
11071 
 
11072 
  def write(self, oprot):
11073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11075 
      return
11076 
    oprot.writeStructBegin('deleteBannerMap_args')
11077 
    if self.bannerName is not None:
11078 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11079 
      oprot.writeString(self.bannerName)
11080 
      oprot.writeFieldEnd()
11081 
    oprot.writeFieldStop()
11082 
    oprot.writeStructEnd()
11083 
 
11084 
  def validate(self):
11085 
    return
11086 
 
11087 
 
11088 
  def __repr__(self):
11089 
    L = ['%s=%r' % (key, value)
11090 
      for key, value in self.__dict__.iteritems()]
11091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11092 
 
11093 
  def __eq__(self, other):
11094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11095 
 
11096 
  def __ne__(self, other):
11097 
    return not (self == other)
11098 
 
11099 
class deleteBannerMap_result:
11100 
  """
11101 
  Attributes:
11102 
   - success
11103 
  """
11104 
 
11105 
  thrift_spec = (
11106 
    (0, TType.BOOL, 'success', None, None, ), # 0
11107 
  )
11108 
 
11109 
  def __init__(self, success=None,):
11110 
    self.success = success
11111 
 
11112 
  def read(self, iprot):
11113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11115 
      return
11116 
    iprot.readStructBegin()
11117 
    while True:
11118 
      (fname, ftype, fid) = iprot.readFieldBegin()
11119 
      if ftype == TType.STOP:
11120 
        break
11121 
      if fid == 0:
11122 
        if ftype == TType.BOOL:
11123 
          self.success = iprot.readBool();
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      else:
11127 
        iprot.skip(ftype)
11128 
      iprot.readFieldEnd()
11129 
    iprot.readStructEnd()
11130 
 
11131 
  def write(self, oprot):
11132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11134 
      return
11135 
    oprot.writeStructBegin('deleteBannerMap_result')
11136 
    if self.success is not None:
11137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11138 
      oprot.writeBool(self.success)
11139 
      oprot.writeFieldEnd()
11140 
    oprot.writeFieldStop()
11141 
    oprot.writeStructEnd()
11142 
 
11143 
  def validate(self):
11144 
    return
11145 
 
11146 
 
11147 
  def __repr__(self):
11148 
    L = ['%s=%r' % (key, value)
11149 
      for key, value in self.__dict__.iteritems()]
11150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11151 
 
11152 
  def __eq__(self, other):
11153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11154 
 
11155 
  def __ne__(self, other):
11156 
    return not (self == other)
11157 
 
11158 
class getBannerMapDetails_args:
11159 
  """
11160 
  Attributes:
11161 
   - bannerName
11162 
  """
11163 
 
11164 
  thrift_spec = (
11165 
    None, # 0
11166 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11167 
  )
11168 
 
11169 
  def __init__(self, bannerName=None,):
11170 
    self.bannerName = bannerName
11171 
 
11172 
  def read(self, iprot):
11173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11175 
      return
11176 
    iprot.readStructBegin()
11177 
    while True:
11178 
      (fname, ftype, fid) = iprot.readFieldBegin()
11179 
      if ftype == TType.STOP:
11180 
        break
11181 
      if fid == 1:
11182 
        if ftype == TType.STRING:
11183 
          self.bannerName = iprot.readString();
11184 
        else:
11185 
          iprot.skip(ftype)
11186 
      else:
11187 
        iprot.skip(ftype)
11188 
      iprot.readFieldEnd()
11189 
    iprot.readStructEnd()
11190 
 
11191 
  def write(self, oprot):
11192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11194 
      return
11195 
    oprot.writeStructBegin('getBannerMapDetails_args')
11196 
    if self.bannerName is not None:
11197 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11198 
      oprot.writeString(self.bannerName)
11199 
      oprot.writeFieldEnd()
11200 
    oprot.writeFieldStop()
11201 
    oprot.writeStructEnd()
11202 
 
11203 
  def validate(self):
11204 
    return
11205 
 
11206 
 
11207 
  def __repr__(self):
11208 
    L = ['%s=%r' % (key, value)
11209 
      for key, value in self.__dict__.iteritems()]
11210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11211 
 
11212 
  def __eq__(self, other):
11213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11214 
 
11215 
  def __ne__(self, other):
11216 
    return not (self == other)
11217 
 
11218 
class getBannerMapDetails_result:
11219 
  """
11220 
  Attributes:
11221 
   - success
11222 
  """
11223 
 
11224 
  thrift_spec = (
11225 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11226 
  )
11227 
 
11228 
  def __init__(self, success=None,):
11229 
    self.success = success
11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 0:
11241 
        if ftype == TType.LIST:
11242 
          self.success = []
6850 kshitij.so 11243 
          (_etype182, _size179) = iprot.readListBegin()
11244 
          for _i183 in xrange(_size179):
11245 
            _elem184 = BannerMap()
11246 
            _elem184.read(iprot)
11247 
            self.success.append(_elem184)
6849 kshitij.so 11248 
          iprot.readListEnd()
11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      else:
11252 
        iprot.skip(ftype)
11253 
      iprot.readFieldEnd()
11254 
    iprot.readStructEnd()
11255 
 
11256 
  def write(self, oprot):
11257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11259 
      return
11260 
    oprot.writeStructBegin('getBannerMapDetails_result')
11261 
    if self.success is not None:
11262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11264 
      for iter185 in self.success:
11265 
        iter185.write(oprot)
6849 kshitij.so 11266 
      oprot.writeListEnd()
11267 
      oprot.writeFieldEnd()
11268 
    oprot.writeFieldStop()
11269 
    oprot.writeStructEnd()
11270 
 
11271 
  def validate(self):
11272 
    return
11273 
 
11274 
 
11275 
  def __repr__(self):
11276 
    L = ['%s=%r' % (key, value)
11277 
      for key, value in self.__dict__.iteritems()]
11278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11279 
 
11280 
  def __eq__(self, other):
11281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11282 
 
11283 
  def __ne__(self, other):
11284 
    return not (self == other)
11285 
 
5944 mandeep.dh 11286 
class deleteSimilarItem_args:
11287 
  """
11288 
  Attributes:
11289 
   - itemId
11290 
   - catalogItemId
11291 
  """
11292 
 
11293 
  thrift_spec = (
11294 
    None, # 0
11295 
    (1, TType.I64, 'itemId', None, None, ), # 1
11296 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11297 
  )
11298 
 
11299 
  def __init__(self, itemId=None, catalogItemId=None,):
11300 
    self.itemId = itemId
11301 
    self.catalogItemId = catalogItemId
11302 
 
11303 
  def read(self, iprot):
11304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11306 
      return
11307 
    iprot.readStructBegin()
11308 
    while True:
11309 
      (fname, ftype, fid) = iprot.readFieldBegin()
11310 
      if ftype == TType.STOP:
11311 
        break
11312 
      if fid == 1:
11313 
        if ftype == TType.I64:
11314 
          self.itemId = iprot.readI64();
11315 
        else:
11316 
          iprot.skip(ftype)
11317 
      elif fid == 2:
11318 
        if ftype == TType.I64:
11319 
          self.catalogItemId = iprot.readI64();
11320 
        else:
11321 
          iprot.skip(ftype)
11322 
      else:
11323 
        iprot.skip(ftype)
11324 
      iprot.readFieldEnd()
11325 
    iprot.readStructEnd()
11326 
 
11327 
  def write(self, oprot):
11328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11330 
      return
11331 
    oprot.writeStructBegin('deleteSimilarItem_args')
11332 
    if self.itemId is not None:
11333 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11334 
      oprot.writeI64(self.itemId)
11335 
      oprot.writeFieldEnd()
11336 
    if self.catalogItemId is not None:
11337 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11338 
      oprot.writeI64(self.catalogItemId)
11339 
      oprot.writeFieldEnd()
11340 
    oprot.writeFieldStop()
11341 
    oprot.writeStructEnd()
11342 
 
11343 
  def validate(self):
11344 
    return
11345 
 
11346 
 
11347 
  def __repr__(self):
11348 
    L = ['%s=%r' % (key, value)
11349 
      for key, value in self.__dict__.iteritems()]
11350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11351 
 
11352 
  def __eq__(self, other):
11353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11354 
 
11355 
  def __ne__(self, other):
11356 
    return not (self == other)
11357 
 
11358 
class deleteSimilarItem_result:
11359 
  """
11360 
  Attributes:
11361 
   - success
11362 
   - cex
11363 
  """
11364 
 
11365 
  thrift_spec = (
11366 
    (0, TType.BOOL, 'success', None, None, ), # 0
11367 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11368 
  )
11369 
 
11370 
  def __init__(self, success=None, cex=None,):
11371 
    self.success = success
11372 
    self.cex = cex
11373 
 
11374 
  def read(self, iprot):
11375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11377 
      return
11378 
    iprot.readStructBegin()
11379 
    while True:
11380 
      (fname, ftype, fid) = iprot.readFieldBegin()
11381 
      if ftype == TType.STOP:
11382 
        break
11383 
      if fid == 0:
11384 
        if ftype == TType.BOOL:
11385 
          self.success = iprot.readBool();
11386 
        else:
11387 
          iprot.skip(ftype)
11388 
      elif fid == 1:
11389 
        if ftype == TType.STRUCT:
11390 
          self.cex = CatalogServiceException()
11391 
          self.cex.read(iprot)
11392 
        else:
11393 
          iprot.skip(ftype)
11394 
      else:
11395 
        iprot.skip(ftype)
11396 
      iprot.readFieldEnd()
11397 
    iprot.readStructEnd()
11398 
 
11399 
  def write(self, oprot):
11400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11402 
      return
11403 
    oprot.writeStructBegin('deleteSimilarItem_result')
11404 
    if self.success is not None:
11405 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11406 
      oprot.writeBool(self.success)
11407 
      oprot.writeFieldEnd()
11408 
    if self.cex is not None:
11409 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11410 
      self.cex.write(oprot)
11411 
      oprot.writeFieldEnd()
11412 
    oprot.writeFieldStop()
11413 
    oprot.writeStructEnd()
11414 
 
11415 
  def validate(self):
11416 
    return
11417 
 
11418 
 
11419 
  def __repr__(self):
11420 
    L = ['%s=%r' % (key, value)
11421 
      for key, value in self.__dict__.iteritems()]
11422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11423 
 
11424 
  def __eq__(self, other):
11425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11426 
 
11427 
  def __ne__(self, other):
11428 
    return not (self == other)
11429 
 
11430 
class checkSimilarItem_args:
11431 
  """
11432 
  Attributes:
11433 
   - brand
11434 
   - modelNumber
11435 
   - modelName
11436 
   - color
11437 
  """
11438 
 
11439 
  thrift_spec = (
11440 
    None, # 0
11441 
    (1, TType.STRING, 'brand', None, None, ), # 1
11442 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11443 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11444 
    (4, TType.STRING, 'color', None, None, ), # 4
11445 
  )
11446 
 
11447 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11448 
    self.brand = brand
11449 
    self.modelNumber = modelNumber
11450 
    self.modelName = modelName
11451 
    self.color = color
11452 
 
11453 
  def read(self, iprot):
11454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11456 
      return
11457 
    iprot.readStructBegin()
11458 
    while True:
11459 
      (fname, ftype, fid) = iprot.readFieldBegin()
11460 
      if ftype == TType.STOP:
11461 
        break
11462 
      if fid == 1:
11463 
        if ftype == TType.STRING:
11464 
          self.brand = iprot.readString();
11465 
        else:
11466 
          iprot.skip(ftype)
11467 
      elif fid == 2:
11468 
        if ftype == TType.STRING:
11469 
          self.modelNumber = iprot.readString();
11470 
        else:
11471 
          iprot.skip(ftype)
11472 
      elif fid == 3:
11473 
        if ftype == TType.STRING:
11474 
          self.modelName = iprot.readString();
11475 
        else:
11476 
          iprot.skip(ftype)
11477 
      elif fid == 4:
11478 
        if ftype == TType.STRING:
11479 
          self.color = iprot.readString();
11480 
        else:
11481 
          iprot.skip(ftype)
11482 
      else:
11483 
        iprot.skip(ftype)
11484 
      iprot.readFieldEnd()
11485 
    iprot.readStructEnd()
11486 
 
11487 
  def write(self, oprot):
11488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11490 
      return
11491 
    oprot.writeStructBegin('checkSimilarItem_args')
11492 
    if self.brand is not None:
11493 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11494 
      oprot.writeString(self.brand)
11495 
      oprot.writeFieldEnd()
11496 
    if self.modelNumber is not None:
11497 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11498 
      oprot.writeString(self.modelNumber)
11499 
      oprot.writeFieldEnd()
11500 
    if self.modelName is not None:
11501 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11502 
      oprot.writeString(self.modelName)
11503 
      oprot.writeFieldEnd()
11504 
    if self.color is not None:
11505 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11506 
      oprot.writeString(self.color)
11507 
      oprot.writeFieldEnd()
11508 
    oprot.writeFieldStop()
11509 
    oprot.writeStructEnd()
11510 
 
11511 
  def validate(self):
11512 
    return
11513 
 
11514 
 
11515 
  def __repr__(self):
11516 
    L = ['%s=%r' % (key, value)
11517 
      for key, value in self.__dict__.iteritems()]
11518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11519 
 
11520 
  def __eq__(self, other):
11521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11522 
 
11523 
  def __ne__(self, other):
11524 
    return not (self == other)
11525 
 
11526 
class checkSimilarItem_result:
11527 
  """
11528 
  Attributes:
11529 
   - success
11530 
  """
11531 
 
11532 
  thrift_spec = (
11533 
    (0, TType.I64, 'success', None, None, ), # 0
11534 
  )
11535 
 
11536 
  def __init__(self, success=None,):
11537 
    self.success = success
11538 
 
11539 
  def read(self, iprot):
11540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11542 
      return
11543 
    iprot.readStructBegin()
11544 
    while True:
11545 
      (fname, ftype, fid) = iprot.readFieldBegin()
11546 
      if ftype == TType.STOP:
11547 
        break
11548 
      if fid == 0:
11549 
        if ftype == TType.I64:
11550 
          self.success = iprot.readI64();
11551 
        else:
11552 
          iprot.skip(ftype)
11553 
      else:
11554 
        iprot.skip(ftype)
11555 
      iprot.readFieldEnd()
11556 
    iprot.readStructEnd()
11557 
 
11558 
  def write(self, oprot):
11559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11561 
      return
11562 
    oprot.writeStructBegin('checkSimilarItem_result')
11563 
    if self.success is not None:
11564 
      oprot.writeFieldBegin('success', TType.I64, 0)
11565 
      oprot.writeI64(self.success)
11566 
      oprot.writeFieldEnd()
11567 
    oprot.writeFieldStop()
11568 
    oprot.writeStructEnd()
11569 
 
11570 
  def validate(self):
11571 
    return
11572 
 
11573 
 
11574 
  def __repr__(self):
11575 
    L = ['%s=%r' % (key, value)
11576 
      for key, value in self.__dict__.iteritems()]
11577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11578 
 
11579 
  def __eq__(self, other):
11580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11581 
 
11582 
  def __ne__(self, other):
11583 
    return not (self == other)
11584 
 
11585 
class validateRiskyStatus_args:
11586 
  """
11587 
  Attributes:
11588 
   - itemId
11589 
  """
11590 
 
11591 
  thrift_spec = (
11592 
    None, # 0
11593 
    (1, TType.I64, 'itemId', None, None, ), # 1
11594 
  )
11595 
 
11596 
  def __init__(self, itemId=None,):
11597 
    self.itemId = itemId
11598 
 
11599 
  def read(self, iprot):
11600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11602 
      return
11603 
    iprot.readStructBegin()
11604 
    while True:
11605 
      (fname, ftype, fid) = iprot.readFieldBegin()
11606 
      if ftype == TType.STOP:
11607 
        break
11608 
      if fid == 1:
11609 
        if ftype == TType.I64:
11610 
          self.itemId = iprot.readI64();
11611 
        else:
11612 
          iprot.skip(ftype)
11613 
      else:
11614 
        iprot.skip(ftype)
11615 
      iprot.readFieldEnd()
11616 
    iprot.readStructEnd()
11617 
 
11618 
  def write(self, oprot):
11619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11621 
      return
11622 
    oprot.writeStructBegin('validateRiskyStatus_args')
11623 
    if self.itemId is not None:
11624 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11625 
      oprot.writeI64(self.itemId)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
11645 
class validateRiskyStatus_result:
11646 
 
11647 
  thrift_spec = (
11648 
  )
11649 
 
11650 
  def read(self, iprot):
11651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11653 
      return
11654 
    iprot.readStructBegin()
11655 
    while True:
11656 
      (fname, ftype, fid) = iprot.readFieldBegin()
11657 
      if ftype == TType.STOP:
11658 
        break
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('validateRiskyStatus_result')
11669 
    oprot.writeFieldStop()
11670 
    oprot.writeStructEnd()
11671 
 
11672 
  def validate(self):
11673 
    return
11674 
 
11675 
 
11676 
  def __repr__(self):
11677 
    L = ['%s=%r' % (key, value)
11678 
      for key, value in self.__dict__.iteritems()]
11679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11680 
 
11681 
  def __eq__(self, other):
11682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11683 
 
11684 
  def __ne__(self, other):
11685 
    return not (self == other)
11686 
 
11687 
class changeItemRiskyFlag_args:
11688 
  """
11689 
  Attributes:
11690 
   - itemId
11691 
   - risky
11692 
  """
11693 
 
11694 
  thrift_spec = (
11695 
    None, # 0
11696 
    (1, TType.I64, 'itemId', None, None, ), # 1
11697 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11698 
  )
11699 
 
11700 
  def __init__(self, itemId=None, risky=None,):
11701 
    self.itemId = itemId
11702 
    self.risky = risky
11703 
 
11704 
  def read(self, iprot):
11705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11707 
      return
11708 
    iprot.readStructBegin()
11709 
    while True:
11710 
      (fname, ftype, fid) = iprot.readFieldBegin()
11711 
      if ftype == TType.STOP:
11712 
        break
11713 
      if fid == 1:
11714 
        if ftype == TType.I64:
11715 
          self.itemId = iprot.readI64();
11716 
        else:
11717 
          iprot.skip(ftype)
11718 
      elif fid == 2:
11719 
        if ftype == TType.BOOL:
11720 
          self.risky = iprot.readBool();
11721 
        else:
11722 
          iprot.skip(ftype)
11723 
      else:
11724 
        iprot.skip(ftype)
11725 
      iprot.readFieldEnd()
11726 
    iprot.readStructEnd()
11727 
 
11728 
  def write(self, oprot):
11729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11731 
      return
11732 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11733 
    if self.itemId is not None:
11734 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11735 
      oprot.writeI64(self.itemId)
11736 
      oprot.writeFieldEnd()
11737 
    if self.risky is not None:
11738 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11739 
      oprot.writeBool(self.risky)
11740 
      oprot.writeFieldEnd()
11741 
    oprot.writeFieldStop()
11742 
    oprot.writeStructEnd()
11743 
 
11744 
  def validate(self):
11745 
    return
11746 
 
11747 
 
11748 
  def __repr__(self):
11749 
    L = ['%s=%r' % (key, value)
11750 
      for key, value in self.__dict__.iteritems()]
11751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11752 
 
11753 
  def __eq__(self, other):
11754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11755 
 
11756 
  def __ne__(self, other):
11757 
    return not (self == other)
11758 
 
11759 
class changeItemRiskyFlag_result:
11760 
 
11761 
  thrift_spec = (
11762 
  )
11763 
 
11764 
  def read(self, iprot):
11765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11767 
      return
11768 
    iprot.readStructBegin()
11769 
    while True:
11770 
      (fname, ftype, fid) = iprot.readFieldBegin()
11771 
      if ftype == TType.STOP:
11772 
        break
11773 
      else:
11774 
        iprot.skip(ftype)
11775 
      iprot.readFieldEnd()
11776 
    iprot.readStructEnd()
11777 
 
11778 
  def write(self, oprot):
11779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11781 
      return
11782 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
11801 
class getItemsByRiskyFlag_args:
11802 
 
11803 
  thrift_spec = (
11804 
  )
11805 
 
11806 
  def read(self, iprot):
11807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11809 
      return
11810 
    iprot.readStructBegin()
11811 
    while True:
11812 
      (fname, ftype, fid) = iprot.readFieldBegin()
11813 
      if ftype == TType.STOP:
11814 
        break
11815 
      else:
11816 
        iprot.skip(ftype)
11817 
      iprot.readFieldEnd()
11818 
    iprot.readStructEnd()
11819 
 
11820 
  def write(self, oprot):
11821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11823 
      return
11824 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
11825 
    oprot.writeFieldStop()
11826 
    oprot.writeStructEnd()
11827 
 
11828 
  def validate(self):
11829 
    return
11830 
 
11831 
 
11832 
  def __repr__(self):
11833 
    L = ['%s=%r' % (key, value)
11834 
      for key, value in self.__dict__.iteritems()]
11835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11836 
 
11837 
  def __eq__(self, other):
11838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11839 
 
11840 
  def __ne__(self, other):
11841 
    return not (self == other)
11842 
 
11843 
class getItemsByRiskyFlag_result:
11844 
  """
11845 
  Attributes:
11846 
   - success
11847 
  """
11848 
 
11849 
  thrift_spec = (
11850 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11851 
  )
11852 
 
11853 
  def __init__(self, success=None,):
11854 
    self.success = success
11855 
 
11856 
  def read(self, iprot):
11857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11859 
      return
11860 
    iprot.readStructBegin()
11861 
    while True:
11862 
      (fname, ftype, fid) = iprot.readFieldBegin()
11863 
      if ftype == TType.STOP:
11864 
        break
11865 
      if fid == 0:
11866 
        if ftype == TType.LIST:
11867 
          self.success = []
6850 kshitij.so 11868 
          (_etype189, _size186) = iprot.readListBegin()
11869 
          for _i190 in xrange(_size186):
11870 
            _elem191 = Item()
11871 
            _elem191.read(iprot)
11872 
            self.success.append(_elem191)
5944 mandeep.dh 11873 
          iprot.readListEnd()
11874 
        else:
11875 
          iprot.skip(ftype)
11876 
      else:
11877 
        iprot.skip(ftype)
11878 
      iprot.readFieldEnd()
11879 
    iprot.readStructEnd()
11880 
 
11881 
  def write(self, oprot):
11882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11884 
      return
11885 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
11886 
    if self.success is not None:
11887 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11888 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11889 
      for iter192 in self.success:
11890 
        iter192.write(oprot)
5944 mandeep.dh 11891 
      oprot.writeListEnd()
11892 
      oprot.writeFieldEnd()
11893 
    oprot.writeFieldStop()
11894 
    oprot.writeStructEnd()
11895 
 
11896 
  def validate(self):
11897 
    return
11898 
 
11899 
 
11900 
  def __repr__(self):
11901 
    L = ['%s=%r' % (key, value)
11902 
      for key, value in self.__dict__.iteritems()]
11903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11904 
 
11905 
  def __eq__(self, other):
11906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11907 
 
11908 
  def __ne__(self, other):
11909 
    return not (self == other)
11910 
 
11911 
class getItemsForMasterSheet_args:
11912 
  """
11913 
  Attributes:
11914 
   - category
11915 
   - brand
11916 
  """
11917 
 
11918 
  thrift_spec = (
11919 
    None, # 0
11920 
    (1, TType.STRING, 'category', None, None, ), # 1
11921 
    (2, TType.STRING, 'brand', None, None, ), # 2
11922 
  )
11923 
 
11924 
  def __init__(self, category=None, brand=None,):
11925 
    self.category = category
11926 
    self.brand = brand
11927 
 
11928 
  def read(self, iprot):
11929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11931 
      return
11932 
    iprot.readStructBegin()
11933 
    while True:
11934 
      (fname, ftype, fid) = iprot.readFieldBegin()
11935 
      if ftype == TType.STOP:
11936 
        break
11937 
      if fid == 1:
11938 
        if ftype == TType.STRING:
11939 
          self.category = iprot.readString();
11940 
        else:
11941 
          iprot.skip(ftype)
11942 
      elif fid == 2:
11943 
        if ftype == TType.STRING:
11944 
          self.brand = iprot.readString();
11945 
        else:
11946 
          iprot.skip(ftype)
11947 
      else:
11948 
        iprot.skip(ftype)
11949 
      iprot.readFieldEnd()
11950 
    iprot.readStructEnd()
11951 
 
11952 
  def write(self, oprot):
11953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11955 
      return
11956 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
11957 
    if self.category is not None:
11958 
      oprot.writeFieldBegin('category', TType.STRING, 1)
11959 
      oprot.writeString(self.category)
11960 
      oprot.writeFieldEnd()
11961 
    if self.brand is not None:
11962 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
11963 
      oprot.writeString(self.brand)
11964 
      oprot.writeFieldEnd()
11965 
    oprot.writeFieldStop()
11966 
    oprot.writeStructEnd()
11967 
 
11968 
  def validate(self):
11969 
    return
11970 
 
11971 
 
11972 
  def __repr__(self):
11973 
    L = ['%s=%r' % (key, value)
11974 
      for key, value in self.__dict__.iteritems()]
11975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11976 
 
11977 
  def __eq__(self, other):
11978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11979 
 
11980 
  def __ne__(self, other):
11981 
    return not (self == other)
11982 
 
11983 
class getItemsForMasterSheet_result:
11984 
  """
11985 
  Attributes:
11986 
   - success
11987 
  """
11988 
 
11989 
  thrift_spec = (
11990 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11991 
  )
11992 
 
11993 
  def __init__(self, success=None,):
11994 
    self.success = success
11995 
 
11996 
  def read(self, iprot):
11997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11999 
      return
12000 
    iprot.readStructBegin()
12001 
    while True:
12002 
      (fname, ftype, fid) = iprot.readFieldBegin()
12003 
      if ftype == TType.STOP:
12004 
        break
12005 
      if fid == 0:
12006 
        if ftype == TType.LIST:
12007 
          self.success = []
6850 kshitij.so 12008 
          (_etype196, _size193) = iprot.readListBegin()
12009 
          for _i197 in xrange(_size193):
12010 
            _elem198 = Item()
12011 
            _elem198.read(iprot)
12012 
            self.success.append(_elem198)
5944 mandeep.dh 12013 
          iprot.readListEnd()
12014 
        else:
12015 
          iprot.skip(ftype)
12016 
      else:
12017 
        iprot.skip(ftype)
12018 
      iprot.readFieldEnd()
12019 
    iprot.readStructEnd()
12020 
 
12021 
  def write(self, oprot):
12022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12024 
      return
12025 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12026 
    if self.success is not None:
12027 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12028 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12029 
      for iter199 in self.success:
12030 
        iter199.write(oprot)
5944 mandeep.dh 12031 
      oprot.writeListEnd()
12032 
      oprot.writeFieldEnd()
12033 
    oprot.writeFieldStop()
12034 
    oprot.writeStructEnd()
12035 
 
12036 
  def validate(self):
12037 
    return
12038 
 
12039 
 
12040 
  def __repr__(self):
12041 
    L = ['%s=%r' % (key, value)
12042 
      for key, value in self.__dict__.iteritems()]
12043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12044 
 
12045 
  def __eq__(self, other):
12046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12047 
 
12048 
  def __ne__(self, other):
12049 
    return not (self == other)
12050 
 
12051 
class getSimilarItemsCatalogIds_args:
12052 
  """
12053 
  Attributes:
12054 
   - beginIndex
12055 
   - totalItems
12056 
   - itemId
12057 
  """
12058 
 
12059 
  thrift_spec = (
12060 
    None, # 0
12061 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12062 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12063 
    (3, TType.I64, 'itemId', None, None, ), # 3
12064 
  )
12065 
 
12066 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12067 
    self.beginIndex = beginIndex
12068 
    self.totalItems = totalItems
12069 
    self.itemId = itemId
12070 
 
12071 
  def read(self, iprot):
12072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12074 
      return
12075 
    iprot.readStructBegin()
12076 
    while True:
12077 
      (fname, ftype, fid) = iprot.readFieldBegin()
12078 
      if ftype == TType.STOP:
12079 
        break
12080 
      if fid == 1:
12081 
        if ftype == TType.I64:
12082 
          self.beginIndex = iprot.readI64();
12083 
        else:
12084 
          iprot.skip(ftype)
12085 
      elif fid == 2:
12086 
        if ftype == TType.I64:
12087 
          self.totalItems = iprot.readI64();
12088 
        else:
12089 
          iprot.skip(ftype)
12090 
      elif fid == 3:
12091 
        if ftype == TType.I64:
12092 
          self.itemId = iprot.readI64();
12093 
        else:
12094 
          iprot.skip(ftype)
12095 
      else:
12096 
        iprot.skip(ftype)
12097 
      iprot.readFieldEnd()
12098 
    iprot.readStructEnd()
12099 
 
12100 
  def write(self, oprot):
12101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12103 
      return
12104 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12105 
    if self.beginIndex is not None:
12106 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12107 
      oprot.writeI64(self.beginIndex)
12108 
      oprot.writeFieldEnd()
12109 
    if self.totalItems is not None:
12110 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12111 
      oprot.writeI64(self.totalItems)
12112 
      oprot.writeFieldEnd()
12113 
    if self.itemId is not None:
12114 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12115 
      oprot.writeI64(self.itemId)
12116 
      oprot.writeFieldEnd()
12117 
    oprot.writeFieldStop()
12118 
    oprot.writeStructEnd()
12119 
 
12120 
  def validate(self):
12121 
    return
12122 
 
12123 
 
12124 
  def __repr__(self):
12125 
    L = ['%s=%r' % (key, value)
12126 
      for key, value in self.__dict__.iteritems()]
12127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12128 
 
12129 
  def __eq__(self, other):
12130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12131 
 
12132 
  def __ne__(self, other):
12133 
    return not (self == other)
12134 
 
12135 
class getSimilarItemsCatalogIds_result:
12136 
  """
12137 
  Attributes:
12138 
   - success
12139 
  """
12140 
 
12141 
  thrift_spec = (
12142 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12143 
  )
12144 
 
12145 
  def __init__(self, success=None,):
12146 
    self.success = success
12147 
 
12148 
  def read(self, iprot):
12149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12151 
      return
12152 
    iprot.readStructBegin()
12153 
    while True:
12154 
      (fname, ftype, fid) = iprot.readFieldBegin()
12155 
      if ftype == TType.STOP:
12156 
        break
12157 
      if fid == 0:
12158 
        if ftype == TType.LIST:
12159 
          self.success = []
6850 kshitij.so 12160 
          (_etype203, _size200) = iprot.readListBegin()
12161 
          for _i204 in xrange(_size200):
12162 
            _elem205 = iprot.readI64();
12163 
            self.success.append(_elem205)
5944 mandeep.dh 12164 
          iprot.readListEnd()
12165 
        else:
12166 
          iprot.skip(ftype)
12167 
      else:
12168 
        iprot.skip(ftype)
12169 
      iprot.readFieldEnd()
12170 
    iprot.readStructEnd()
12171 
 
12172 
  def write(self, oprot):
12173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12175 
      return
12176 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12177 
    if self.success is not None:
12178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12179 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12180 
      for iter206 in self.success:
12181 
        oprot.writeI64(iter206)
5944 mandeep.dh 12182 
      oprot.writeListEnd()
12183 
      oprot.writeFieldEnd()
12184 
    oprot.writeFieldStop()
12185 
    oprot.writeStructEnd()
12186 
 
12187 
  def validate(self):
12188 
    return
12189 
 
12190 
 
12191 
  def __repr__(self):
12192 
    L = ['%s=%r' % (key, value)
12193 
      for key, value in self.__dict__.iteritems()]
12194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12195 
 
12196 
  def __eq__(self, other):
12197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12198 
 
12199 
  def __ne__(self, other):
12200 
    return not (self == other)
12201 
 
12202 
class addProductNotification_args:
12203 
  """
12204 
  Attributes:
12205 
   - itemId
12206 
   - email
12207 
  """
12208 
 
12209 
  thrift_spec = None
12210 
  def __init__(self, itemId=None, email=None,):
12211 
    self.itemId = itemId
12212 
    self.email = email
12213 
 
12214 
  def read(self, iprot):
12215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12217 
      return
12218 
    iprot.readStructBegin()
12219 
    while True:
12220 
      (fname, ftype, fid) = iprot.readFieldBegin()
12221 
      if ftype == TType.STOP:
12222 
        break
12223 
      if fid == -1:
12224 
        if ftype == TType.I64:
12225 
          self.itemId = iprot.readI64();
12226 
        else:
12227 
          iprot.skip(ftype)
12228 
      elif fid == -2:
12229 
        if ftype == TType.STRING:
12230 
          self.email = iprot.readString();
12231 
        else:
12232 
          iprot.skip(ftype)
12233 
      else:
12234 
        iprot.skip(ftype)
12235 
      iprot.readFieldEnd()
12236 
    iprot.readStructEnd()
12237 
 
12238 
  def write(self, oprot):
12239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12241 
      return
12242 
    oprot.writeStructBegin('addProductNotification_args')
12243 
    if self.email is not None:
12244 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12245 
      oprot.writeString(self.email)
12246 
      oprot.writeFieldEnd()
12247 
    if self.itemId is not None:
12248 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12249 
      oprot.writeI64(self.itemId)
12250 
      oprot.writeFieldEnd()
12251 
    oprot.writeFieldStop()
12252 
    oprot.writeStructEnd()
12253 
 
12254 
  def validate(self):
12255 
    return
12256 
 
12257 
 
12258 
  def __repr__(self):
12259 
    L = ['%s=%r' % (key, value)
12260 
      for key, value in self.__dict__.iteritems()]
12261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12262 
 
12263 
  def __eq__(self, other):
12264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12265 
 
12266 
  def __ne__(self, other):
12267 
    return not (self == other)
12268 
 
12269 
class addProductNotification_result:
12270 
  """
12271 
  Attributes:
12272 
   - success
12273 
  """
12274 
 
12275 
  thrift_spec = (
12276 
    (0, TType.BOOL, 'success', None, None, ), # 0
12277 
  )
12278 
 
12279 
  def __init__(self, success=None,):
12280 
    self.success = success
12281 
 
12282 
  def read(self, iprot):
12283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12285 
      return
12286 
    iprot.readStructBegin()
12287 
    while True:
12288 
      (fname, ftype, fid) = iprot.readFieldBegin()
12289 
      if ftype == TType.STOP:
12290 
        break
12291 
      if fid == 0:
12292 
        if ftype == TType.BOOL:
12293 
          self.success = iprot.readBool();
12294 
        else:
12295 
          iprot.skip(ftype)
12296 
      else:
12297 
        iprot.skip(ftype)
12298 
      iprot.readFieldEnd()
12299 
    iprot.readStructEnd()
12300 
 
12301 
  def write(self, oprot):
12302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12304 
      return
12305 
    oprot.writeStructBegin('addProductNotification_result')
12306 
    if self.success is not None:
12307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12308 
      oprot.writeBool(self.success)
12309 
      oprot.writeFieldEnd()
12310 
    oprot.writeFieldStop()
12311 
    oprot.writeStructEnd()
12312 
 
12313 
  def validate(self):
12314 
    return
12315 
 
12316 
 
12317 
  def __repr__(self):
12318 
    L = ['%s=%r' % (key, value)
12319 
      for key, value in self.__dict__.iteritems()]
12320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12321 
 
12322 
  def __eq__(self, other):
12323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12324 
 
12325 
  def __ne__(self, other):
12326 
    return not (self == other)
12327 
 
12328 
class sendProductNotifications_args:
12329 
 
12330 
  thrift_spec = (
12331 
  )
12332 
 
12333 
  def read(self, iprot):
12334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12336 
      return
12337 
    iprot.readStructBegin()
12338 
    while True:
12339 
      (fname, ftype, fid) = iprot.readFieldBegin()
12340 
      if ftype == TType.STOP:
12341 
        break
12342 
      else:
12343 
        iprot.skip(ftype)
12344 
      iprot.readFieldEnd()
12345 
    iprot.readStructEnd()
12346 
 
12347 
  def write(self, oprot):
12348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12350 
      return
12351 
    oprot.writeStructBegin('sendProductNotifications_args')
12352 
    oprot.writeFieldStop()
12353 
    oprot.writeStructEnd()
12354 
 
12355 
  def validate(self):
12356 
    return
12357 
 
12358 
 
12359 
  def __repr__(self):
12360 
    L = ['%s=%r' % (key, value)
12361 
      for key, value in self.__dict__.iteritems()]
12362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12363 
 
12364 
  def __eq__(self, other):
12365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12366 
 
12367 
  def __ne__(self, other):
12368 
    return not (self == other)
12369 
 
12370 
class sendProductNotifications_result:
12371 
  """
12372 
  Attributes:
12373 
   - success
12374 
  """
12375 
 
12376 
  thrift_spec = (
12377 
    (0, TType.BOOL, 'success', None, None, ), # 0
12378 
  )
12379 
 
12380 
  def __init__(self, success=None,):
12381 
    self.success = success
12382 
 
12383 
  def read(self, iprot):
12384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12386 
      return
12387 
    iprot.readStructBegin()
12388 
    while True:
12389 
      (fname, ftype, fid) = iprot.readFieldBegin()
12390 
      if ftype == TType.STOP:
12391 
        break
12392 
      if fid == 0:
12393 
        if ftype == TType.BOOL:
12394 
          self.success = iprot.readBool();
12395 
        else:
12396 
          iprot.skip(ftype)
12397 
      else:
12398 
        iprot.skip(ftype)
12399 
      iprot.readFieldEnd()
12400 
    iprot.readStructEnd()
12401 
 
12402 
  def write(self, oprot):
12403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12405 
      return
12406 
    oprot.writeStructBegin('sendProductNotifications_result')
12407 
    if self.success is not None:
12408 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12409 
      oprot.writeBool(self.success)
12410 
      oprot.writeFieldEnd()
12411 
    oprot.writeFieldStop()
12412 
    oprot.writeStructEnd()
12413 
 
12414 
  def validate(self):
12415 
    return
12416 
 
12417 
 
12418 
  def __repr__(self):
12419 
    L = ['%s=%r' % (key, value)
12420 
      for key, value in self.__dict__.iteritems()]
12421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12422 
 
12423 
  def __eq__(self, other):
12424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12425 
 
12426 
  def __ne__(self, other):
12427 
    return not (self == other)
12428 
 
12429 
class getAllBrandsByCategory_args:
12430 
  """
12431 
  Attributes:
12432 
   - categoryId
12433 
  """
12434 
 
12435 
  thrift_spec = (
12436 
    None, # 0
12437 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12438 
  )
12439 
 
12440 
  def __init__(self, categoryId=None,):
12441 
    self.categoryId = categoryId
12442 
 
12443 
  def read(self, iprot):
12444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12446 
      return
12447 
    iprot.readStructBegin()
12448 
    while True:
12449 
      (fname, ftype, fid) = iprot.readFieldBegin()
12450 
      if ftype == TType.STOP:
12451 
        break
12452 
      if fid == 1:
12453 
        if ftype == TType.I64:
12454 
          self.categoryId = iprot.readI64();
12455 
        else:
12456 
          iprot.skip(ftype)
12457 
      else:
12458 
        iprot.skip(ftype)
12459 
      iprot.readFieldEnd()
12460 
    iprot.readStructEnd()
12461 
 
12462 
  def write(self, oprot):
12463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12465 
      return
12466 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12467 
    if self.categoryId is not None:
12468 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12469 
      oprot.writeI64(self.categoryId)
12470 
      oprot.writeFieldEnd()
12471 
    oprot.writeFieldStop()
12472 
    oprot.writeStructEnd()
12473 
 
12474 
  def validate(self):
12475 
    return
12476 
 
12477 
 
12478 
  def __repr__(self):
12479 
    L = ['%s=%r' % (key, value)
12480 
      for key, value in self.__dict__.iteritems()]
12481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12482 
 
12483 
  def __eq__(self, other):
12484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12485 
 
12486 
  def __ne__(self, other):
12487 
    return not (self == other)
12488 
 
12489 
class getAllBrandsByCategory_result:
12490 
  """
12491 
  Attributes:
12492 
   - success
12493 
  """
12494 
 
12495 
  thrift_spec = (
12496 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12497 
  )
12498 
 
12499 
  def __init__(self, success=None,):
12500 
    self.success = success
12501 
 
12502 
  def read(self, iprot):
12503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12505 
      return
12506 
    iprot.readStructBegin()
12507 
    while True:
12508 
      (fname, ftype, fid) = iprot.readFieldBegin()
12509 
      if ftype == TType.STOP:
12510 
        break
12511 
      if fid == 0:
12512 
        if ftype == TType.LIST:
12513 
          self.success = []
6850 kshitij.so 12514 
          (_etype210, _size207) = iprot.readListBegin()
12515 
          for _i211 in xrange(_size207):
12516 
            _elem212 = iprot.readString();
12517 
            self.success.append(_elem212)
5944 mandeep.dh 12518 
          iprot.readListEnd()
12519 
        else:
12520 
          iprot.skip(ftype)
12521 
      else:
12522 
        iprot.skip(ftype)
12523 
      iprot.readFieldEnd()
12524 
    iprot.readStructEnd()
12525 
 
12526 
  def write(self, oprot):
12527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12529 
      return
12530 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12531 
    if self.success is not None:
12532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12533 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12534 
      for iter213 in self.success:
12535 
        oprot.writeString(iter213)
5944 mandeep.dh 12536 
      oprot.writeListEnd()
12537 
      oprot.writeFieldEnd()
12538 
    oprot.writeFieldStop()
12539 
    oprot.writeStructEnd()
12540 
 
12541 
  def validate(self):
12542 
    return
12543 
 
12544 
 
12545 
  def __repr__(self):
12546 
    L = ['%s=%r' % (key, value)
12547 
      for key, value in self.__dict__.iteritems()]
12548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12549 
 
12550 
  def __eq__(self, other):
12551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12552 
 
12553 
  def __ne__(self, other):
12554 
    return not (self == other)
12555 
 
12556 
class getAllBrands_args:
12557 
 
12558 
  thrift_spec = (
12559 
  )
12560 
 
12561 
  def read(self, iprot):
12562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12564 
      return
12565 
    iprot.readStructBegin()
12566 
    while True:
12567 
      (fname, ftype, fid) = iprot.readFieldBegin()
12568 
      if ftype == TType.STOP:
12569 
        break
12570 
      else:
12571 
        iprot.skip(ftype)
12572 
      iprot.readFieldEnd()
12573 
    iprot.readStructEnd()
12574 
 
12575 
  def write(self, oprot):
12576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12578 
      return
12579 
    oprot.writeStructBegin('getAllBrands_args')
12580 
    oprot.writeFieldStop()
12581 
    oprot.writeStructEnd()
12582 
 
12583 
  def validate(self):
12584 
    return
12585 
 
12586 
 
12587 
  def __repr__(self):
12588 
    L = ['%s=%r' % (key, value)
12589 
      for key, value in self.__dict__.iteritems()]
12590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12591 
 
12592 
  def __eq__(self, other):
12593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12594 
 
12595 
  def __ne__(self, other):
12596 
    return not (self == other)
12597 
 
12598 
class getAllBrands_result:
12599 
  """
12600 
  Attributes:
12601 
   - success
12602 
  """
12603 
 
12604 
  thrift_spec = (
12605 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12606 
  )
12607 
 
12608 
  def __init__(self, success=None,):
12609 
    self.success = success
12610 
 
12611 
  def read(self, iprot):
12612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12614 
      return
12615 
    iprot.readStructBegin()
12616 
    while True:
12617 
      (fname, ftype, fid) = iprot.readFieldBegin()
12618 
      if ftype == TType.STOP:
12619 
        break
12620 
      if fid == 0:
12621 
        if ftype == TType.LIST:
12622 
          self.success = []
6850 kshitij.so 12623 
          (_etype217, _size214) = iprot.readListBegin()
12624 
          for _i218 in xrange(_size214):
12625 
            _elem219 = iprot.readString();
12626 
            self.success.append(_elem219)
5944 mandeep.dh 12627 
          iprot.readListEnd()
12628 
        else:
12629 
          iprot.skip(ftype)
12630 
      else:
12631 
        iprot.skip(ftype)
12632 
      iprot.readFieldEnd()
12633 
    iprot.readStructEnd()
12634 
 
12635 
  def write(self, oprot):
12636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12638 
      return
12639 
    oprot.writeStructBegin('getAllBrands_result')
12640 
    if self.success is not None:
12641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12642 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12643 
      for iter220 in self.success:
12644 
        oprot.writeString(iter220)
5944 mandeep.dh 12645 
      oprot.writeListEnd()
12646 
      oprot.writeFieldEnd()
12647 
    oprot.writeFieldStop()
12648 
    oprot.writeStructEnd()
12649 
 
12650 
  def validate(self):
12651 
    return
12652 
 
12653 
 
12654 
  def __repr__(self):
12655 
    L = ['%s=%r' % (key, value)
12656 
      for key, value in self.__dict__.iteritems()]
12657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12658 
 
12659 
  def __eq__(self, other):
12660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12661 
 
12662 
  def __ne__(self, other):
12663 
    return not (self == other)
12664 
 
12665 
class getAllSources_args:
12666 
 
12667 
  thrift_spec = (
12668 
  )
12669 
 
12670 
  def read(self, iprot):
12671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12673 
      return
12674 
    iprot.readStructBegin()
12675 
    while True:
12676 
      (fname, ftype, fid) = iprot.readFieldBegin()
12677 
      if ftype == TType.STOP:
12678 
        break
12679 
      else:
12680 
        iprot.skip(ftype)
12681 
      iprot.readFieldEnd()
12682 
    iprot.readStructEnd()
12683 
 
12684 
  def write(self, oprot):
12685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12687 
      return
12688 
    oprot.writeStructBegin('getAllSources_args')
12689 
    oprot.writeFieldStop()
12690 
    oprot.writeStructEnd()
12691 
 
12692 
  def validate(self):
12693 
    return
12694 
 
12695 
 
12696 
  def __repr__(self):
12697 
    L = ['%s=%r' % (key, value)
12698 
      for key, value in self.__dict__.iteritems()]
12699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12700 
 
12701 
  def __eq__(self, other):
12702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12703 
 
12704 
  def __ne__(self, other):
12705 
    return not (self == other)
12706 
 
12707 
class getAllSources_result:
12708 
  """
12709 
  Attributes:
12710 
   - success
12711 
  """
12712 
 
12713 
  thrift_spec = (
12714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12715 
  )
12716 
 
12717 
  def __init__(self, success=None,):
12718 
    self.success = success
12719 
 
12720 
  def read(self, iprot):
12721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12723 
      return
12724 
    iprot.readStructBegin()
12725 
    while True:
12726 
      (fname, ftype, fid) = iprot.readFieldBegin()
12727 
      if ftype == TType.STOP:
12728 
        break
12729 
      if fid == 0:
12730 
        if ftype == TType.LIST:
12731 
          self.success = []
6850 kshitij.so 12732 
          (_etype224, _size221) = iprot.readListBegin()
12733 
          for _i225 in xrange(_size221):
12734 
            _elem226 = Source()
12735 
            _elem226.read(iprot)
12736 
            self.success.append(_elem226)
5944 mandeep.dh 12737 
          iprot.readListEnd()
12738 
        else:
12739 
          iprot.skip(ftype)
12740 
      else:
12741 
        iprot.skip(ftype)
12742 
      iprot.readFieldEnd()
12743 
    iprot.readStructEnd()
12744 
 
12745 
  def write(self, oprot):
12746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12748 
      return
12749 
    oprot.writeStructBegin('getAllSources_result')
12750 
    if self.success is not None:
12751 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12752 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12753 
      for iter227 in self.success:
12754 
        iter227.write(oprot)
5944 mandeep.dh 12755 
      oprot.writeListEnd()
12756 
      oprot.writeFieldEnd()
12757 
    oprot.writeFieldStop()
12758 
    oprot.writeStructEnd()
12759 
 
12760 
  def validate(self):
12761 
    return
12762 
 
12763 
 
12764 
  def __repr__(self):
12765 
    L = ['%s=%r' % (key, value)
12766 
      for key, value in self.__dict__.iteritems()]
12767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12768 
 
12769 
  def __eq__(self, other):
12770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12771 
 
12772 
  def __ne__(self, other):
12773 
    return not (self == other)
12774 
 
12775 
class getItemPricingBySource_args:
12776 
  """
12777 
  Attributes:
12778 
   - itemId
12779 
   - sourceId
12780 
  """
12781 
 
12782 
  thrift_spec = (
12783 
    None, # 0
12784 
    (1, TType.I64, 'itemId', None, None, ), # 1
12785 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12786 
  )
12787 
 
12788 
  def __init__(self, itemId=None, sourceId=None,):
12789 
    self.itemId = itemId
12790 
    self.sourceId = sourceId
12791 
 
12792 
  def read(self, iprot):
12793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12795 
      return
12796 
    iprot.readStructBegin()
12797 
    while True:
12798 
      (fname, ftype, fid) = iprot.readFieldBegin()
12799 
      if ftype == TType.STOP:
12800 
        break
12801 
      if fid == 1:
12802 
        if ftype == TType.I64:
12803 
          self.itemId = iprot.readI64();
12804 
        else:
12805 
          iprot.skip(ftype)
12806 
      elif fid == 2:
12807 
        if ftype == TType.I64:
12808 
          self.sourceId = iprot.readI64();
12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      else:
12812 
        iprot.skip(ftype)
12813 
      iprot.readFieldEnd()
12814 
    iprot.readStructEnd()
12815 
 
12816 
  def write(self, oprot):
12817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12819 
      return
12820 
    oprot.writeStructBegin('getItemPricingBySource_args')
12821 
    if self.itemId is not None:
12822 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12823 
      oprot.writeI64(self.itemId)
12824 
      oprot.writeFieldEnd()
12825 
    if self.sourceId is not None:
12826 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12827 
      oprot.writeI64(self.sourceId)
12828 
      oprot.writeFieldEnd()
12829 
    oprot.writeFieldStop()
12830 
    oprot.writeStructEnd()
12831 
 
12832 
  def validate(self):
12833 
    return
12834 
 
12835 
 
12836 
  def __repr__(self):
12837 
    L = ['%s=%r' % (key, value)
12838 
      for key, value in self.__dict__.iteritems()]
12839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12840 
 
12841 
  def __eq__(self, other):
12842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12843 
 
12844 
  def __ne__(self, other):
12845 
    return not (self == other)
12846 
 
12847 
class getItemPricingBySource_result:
12848 
  """
12849 
  Attributes:
12850 
   - success
12851 
   - cex
12852 
  """
12853 
 
12854 
  thrift_spec = (
12855 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
12856 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12857 
  )
12858 
 
12859 
  def __init__(self, success=None, cex=None,):
12860 
    self.success = success
12861 
    self.cex = cex
12862 
 
12863 
  def read(self, iprot):
12864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12866 
      return
12867 
    iprot.readStructBegin()
12868 
    while True:
12869 
      (fname, ftype, fid) = iprot.readFieldBegin()
12870 
      if ftype == TType.STOP:
12871 
        break
12872 
      if fid == 0:
12873 
        if ftype == TType.STRUCT:
12874 
          self.success = SourceItemPricing()
12875 
          self.success.read(iprot)
12876 
        else:
12877 
          iprot.skip(ftype)
12878 
      elif fid == 1:
12879 
        if ftype == TType.STRUCT:
12880 
          self.cex = CatalogServiceException()
12881 
          self.cex.read(iprot)
12882 
        else:
12883 
          iprot.skip(ftype)
12884 
      else:
12885 
        iprot.skip(ftype)
12886 
      iprot.readFieldEnd()
12887 
    iprot.readStructEnd()
12888 
 
12889 
  def write(self, oprot):
12890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12892 
      return
12893 
    oprot.writeStructBegin('getItemPricingBySource_result')
12894 
    if self.success is not None:
12895 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12896 
      self.success.write(oprot)
12897 
      oprot.writeFieldEnd()
12898 
    if self.cex is not None:
12899 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
12900 
      self.cex.write(oprot)
12901 
      oprot.writeFieldEnd()
12902 
    oprot.writeFieldStop()
12903 
    oprot.writeStructEnd()
12904 
 
12905 
  def validate(self):
12906 
    return
12907 
 
12908 
 
12909 
  def __repr__(self):
12910 
    L = ['%s=%r' % (key, value)
12911 
      for key, value in self.__dict__.iteritems()]
12912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12913 
 
12914 
  def __eq__(self, other):
12915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12916 
 
12917 
  def __ne__(self, other):
12918 
    return not (self == other)
12919 
 
12920 
class addSourceItemPricing_args:
12921 
  """
12922 
  Attributes:
12923 
   - sourceItemPricing
12924 
  """
12925 
 
12926 
  thrift_spec = (
12927 
    None, # 0
12928 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
12929 
  )
12930 
 
12931 
  def __init__(self, sourceItemPricing=None,):
12932 
    self.sourceItemPricing = sourceItemPricing
12933 
 
12934 
  def read(self, iprot):
12935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12937 
      return
12938 
    iprot.readStructBegin()
12939 
    while True:
12940 
      (fname, ftype, fid) = iprot.readFieldBegin()
12941 
      if ftype == TType.STOP:
12942 
        break
12943 
      if fid == 1:
12944 
        if ftype == TType.STRUCT:
12945 
          self.sourceItemPricing = SourceItemPricing()
12946 
          self.sourceItemPricing.read(iprot)
12947 
        else:
12948 
          iprot.skip(ftype)
12949 
      else:
12950 
        iprot.skip(ftype)
12951 
      iprot.readFieldEnd()
12952 
    iprot.readStructEnd()
12953 
 
12954 
  def write(self, oprot):
12955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12957 
      return
12958 
    oprot.writeStructBegin('addSourceItemPricing_args')
12959 
    if self.sourceItemPricing is not None:
12960 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
12961 
      self.sourceItemPricing.write(oprot)
12962 
      oprot.writeFieldEnd()
12963 
    oprot.writeFieldStop()
12964 
    oprot.writeStructEnd()
12965 
 
12966 
  def validate(self):
12967 
    return
12968 
 
12969 
 
12970 
  def __repr__(self):
12971 
    L = ['%s=%r' % (key, value)
12972 
      for key, value in self.__dict__.iteritems()]
12973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12974 
 
12975 
  def __eq__(self, other):
12976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12977 
 
12978 
  def __ne__(self, other):
12979 
    return not (self == other)
12980 
 
12981 
class addSourceItemPricing_result:
12982 
  """
12983 
  Attributes:
12984 
   - cex
12985 
  """
12986 
 
12987 
  thrift_spec = (
12988 
    None, # 0
12989 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12990 
  )
12991 
 
12992 
  def __init__(self, cex=None,):
12993 
    self.cex = cex
12994 
 
12995 
  def read(self, iprot):
12996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12998 
      return
12999 
    iprot.readStructBegin()
13000 
    while True:
13001 
      (fname, ftype, fid) = iprot.readFieldBegin()
13002 
      if ftype == TType.STOP:
13003 
        break
13004 
      if fid == 1:
13005 
        if ftype == TType.STRUCT:
13006 
          self.cex = CatalogServiceException()
13007 
          self.cex.read(iprot)
13008 
        else:
13009 
          iprot.skip(ftype)
13010 
      else:
13011 
        iprot.skip(ftype)
13012 
      iprot.readFieldEnd()
13013 
    iprot.readStructEnd()
13014 
 
13015 
  def write(self, oprot):
13016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13018 
      return
13019 
    oprot.writeStructBegin('addSourceItemPricing_result')
13020 
    if self.cex is not None:
13021 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13022 
      self.cex.write(oprot)
13023 
      oprot.writeFieldEnd()
13024 
    oprot.writeFieldStop()
13025 
    oprot.writeStructEnd()
13026 
 
13027 
  def validate(self):
13028 
    return
13029 
 
13030 
 
13031 
  def __repr__(self):
13032 
    L = ['%s=%r' % (key, value)
13033 
      for key, value in self.__dict__.iteritems()]
13034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13035 
 
13036 
  def __eq__(self, other):
13037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13038 
 
13039 
  def __ne__(self, other):
13040 
    return not (self == other)
13041 
 
13042 
class getAllSourcePricing_args:
13043 
  """
13044 
  Attributes:
13045 
   - itemId
13046 
  """
13047 
 
13048 
  thrift_spec = (
13049 
    None, # 0
13050 
    (1, TType.I64, 'itemId', None, None, ), # 1
13051 
  )
13052 
 
13053 
  def __init__(self, itemId=None,):
13054 
    self.itemId = itemId
13055 
 
13056 
  def read(self, iprot):
13057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13059 
      return
13060 
    iprot.readStructBegin()
13061 
    while True:
13062 
      (fname, ftype, fid) = iprot.readFieldBegin()
13063 
      if ftype == TType.STOP:
13064 
        break
13065 
      if fid == 1:
13066 
        if ftype == TType.I64:
13067 
          self.itemId = iprot.readI64();
13068 
        else:
13069 
          iprot.skip(ftype)
13070 
      else:
13071 
        iprot.skip(ftype)
13072 
      iprot.readFieldEnd()
13073 
    iprot.readStructEnd()
13074 
 
13075 
  def write(self, oprot):
13076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13078 
      return
13079 
    oprot.writeStructBegin('getAllSourcePricing_args')
13080 
    if self.itemId is not None:
13081 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13082 
      oprot.writeI64(self.itemId)
13083 
      oprot.writeFieldEnd()
13084 
    oprot.writeFieldStop()
13085 
    oprot.writeStructEnd()
13086 
 
13087 
  def validate(self):
13088 
    return
13089 
 
13090 
 
13091 
  def __repr__(self):
13092 
    L = ['%s=%r' % (key, value)
13093 
      for key, value in self.__dict__.iteritems()]
13094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13095 
 
13096 
  def __eq__(self, other):
13097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13098 
 
13099 
  def __ne__(self, other):
13100 
    return not (self == other)
13101 
 
13102 
class getAllSourcePricing_result:
13103 
  """
13104 
  Attributes:
13105 
   - success
13106 
   - cex
13107 
  """
13108 
 
13109 
  thrift_spec = (
13110 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13111 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13112 
  )
13113 
 
13114 
  def __init__(self, success=None, cex=None,):
13115 
    self.success = success
13116 
    self.cex = cex
13117 
 
13118 
  def read(self, iprot):
13119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13121 
      return
13122 
    iprot.readStructBegin()
13123 
    while True:
13124 
      (fname, ftype, fid) = iprot.readFieldBegin()
13125 
      if ftype == TType.STOP:
13126 
        break
13127 
      if fid == 0:
13128 
        if ftype == TType.LIST:
13129 
          self.success = []
6850 kshitij.so 13130 
          (_etype231, _size228) = iprot.readListBegin()
13131 
          for _i232 in xrange(_size228):
13132 
            _elem233 = SourceItemPricing()
13133 
            _elem233.read(iprot)
13134 
            self.success.append(_elem233)
5944 mandeep.dh 13135 
          iprot.readListEnd()
13136 
        else:
13137 
          iprot.skip(ftype)
13138 
      elif fid == 1:
13139 
        if ftype == TType.STRUCT:
13140 
          self.cex = CatalogServiceException()
13141 
          self.cex.read(iprot)
13142 
        else:
13143 
          iprot.skip(ftype)
13144 
      else:
13145 
        iprot.skip(ftype)
13146 
      iprot.readFieldEnd()
13147 
    iprot.readStructEnd()
13148 
 
13149 
  def write(self, oprot):
13150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13152 
      return
13153 
    oprot.writeStructBegin('getAllSourcePricing_result')
13154 
    if self.success is not None:
13155 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13156 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13157 
      for iter234 in self.success:
13158 
        iter234.write(oprot)
5944 mandeep.dh 13159 
      oprot.writeListEnd()
13160 
      oprot.writeFieldEnd()
13161 
    if self.cex is not None:
13162 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13163 
      self.cex.write(oprot)
13164 
      oprot.writeFieldEnd()
13165 
    oprot.writeFieldStop()
13166 
    oprot.writeStructEnd()
13167 
 
13168 
  def validate(self):
13169 
    return
13170 
 
13171 
 
13172 
  def __repr__(self):
13173 
    L = ['%s=%r' % (key, value)
13174 
      for key, value in self.__dict__.iteritems()]
13175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13176 
 
13177 
  def __eq__(self, other):
13178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13179 
 
13180 
  def __ne__(self, other):
13181 
    return not (self == other)
13182 
 
13183 
class getItemForSource_args:
13184 
  """
13185 
  Attributes:
13186 
   - item_id
13187 
   - sourceId
13188 
  """
13189 
 
13190 
  thrift_spec = (
13191 
    None, # 0
13192 
    (1, TType.I64, 'item_id', None, None, ), # 1
13193 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13194 
  )
13195 
 
13196 
  def __init__(self, item_id=None, sourceId=None,):
13197 
    self.item_id = item_id
13198 
    self.sourceId = sourceId
13199 
 
13200 
  def read(self, iprot):
13201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13203 
      return
13204 
    iprot.readStructBegin()
13205 
    while True:
13206 
      (fname, ftype, fid) = iprot.readFieldBegin()
13207 
      if ftype == TType.STOP:
13208 
        break
13209 
      if fid == 1:
13210 
        if ftype == TType.I64:
13211 
          self.item_id = iprot.readI64();
13212 
        else:
13213 
          iprot.skip(ftype)
13214 
      elif fid == 2:
13215 
        if ftype == TType.I64:
13216 
          self.sourceId = iprot.readI64();
13217 
        else:
13218 
          iprot.skip(ftype)
13219 
      else:
13220 
        iprot.skip(ftype)
13221 
      iprot.readFieldEnd()
13222 
    iprot.readStructEnd()
13223 
 
13224 
  def write(self, oprot):
13225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13227 
      return
13228 
    oprot.writeStructBegin('getItemForSource_args')
13229 
    if self.item_id is not None:
13230 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13231 
      oprot.writeI64(self.item_id)
13232 
      oprot.writeFieldEnd()
13233 
    if self.sourceId is not None:
13234 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13235 
      oprot.writeI64(self.sourceId)
13236 
      oprot.writeFieldEnd()
13237 
    oprot.writeFieldStop()
13238 
    oprot.writeStructEnd()
13239 
 
13240 
  def validate(self):
13241 
    return
13242 
 
13243 
 
13244 
  def __repr__(self):
13245 
    L = ['%s=%r' % (key, value)
13246 
      for key, value in self.__dict__.iteritems()]
13247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13248 
 
13249 
  def __eq__(self, other):
13250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13251 
 
13252 
  def __ne__(self, other):
13253 
    return not (self == other)
13254 
 
13255 
class getItemForSource_result:
13256 
  """
13257 
  Attributes:
13258 
   - success
13259 
   - cex
13260 
  """
13261 
 
13262 
  thrift_spec = (
13263 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13264 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13265 
  )
13266 
 
13267 
  def __init__(self, success=None, cex=None,):
13268 
    self.success = success
13269 
    self.cex = cex
13270 
 
13271 
  def read(self, iprot):
13272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13274 
      return
13275 
    iprot.readStructBegin()
13276 
    while True:
13277 
      (fname, ftype, fid) = iprot.readFieldBegin()
13278 
      if ftype == TType.STOP:
13279 
        break
13280 
      if fid == 0:
13281 
        if ftype == TType.STRUCT:
13282 
          self.success = Item()
13283 
          self.success.read(iprot)
13284 
        else:
13285 
          iprot.skip(ftype)
13286 
      elif fid == 1:
13287 
        if ftype == TType.STRUCT:
13288 
          self.cex = CatalogServiceException()
13289 
          self.cex.read(iprot)
13290 
        else:
13291 
          iprot.skip(ftype)
13292 
      else:
13293 
        iprot.skip(ftype)
13294 
      iprot.readFieldEnd()
13295 
    iprot.readStructEnd()
13296 
 
13297 
  def write(self, oprot):
13298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13300 
      return
13301 
    oprot.writeStructBegin('getItemForSource_result')
13302 
    if self.success is not None:
13303 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13304 
      self.success.write(oprot)
13305 
      oprot.writeFieldEnd()
13306 
    if self.cex is not None:
13307 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13308 
      self.cex.write(oprot)
13309 
      oprot.writeFieldEnd()
13310 
    oprot.writeFieldStop()
13311 
    oprot.writeStructEnd()
13312 
 
13313 
  def validate(self):
13314 
    return
13315 
 
13316 
 
13317 
  def __repr__(self):
13318 
    L = ['%s=%r' % (key, value)
13319 
      for key, value in self.__dict__.iteritems()]
13320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13321 
 
13322 
  def __eq__(self, other):
13323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13324 
 
13325 
  def __ne__(self, other):
13326 
    return not (self == other)
13327 
 
13328 
class searchItemsInRange_args:
13329 
  """
13330 
  Attributes:
13331 
   - searchTerms
13332 
   - offset
13333 
   - limit
13334 
  """
13335 
 
13336 
  thrift_spec = (
13337 
    None, # 0
13338 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13339 
    (2, TType.I64, 'offset', None, None, ), # 2
13340 
    (3, TType.I64, 'limit', None, None, ), # 3
13341 
  )
13342 
 
13343 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13344 
    self.searchTerms = searchTerms
13345 
    self.offset = offset
13346 
    self.limit = limit
13347 
 
13348 
  def read(self, iprot):
13349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13351 
      return
13352 
    iprot.readStructBegin()
13353 
    while True:
13354 
      (fname, ftype, fid) = iprot.readFieldBegin()
13355 
      if ftype == TType.STOP:
13356 
        break
13357 
      if fid == 1:
13358 
        if ftype == TType.LIST:
13359 
          self.searchTerms = []
6850 kshitij.so 13360 
          (_etype238, _size235) = iprot.readListBegin()
13361 
          for _i239 in xrange(_size235):
13362 
            _elem240 = iprot.readString();
13363 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13364 
          iprot.readListEnd()
13365 
        else:
13366 
          iprot.skip(ftype)
13367 
      elif fid == 2:
13368 
        if ftype == TType.I64:
13369 
          self.offset = iprot.readI64();
13370 
        else:
13371 
          iprot.skip(ftype)
13372 
      elif fid == 3:
13373 
        if ftype == TType.I64:
13374 
          self.limit = iprot.readI64();
13375 
        else:
13376 
          iprot.skip(ftype)
13377 
      else:
13378 
        iprot.skip(ftype)
13379 
      iprot.readFieldEnd()
13380 
    iprot.readStructEnd()
13381 
 
13382 
  def write(self, oprot):
13383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13385 
      return
13386 
    oprot.writeStructBegin('searchItemsInRange_args')
13387 
    if self.searchTerms is not None:
13388 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13389 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13390 
      for iter241 in self.searchTerms:
13391 
        oprot.writeString(iter241)
5944 mandeep.dh 13392 
      oprot.writeListEnd()
13393 
      oprot.writeFieldEnd()
13394 
    if self.offset is not None:
13395 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13396 
      oprot.writeI64(self.offset)
13397 
      oprot.writeFieldEnd()
13398 
    if self.limit is not None:
13399 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13400 
      oprot.writeI64(self.limit)
13401 
      oprot.writeFieldEnd()
13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
13420 
class searchItemsInRange_result:
13421 
  """
13422 
  Attributes:
13423 
   - success
13424 
  """
13425 
 
13426 
  thrift_spec = (
13427 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13428 
  )
13429 
 
13430 
  def __init__(self, success=None,):
13431 
    self.success = success
13432 
 
13433 
  def read(self, iprot):
13434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13436 
      return
13437 
    iprot.readStructBegin()
13438 
    while True:
13439 
      (fname, ftype, fid) = iprot.readFieldBegin()
13440 
      if ftype == TType.STOP:
13441 
        break
13442 
      if fid == 0:
13443 
        if ftype == TType.LIST:
13444 
          self.success = []
6850 kshitij.so 13445 
          (_etype245, _size242) = iprot.readListBegin()
13446 
          for _i246 in xrange(_size242):
13447 
            _elem247 = Item()
13448 
            _elem247.read(iprot)
13449 
            self.success.append(_elem247)
5944 mandeep.dh 13450 
          iprot.readListEnd()
13451 
        else:
13452 
          iprot.skip(ftype)
13453 
      else:
13454 
        iprot.skip(ftype)
13455 
      iprot.readFieldEnd()
13456 
    iprot.readStructEnd()
13457 
 
13458 
  def write(self, oprot):
13459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13461 
      return
13462 
    oprot.writeStructBegin('searchItemsInRange_result')
13463 
    if self.success is not None:
13464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13466 
      for iter248 in self.success:
13467 
        iter248.write(oprot)
5944 mandeep.dh 13468 
      oprot.writeListEnd()
13469 
      oprot.writeFieldEnd()
13470 
    oprot.writeFieldStop()
13471 
    oprot.writeStructEnd()
13472 
 
13473 
  def validate(self):
13474 
    return
13475 
 
13476 
 
13477 
  def __repr__(self):
13478 
    L = ['%s=%r' % (key, value)
13479 
      for key, value in self.__dict__.iteritems()]
13480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13481 
 
13482 
  def __eq__(self, other):
13483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13484 
 
13485 
  def __ne__(self, other):
13486 
    return not (self == other)
13487 
 
13488 
class getSearchResultCount_args:
13489 
  """
13490 
  Attributes:
13491 
   - searchTerms
13492 
  """
13493 
 
13494 
  thrift_spec = (
13495 
    None, # 0
13496 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13497 
  )
13498 
 
13499 
  def __init__(self, searchTerms=None,):
13500 
    self.searchTerms = searchTerms
13501 
 
13502 
  def read(self, iprot):
13503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13505 
      return
13506 
    iprot.readStructBegin()
13507 
    while True:
13508 
      (fname, ftype, fid) = iprot.readFieldBegin()
13509 
      if ftype == TType.STOP:
13510 
        break
13511 
      if fid == 1:
13512 
        if ftype == TType.LIST:
13513 
          self.searchTerms = []
6850 kshitij.so 13514 
          (_etype252, _size249) = iprot.readListBegin()
13515 
          for _i253 in xrange(_size249):
13516 
            _elem254 = iprot.readString();
13517 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13518 
          iprot.readListEnd()
13519 
        else:
13520 
          iprot.skip(ftype)
13521 
      else:
13522 
        iprot.skip(ftype)
13523 
      iprot.readFieldEnd()
13524 
    iprot.readStructEnd()
13525 
 
13526 
  def write(self, oprot):
13527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13529 
      return
13530 
    oprot.writeStructBegin('getSearchResultCount_args')
13531 
    if self.searchTerms is not None:
13532 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13533 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13534 
      for iter255 in self.searchTerms:
13535 
        oprot.writeString(iter255)
5944 mandeep.dh 13536 
      oprot.writeListEnd()
13537 
      oprot.writeFieldEnd()
13538 
    oprot.writeFieldStop()
13539 
    oprot.writeStructEnd()
13540 
 
13541 
  def validate(self):
13542 
    return
13543 
 
13544 
 
13545 
  def __repr__(self):
13546 
    L = ['%s=%r' % (key, value)
13547 
      for key, value in self.__dict__.iteritems()]
13548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13549 
 
13550 
  def __eq__(self, other):
13551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13552 
 
13553 
  def __ne__(self, other):
13554 
    return not (self == other)
13555 
 
13556 
class getSearchResultCount_result:
13557 
  """
13558 
  Attributes:
13559 
   - success
13560 
  """
13561 
 
13562 
  thrift_spec = (
13563 
    (0, TType.I32, 'success', None, None, ), # 0
13564 
  )
13565 
 
13566 
  def __init__(self, success=None,):
13567 
    self.success = success
13568 
 
13569 
  def read(self, iprot):
13570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13572 
      return
13573 
    iprot.readStructBegin()
13574 
    while True:
13575 
      (fname, ftype, fid) = iprot.readFieldBegin()
13576 
      if ftype == TType.STOP:
13577 
        break
13578 
      if fid == 0:
13579 
        if ftype == TType.I32:
13580 
          self.success = iprot.readI32();
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      else:
13584 
        iprot.skip(ftype)
13585 
      iprot.readFieldEnd()
13586 
    iprot.readStructEnd()
13587 
 
13588 
  def write(self, oprot):
13589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13591 
      return
13592 
    oprot.writeStructBegin('getSearchResultCount_result')
13593 
    if self.success is not None:
13594 
      oprot.writeFieldBegin('success', TType.I32, 0)
13595 
      oprot.writeI32(self.success)
13596 
      oprot.writeFieldEnd()
13597 
    oprot.writeFieldStop()
13598 
    oprot.writeStructEnd()
13599 
 
13600 
  def validate(self):
13601 
    return
13602 
 
13603 
 
13604 
  def __repr__(self):
13605 
    L = ['%s=%r' % (key, value)
13606 
      for key, value in self.__dict__.iteritems()]
13607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13608 
 
13609 
  def __eq__(self, other):
13610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13611 
 
13612 
  def __ne__(self, other):
13613 
    return not (self == other)
13614 
 
13615 
class getProductNotifications_args:
13616 
  """
13617 
  Attributes:
13618 
   - startDateTime
13619 
  """
13620 
 
13621 
  thrift_spec = (
13622 
    None, # 0
13623 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13624 
  )
13625 
 
13626 
  def __init__(self, startDateTime=None,):
13627 
    self.startDateTime = startDateTime
13628 
 
13629 
  def read(self, iprot):
13630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13632 
      return
13633 
    iprot.readStructBegin()
13634 
    while True:
13635 
      (fname, ftype, fid) = iprot.readFieldBegin()
13636 
      if ftype == TType.STOP:
13637 
        break
13638 
      if fid == 1:
13639 
        if ftype == TType.I64:
13640 
          self.startDateTime = iprot.readI64();
13641 
        else:
13642 
          iprot.skip(ftype)
13643 
      else:
13644 
        iprot.skip(ftype)
13645 
      iprot.readFieldEnd()
13646 
    iprot.readStructEnd()
13647 
 
13648 
  def write(self, oprot):
13649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13651 
      return
13652 
    oprot.writeStructBegin('getProductNotifications_args')
13653 
    if self.startDateTime is not None:
13654 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13655 
      oprot.writeI64(self.startDateTime)
13656 
      oprot.writeFieldEnd()
13657 
    oprot.writeFieldStop()
13658 
    oprot.writeStructEnd()
13659 
 
13660 
  def validate(self):
13661 
    return
13662 
 
13663 
 
13664 
  def __repr__(self):
13665 
    L = ['%s=%r' % (key, value)
13666 
      for key, value in self.__dict__.iteritems()]
13667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13668 
 
13669 
  def __eq__(self, other):
13670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13671 
 
13672 
  def __ne__(self, other):
13673 
    return not (self == other)
13674 
 
13675 
class getProductNotifications_result:
13676 
  """
13677 
  Attributes:
13678 
   - success
13679 
  """
13680 
 
13681 
  thrift_spec = (
13682 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13683 
  )
13684 
 
13685 
  def __init__(self, success=None,):
13686 
    self.success = success
13687 
 
13688 
  def read(self, iprot):
13689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13691 
      return
13692 
    iprot.readStructBegin()
13693 
    while True:
13694 
      (fname, ftype, fid) = iprot.readFieldBegin()
13695 
      if ftype == TType.STOP:
13696 
        break
13697 
      if fid == 0:
13698 
        if ftype == TType.LIST:
13699 
          self.success = []
6850 kshitij.so 13700 
          (_etype259, _size256) = iprot.readListBegin()
13701 
          for _i260 in xrange(_size256):
13702 
            _elem261 = ProductNotificationRequest()
13703 
            _elem261.read(iprot)
13704 
            self.success.append(_elem261)
5944 mandeep.dh 13705 
          iprot.readListEnd()
13706 
        else:
13707 
          iprot.skip(ftype)
13708 
      else:
13709 
        iprot.skip(ftype)
13710 
      iprot.readFieldEnd()
13711 
    iprot.readStructEnd()
13712 
 
13713 
  def write(self, oprot):
13714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13716 
      return
13717 
    oprot.writeStructBegin('getProductNotifications_result')
13718 
    if self.success is not None:
13719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13721 
      for iter262 in self.success:
13722 
        iter262.write(oprot)
5944 mandeep.dh 13723 
      oprot.writeListEnd()
13724 
      oprot.writeFieldEnd()
13725 
    oprot.writeFieldStop()
13726 
    oprot.writeStructEnd()
13727 
 
13728 
  def validate(self):
13729 
    return
13730 
 
13731 
 
13732 
  def __repr__(self):
13733 
    L = ['%s=%r' % (key, value)
13734 
      for key, value in self.__dict__.iteritems()]
13735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13736 
 
13737 
  def __eq__(self, other):
13738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13739 
 
13740 
  def __ne__(self, other):
13741 
    return not (self == other)
13742 
 
13743 
class getProductNotificationRequestCount_args:
13744 
  """
13745 
  Attributes:
13746 
   - startDateTime
13747 
  """
13748 
 
13749 
  thrift_spec = (
13750 
    None, # 0
13751 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13752 
  )
13753 
 
13754 
  def __init__(self, startDateTime=None,):
13755 
    self.startDateTime = startDateTime
13756 
 
13757 
  def read(self, iprot):
13758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13760 
      return
13761 
    iprot.readStructBegin()
13762 
    while True:
13763 
      (fname, ftype, fid) = iprot.readFieldBegin()
13764 
      if ftype == TType.STOP:
13765 
        break
13766 
      if fid == 1:
13767 
        if ftype == TType.I64:
13768 
          self.startDateTime = iprot.readI64();
13769 
        else:
13770 
          iprot.skip(ftype)
13771 
      else:
13772 
        iprot.skip(ftype)
13773 
      iprot.readFieldEnd()
13774 
    iprot.readStructEnd()
13775 
 
13776 
  def write(self, oprot):
13777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13779 
      return
13780 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13781 
    if self.startDateTime is not None:
13782 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13783 
      oprot.writeI64(self.startDateTime)
13784 
      oprot.writeFieldEnd()
13785 
    oprot.writeFieldStop()
13786 
    oprot.writeStructEnd()
13787 
 
13788 
  def validate(self):
13789 
    return
13790 
 
13791 
 
13792 
  def __repr__(self):
13793 
    L = ['%s=%r' % (key, value)
13794 
      for key, value in self.__dict__.iteritems()]
13795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13796 
 
13797 
  def __eq__(self, other):
13798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13799 
 
13800 
  def __ne__(self, other):
13801 
    return not (self == other)
13802 
 
13803 
class getProductNotificationRequestCount_result:
13804 
  """
13805 
  Attributes:
13806 
   - success
13807 
  """
13808 
 
13809 
  thrift_spec = (
13810 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13811 
  )
13812 
 
13813 
  def __init__(self, success=None,):
13814 
    self.success = success
13815 
 
13816 
  def read(self, iprot):
13817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13819 
      return
13820 
    iprot.readStructBegin()
13821 
    while True:
13822 
      (fname, ftype, fid) = iprot.readFieldBegin()
13823 
      if ftype == TType.STOP:
13824 
        break
13825 
      if fid == 0:
13826 
        if ftype == TType.LIST:
13827 
          self.success = []
6850 kshitij.so 13828 
          (_etype266, _size263) = iprot.readListBegin()
13829 
          for _i267 in xrange(_size263):
13830 
            _elem268 = ProductNotificationRequestCount()
13831 
            _elem268.read(iprot)
13832 
            self.success.append(_elem268)
5944 mandeep.dh 13833 
          iprot.readListEnd()
13834 
        else:
13835 
          iprot.skip(ftype)
13836 
      else:
13837 
        iprot.skip(ftype)
13838 
      iprot.readFieldEnd()
13839 
    iprot.readStructEnd()
13840 
 
13841 
  def write(self, oprot):
13842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13844 
      return
13845 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
13846 
    if self.success is not None:
13847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13848 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13849 
      for iter269 in self.success:
13850 
        iter269.write(oprot)
5944 mandeep.dh 13851 
      oprot.writeListEnd()
13852 
      oprot.writeFieldEnd()
13853 
    oprot.writeFieldStop()
13854 
    oprot.writeStructEnd()
13855 
 
13856 
  def validate(self):
13857 
    return
13858 
 
13859 
 
13860 
  def __repr__(self):
13861 
    L = ['%s=%r' % (key, value)
13862 
      for key, value in self.__dict__.iteritems()]
13863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13864 
 
13865 
  def __eq__(self, other):
13866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13867 
 
13868 
  def __ne__(self, other):
13869 
    return not (self == other)
13870 
 
13871 
class addAuthorizationLog_args:
13872 
  """
13873 
  Attributes:
13874 
   - itemId
13875 
   - username
13876 
   - reason
13877 
  """
13878 
 
13879 
  thrift_spec = (
13880 
    None, # 0
13881 
    (1, TType.I64, 'itemId', None, None, ), # 1
13882 
    (2, TType.STRING, 'username', None, None, ), # 2
13883 
    (3, TType.STRING, 'reason', None, None, ), # 3
13884 
  )
13885 
 
13886 
  def __init__(self, itemId=None, username=None, reason=None,):
13887 
    self.itemId = itemId
13888 
    self.username = username
13889 
    self.reason = reason
13890 
 
13891 
  def read(self, iprot):
13892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13894 
      return
13895 
    iprot.readStructBegin()
13896 
    while True:
13897 
      (fname, ftype, fid) = iprot.readFieldBegin()
13898 
      if ftype == TType.STOP:
13899 
        break
13900 
      if fid == 1:
13901 
        if ftype == TType.I64:
13902 
          self.itemId = iprot.readI64();
13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      elif fid == 2:
13906 
        if ftype == TType.STRING:
13907 
          self.username = iprot.readString();
13908 
        else:
13909 
          iprot.skip(ftype)
13910 
      elif fid == 3:
13911 
        if ftype == TType.STRING:
13912 
          self.reason = iprot.readString();
13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      else:
13916 
        iprot.skip(ftype)
13917 
      iprot.readFieldEnd()
13918 
    iprot.readStructEnd()
13919 
 
13920 
  def write(self, oprot):
13921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13923 
      return
13924 
    oprot.writeStructBegin('addAuthorizationLog_args')
13925 
    if self.itemId is not None:
13926 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13927 
      oprot.writeI64(self.itemId)
13928 
      oprot.writeFieldEnd()
13929 
    if self.username is not None:
13930 
      oprot.writeFieldBegin('username', TType.STRING, 2)
13931 
      oprot.writeString(self.username)
13932 
      oprot.writeFieldEnd()
13933 
    if self.reason is not None:
13934 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
13935 
      oprot.writeString(self.reason)
13936 
      oprot.writeFieldEnd()
13937 
    oprot.writeFieldStop()
13938 
    oprot.writeStructEnd()
13939 
 
13940 
  def validate(self):
13941 
    return
13942 
 
13943 
 
13944 
  def __repr__(self):
13945 
    L = ['%s=%r' % (key, value)
13946 
      for key, value in self.__dict__.iteritems()]
13947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13948 
 
13949 
  def __eq__(self, other):
13950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13951 
 
13952 
  def __ne__(self, other):
13953 
    return not (self == other)
13954 
 
13955 
class addAuthorizationLog_result:
13956 
  """
13957 
  Attributes:
13958 
   - success
13959 
   - cex
13960 
  """
13961 
 
13962 
  thrift_spec = (
13963 
    (0, TType.BOOL, 'success', None, None, ), # 0
13964 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13965 
  )
13966 
 
13967 
  def __init__(self, success=None, cex=None,):
13968 
    self.success = success
13969 
    self.cex = cex
13970 
 
13971 
  def read(self, iprot):
13972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13974 
      return
13975 
    iprot.readStructBegin()
13976 
    while True:
13977 
      (fname, ftype, fid) = iprot.readFieldBegin()
13978 
      if ftype == TType.STOP:
13979 
        break
13980 
      if fid == 0:
13981 
        if ftype == TType.BOOL:
13982 
          self.success = iprot.readBool();
13983 
        else:
13984 
          iprot.skip(ftype)
13985 
      elif fid == 1:
13986 
        if ftype == TType.STRUCT:
13987 
          self.cex = CatalogServiceException()
13988 
          self.cex.read(iprot)
13989 
        else:
13990 
          iprot.skip(ftype)
13991 
      else:
13992 
        iprot.skip(ftype)
13993 
      iprot.readFieldEnd()
13994 
    iprot.readStructEnd()
13995 
 
13996 
  def write(self, oprot):
13997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13999 
      return
14000 
    oprot.writeStructBegin('addAuthorizationLog_result')
14001 
    if self.success is not None:
14002 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14003 
      oprot.writeBool(self.success)
14004 
      oprot.writeFieldEnd()
14005 
    if self.cex is not None:
14006 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14007 
      self.cex.write(oprot)
14008 
      oprot.writeFieldEnd()
14009 
    oprot.writeFieldStop()
14010 
    oprot.writeStructEnd()
14011 
 
14012 
  def validate(self):
14013 
    return
14014 
 
14015 
 
14016 
  def __repr__(self):
14017 
    L = ['%s=%r' % (key, value)
14018 
      for key, value in self.__dict__.iteritems()]
14019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14020 
 
14021 
  def __eq__(self, other):
14022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14023 
 
14024 
  def __ne__(self, other):
14025 
    return not (self == other)
14026 
 
14027 
class addupdateVoucherForItem_args:
14028 
  """
14029 
  Attributes:
14030 
   - catalog_item_id
14031 
   - voucherType
14032 
   - voucherAmount
14033 
  """
14034 
 
14035 
  thrift_spec = (
14036 
    None, # 0
14037 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14038 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14039 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14040 
  )
14041 
 
14042 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14043 
    self.catalog_item_id = catalog_item_id
14044 
    self.voucherType = voucherType
14045 
    self.voucherAmount = voucherAmount
14046 
 
14047 
  def read(self, iprot):
14048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14050 
      return
14051 
    iprot.readStructBegin()
14052 
    while True:
14053 
      (fname, ftype, fid) = iprot.readFieldBegin()
14054 
      if ftype == TType.STOP:
14055 
        break
14056 
      if fid == 1:
14057 
        if ftype == TType.I64:
14058 
          self.catalog_item_id = iprot.readI64();
14059 
        else:
14060 
          iprot.skip(ftype)
14061 
      elif fid == 2:
14062 
        if ftype == TType.I64:
14063 
          self.voucherType = iprot.readI64();
14064 
        else:
14065 
          iprot.skip(ftype)
14066 
      elif fid == 3:
14067 
        if ftype == TType.I64:
14068 
          self.voucherAmount = iprot.readI64();
14069 
        else:
14070 
          iprot.skip(ftype)
14071 
      else:
14072 
        iprot.skip(ftype)
14073 
      iprot.readFieldEnd()
14074 
    iprot.readStructEnd()
14075 
 
14076 
  def write(self, oprot):
14077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14079 
      return
14080 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14081 
    if self.catalog_item_id is not None:
14082 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14083 
      oprot.writeI64(self.catalog_item_id)
14084 
      oprot.writeFieldEnd()
14085 
    if self.voucherType is not None:
14086 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14087 
      oprot.writeI64(self.voucherType)
14088 
      oprot.writeFieldEnd()
14089 
    if self.voucherAmount is not None:
14090 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14091 
      oprot.writeI64(self.voucherAmount)
14092 
      oprot.writeFieldEnd()
14093 
    oprot.writeFieldStop()
14094 
    oprot.writeStructEnd()
14095 
 
14096 
  def validate(self):
14097 
    return
14098 
 
14099 
 
14100 
  def __repr__(self):
14101 
    L = ['%s=%r' % (key, value)
14102 
      for key, value in self.__dict__.iteritems()]
14103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14104 
 
14105 
  def __eq__(self, other):
14106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14107 
 
14108 
  def __ne__(self, other):
14109 
    return not (self == other)
14110 
 
14111 
class addupdateVoucherForItem_result:
14112 
  """
14113 
  Attributes:
14114 
   - success
14115 
   - cex
14116 
  """
14117 
 
14118 
  thrift_spec = (
14119 
    (0, TType.BOOL, 'success', None, None, ), # 0
14120 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14121 
  )
14122 
 
14123 
  def __init__(self, success=None, cex=None,):
14124 
    self.success = success
14125 
    self.cex = cex
14126 
 
14127 
  def read(self, iprot):
14128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14130 
      return
14131 
    iprot.readStructBegin()
14132 
    while True:
14133 
      (fname, ftype, fid) = iprot.readFieldBegin()
14134 
      if ftype == TType.STOP:
14135 
        break
14136 
      if fid == 0:
14137 
        if ftype == TType.BOOL:
14138 
          self.success = iprot.readBool();
14139 
        else:
14140 
          iprot.skip(ftype)
14141 
      elif fid == 1:
14142 
        if ftype == TType.STRUCT:
14143 
          self.cex = CatalogServiceException()
14144 
          self.cex.read(iprot)
14145 
        else:
14146 
          iprot.skip(ftype)
14147 
      else:
14148 
        iprot.skip(ftype)
14149 
      iprot.readFieldEnd()
14150 
    iprot.readStructEnd()
14151 
 
14152 
  def write(self, oprot):
14153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14155 
      return
14156 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14157 
    if self.success is not None:
14158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14159 
      oprot.writeBool(self.success)
14160 
      oprot.writeFieldEnd()
14161 
    if self.cex is not None:
14162 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14163 
      self.cex.write(oprot)
14164 
      oprot.writeFieldEnd()
14165 
    oprot.writeFieldStop()
14166 
    oprot.writeStructEnd()
14167 
 
14168 
  def validate(self):
14169 
    return
14170 
 
14171 
 
14172 
  def __repr__(self):
14173 
    L = ['%s=%r' % (key, value)
14174 
      for key, value in self.__dict__.iteritems()]
14175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14176 
 
14177 
  def __eq__(self, other):
14178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14179 
 
14180 
  def __ne__(self, other):
14181 
    return not (self == other)
14182 
 
14183 
class deleteVoucherForItem_args:
14184 
  """
14185 
  Attributes:
14186 
   - catalog_item_id
14187 
   - voucherType
14188 
  """
14189 
 
14190 
  thrift_spec = (
14191 
    None, # 0
14192 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14193 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14194 
  )
14195 
 
14196 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14197 
    self.catalog_item_id = catalog_item_id
14198 
    self.voucherType = voucherType
14199 
 
14200 
  def read(self, iprot):
14201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14203 
      return
14204 
    iprot.readStructBegin()
14205 
    while True:
14206 
      (fname, ftype, fid) = iprot.readFieldBegin()
14207 
      if ftype == TType.STOP:
14208 
        break
14209 
      if fid == 1:
14210 
        if ftype == TType.I64:
14211 
          self.catalog_item_id = iprot.readI64();
14212 
        else:
14213 
          iprot.skip(ftype)
14214 
      elif fid == 2:
14215 
        if ftype == TType.I64:
14216 
          self.voucherType = iprot.readI64();
14217 
        else:
14218 
          iprot.skip(ftype)
14219 
      else:
14220 
        iprot.skip(ftype)
14221 
      iprot.readFieldEnd()
14222 
    iprot.readStructEnd()
14223 
 
14224 
  def write(self, oprot):
14225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14227 
      return
14228 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14229 
    if self.catalog_item_id is not None:
14230 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14231 
      oprot.writeI64(self.catalog_item_id)
14232 
      oprot.writeFieldEnd()
14233 
    if self.voucherType is not None:
14234 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14235 
      oprot.writeI64(self.voucherType)
14236 
      oprot.writeFieldEnd()
14237 
    oprot.writeFieldStop()
14238 
    oprot.writeStructEnd()
14239 
 
14240 
  def validate(self):
14241 
    return
14242 
 
14243 
 
14244 
  def __repr__(self):
14245 
    L = ['%s=%r' % (key, value)
14246 
      for key, value in self.__dict__.iteritems()]
14247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14248 
 
14249 
  def __eq__(self, other):
14250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14251 
 
14252 
  def __ne__(self, other):
14253 
    return not (self == other)
14254 
 
14255 
class deleteVoucherForItem_result:
14256 
  """
14257 
  Attributes:
14258 
   - success
14259 
   - cex
14260 
  """
14261 
 
14262 
  thrift_spec = (
14263 
    (0, TType.BOOL, 'success', None, None, ), # 0
14264 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14265 
  )
14266 
 
14267 
  def __init__(self, success=None, cex=None,):
14268 
    self.success = success
14269 
    self.cex = cex
14270 
 
14271 
  def read(self, iprot):
14272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14274 
      return
14275 
    iprot.readStructBegin()
14276 
    while True:
14277 
      (fname, ftype, fid) = iprot.readFieldBegin()
14278 
      if ftype == TType.STOP:
14279 
        break
14280 
      if fid == 0:
14281 
        if ftype == TType.BOOL:
14282 
          self.success = iprot.readBool();
14283 
        else:
14284 
          iprot.skip(ftype)
14285 
      elif fid == 1:
14286 
        if ftype == TType.STRUCT:
14287 
          self.cex = CatalogServiceException()
14288 
          self.cex.read(iprot)
14289 
        else:
14290 
          iprot.skip(ftype)
14291 
      else:
14292 
        iprot.skip(ftype)
14293 
      iprot.readFieldEnd()
14294 
    iprot.readStructEnd()
14295 
 
14296 
  def write(self, oprot):
14297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14299 
      return
14300 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14301 
    if self.success is not None:
14302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14303 
      oprot.writeBool(self.success)
14304 
      oprot.writeFieldEnd()
14305 
    if self.cex is not None:
14306 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14307 
      self.cex.write(oprot)
14308 
      oprot.writeFieldEnd()
14309 
    oprot.writeFieldStop()
14310 
    oprot.writeStructEnd()
14311 
 
14312 
  def validate(self):
14313 
    return
14314 
 
14315 
 
14316 
  def __repr__(self):
14317 
    L = ['%s=%r' % (key, value)
14318 
      for key, value in self.__dict__.iteritems()]
14319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14320 
 
14321 
  def __eq__(self, other):
14322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14323 
 
14324 
  def __ne__(self, other):
14325 
    return not (self == other)
14326 
 
14327 
class getVoucherAmount_args:
14328 
  """
14329 
  Attributes:
14330 
   - itemId
14331 
   - voucherType
14332 
  """
14333 
 
14334 
  thrift_spec = (
14335 
    None, # 0
14336 
    (1, TType.I64, 'itemId', None, None, ), # 1
14337 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14338 
  )
14339 
 
14340 
  def __init__(self, itemId=None, voucherType=None,):
14341 
    self.itemId = itemId
14342 
    self.voucherType = voucherType
14343 
 
14344 
  def read(self, iprot):
14345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14347 
      return
14348 
    iprot.readStructBegin()
14349 
    while True:
14350 
      (fname, ftype, fid) = iprot.readFieldBegin()
14351 
      if ftype == TType.STOP:
14352 
        break
14353 
      if fid == 1:
14354 
        if ftype == TType.I64:
14355 
          self.itemId = iprot.readI64();
14356 
        else:
14357 
          iprot.skip(ftype)
14358 
      elif fid == 2:
14359 
        if ftype == TType.I64:
14360 
          self.voucherType = iprot.readI64();
14361 
        else:
14362 
          iprot.skip(ftype)
14363 
      else:
14364 
        iprot.skip(ftype)
14365 
      iprot.readFieldEnd()
14366 
    iprot.readStructEnd()
14367 
 
14368 
  def write(self, oprot):
14369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14371 
      return
14372 
    oprot.writeStructBegin('getVoucherAmount_args')
14373 
    if self.itemId is not None:
14374 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14375 
      oprot.writeI64(self.itemId)
14376 
      oprot.writeFieldEnd()
14377 
    if self.voucherType is not None:
14378 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14379 
      oprot.writeI64(self.voucherType)
14380 
      oprot.writeFieldEnd()
14381 
    oprot.writeFieldStop()
14382 
    oprot.writeStructEnd()
14383 
 
14384 
  def validate(self):
14385 
    return
14386 
 
14387 
 
14388 
  def __repr__(self):
14389 
    L = ['%s=%r' % (key, value)
14390 
      for key, value in self.__dict__.iteritems()]
14391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14392 
 
14393 
  def __eq__(self, other):
14394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14395 
 
14396 
  def __ne__(self, other):
14397 
    return not (self == other)
14398 
 
14399 
class getVoucherAmount_result:
14400 
  """
14401 
  Attributes:
14402 
   - success
14403 
  """
14404 
 
14405 
  thrift_spec = (
14406 
    (0, TType.I64, 'success', None, None, ), # 0
14407 
  )
14408 
 
14409 
  def __init__(self, success=None,):
14410 
    self.success = success
14411 
 
14412 
  def read(self, iprot):
14413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14415 
      return
14416 
    iprot.readStructBegin()
14417 
    while True:
14418 
      (fname, ftype, fid) = iprot.readFieldBegin()
14419 
      if ftype == TType.STOP:
14420 
        break
14421 
      if fid == 0:
14422 
        if ftype == TType.I64:
14423 
          self.success = iprot.readI64();
14424 
        else:
14425 
          iprot.skip(ftype)
14426 
      else:
14427 
        iprot.skip(ftype)
14428 
      iprot.readFieldEnd()
14429 
    iprot.readStructEnd()
14430 
 
14431 
  def write(self, oprot):
14432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14434 
      return
14435 
    oprot.writeStructBegin('getVoucherAmount_result')
14436 
    if self.success is not None:
14437 
      oprot.writeFieldBegin('success', TType.I64, 0)
14438 
      oprot.writeI64(self.success)
14439 
      oprot.writeFieldEnd()
14440 
    oprot.writeFieldStop()
14441 
    oprot.writeStructEnd()
14442 
 
14443 
  def validate(self):
14444 
    return
14445 
 
14446 
 
14447 
  def __repr__(self):
14448 
    L = ['%s=%r' % (key, value)
14449 
      for key, value in self.__dict__.iteritems()]
14450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14451 
 
14452 
  def __eq__(self, other):
14453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14454 
 
14455 
  def __ne__(self, other):
14456 
    return not (self == other)
14457 
 
14458 
class getAllItemVouchers_args:
14459 
  """
14460 
  Attributes:
14461 
   - itemId
14462 
  """
14463 
 
14464 
  thrift_spec = (
14465 
    None, # 0
14466 
    (1, TType.I64, 'itemId', None, None, ), # 1
14467 
  )
14468 
 
14469 
  def __init__(self, itemId=None,):
14470 
    self.itemId = itemId
14471 
 
14472 
  def read(self, iprot):
14473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14475 
      return
14476 
    iprot.readStructBegin()
14477 
    while True:
14478 
      (fname, ftype, fid) = iprot.readFieldBegin()
14479 
      if ftype == TType.STOP:
14480 
        break
14481 
      if fid == 1:
14482 
        if ftype == TType.I64:
14483 
          self.itemId = iprot.readI64();
14484 
        else:
14485 
          iprot.skip(ftype)
14486 
      else:
14487 
        iprot.skip(ftype)
14488 
      iprot.readFieldEnd()
14489 
    iprot.readStructEnd()
14490 
 
14491 
  def write(self, oprot):
14492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14494 
      return
14495 
    oprot.writeStructBegin('getAllItemVouchers_args')
14496 
    if self.itemId is not None:
14497 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14498 
      oprot.writeI64(self.itemId)
14499 
      oprot.writeFieldEnd()
14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
14517 
 
14518 
class getAllItemVouchers_result:
14519 
  """
14520 
  Attributes:
14521 
   - success
14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14526 
  )
14527 
 
14528 
  def __init__(self, success=None,):
14529 
    self.success = success
14530 
 
14531 
  def read(self, iprot):
14532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14534 
      return
14535 
    iprot.readStructBegin()
14536 
    while True:
14537 
      (fname, ftype, fid) = iprot.readFieldBegin()
14538 
      if ftype == TType.STOP:
14539 
        break
14540 
      if fid == 0:
14541 
        if ftype == TType.LIST:
14542 
          self.success = []
7256 rajveer 14543 
          (_etype273, _size270) = iprot.readListBegin()
14544 
          for _i274 in xrange(_size270):
14545 
            _elem275 = VoucherItemMapping()
14546 
            _elem275.read(iprot)
14547 
            self.success.append(_elem275)
5944 mandeep.dh 14548 
          iprot.readListEnd()
14549 
        else:
14550 
          iprot.skip(ftype)
14551 
      else:
14552 
        iprot.skip(ftype)
14553 
      iprot.readFieldEnd()
14554 
    iprot.readStructEnd()
14555 
 
14556 
  def write(self, oprot):
14557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14559 
      return
14560 
    oprot.writeStructBegin('getAllItemVouchers_result')
14561 
    if self.success is not None:
14562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14563 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14564 
      for iter276 in self.success:
14565 
        iter276.write(oprot)
5944 mandeep.dh 14566 
      oprot.writeListEnd()
14567 
      oprot.writeFieldEnd()
14568 
    oprot.writeFieldStop()
14569 
    oprot.writeStructEnd()
14570 
 
14571 
  def validate(self):
14572 
    return
14573 
 
14574 
 
14575 
  def __repr__(self):
14576 
    L = ['%s=%r' % (key, value)
14577 
      for key, value in self.__dict__.iteritems()]
14578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14579 
 
14580 
  def __eq__(self, other):
14581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14582 
 
14583 
  def __ne__(self, other):
14584 
    return not (self == other)
14585 
 
14586 
class isValidCatalogItemId_args:
14587 
  """
14588 
  Attributes:
14589 
   - catalog_item_id
14590 
  """
14591 
 
14592 
  thrift_spec = (
14593 
    None, # 0
14594 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14595 
  )
14596 
 
14597 
  def __init__(self, catalog_item_id=None,):
14598 
    self.catalog_item_id = catalog_item_id
14599 
 
14600 
  def read(self, iprot):
14601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14603 
      return
14604 
    iprot.readStructBegin()
14605 
    while True:
14606 
      (fname, ftype, fid) = iprot.readFieldBegin()
14607 
      if ftype == TType.STOP:
14608 
        break
14609 
      if fid == 1:
14610 
        if ftype == TType.I64:
14611 
          self.catalog_item_id = iprot.readI64();
14612 
        else:
14613 
          iprot.skip(ftype)
14614 
      else:
14615 
        iprot.skip(ftype)
14616 
      iprot.readFieldEnd()
14617 
    iprot.readStructEnd()
14618 
 
14619 
  def write(self, oprot):
14620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14622 
      return
14623 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14624 
    if self.catalog_item_id is not None:
14625 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14626 
      oprot.writeI64(self.catalog_item_id)
14627 
      oprot.writeFieldEnd()
14628 
    oprot.writeFieldStop()
14629 
    oprot.writeStructEnd()
14630 
 
14631 
  def validate(self):
14632 
    return
14633 
 
14634 
 
14635 
  def __repr__(self):
14636 
    L = ['%s=%r' % (key, value)
14637 
      for key, value in self.__dict__.iteritems()]
14638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14639 
 
14640 
  def __eq__(self, other):
14641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14642 
 
14643 
  def __ne__(self, other):
14644 
    return not (self == other)
14645 
 
14646 
class isValidCatalogItemId_result:
14647 
  """
14648 
  Attributes:
14649 
   - success
14650 
  """
14651 
 
14652 
  thrift_spec = (
14653 
    (0, TType.BOOL, 'success', None, None, ), # 0
14654 
  )
14655 
 
14656 
  def __init__(self, success=None,):
14657 
    self.success = success
14658 
 
14659 
  def read(self, iprot):
14660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14662 
      return
14663 
    iprot.readStructBegin()
14664 
    while True:
14665 
      (fname, ftype, fid) = iprot.readFieldBegin()
14666 
      if ftype == TType.STOP:
14667 
        break
14668 
      if fid == 0:
14669 
        if ftype == TType.BOOL:
14670 
          self.success = iprot.readBool();
14671 
        else:
14672 
          iprot.skip(ftype)
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
14682 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14683 
    if self.success is not None:
14684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14685 
      oprot.writeBool(self.success)
14686 
      oprot.writeFieldEnd()
14687 
    oprot.writeFieldStop()
14688 
    oprot.writeStructEnd()
14689 
 
14690 
  def validate(self):
14691 
    return
14692 
 
14693 
 
14694 
  def __repr__(self):
14695 
    L = ['%s=%r' % (key, value)
14696 
      for key, value in self.__dict__.iteritems()]
14697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14698 
 
14699 
  def __eq__(self, other):
14700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14701 
 
14702 
  def __ne__(self, other):
14703 
    return not (self == other)
6039 amit.gupta 14704 
 
14705 
class getVatPercentageForItem_args:
14706 
  """
14707 
  Attributes:
14708 
   - itemId
14709 
   - price
14710 
  """
14711 
 
14712 
  thrift_spec = (
14713 
    None, # 0
14714 
    (1, TType.I64, 'itemId', None, None, ), # 1
14715 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
14716 
  )
14717 
 
14718 
  def __init__(self, itemId=None, price=None,):
14719 
    self.itemId = itemId
14720 
    self.price = price
14721 
 
14722 
  def read(self, iprot):
14723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14725 
      return
14726 
    iprot.readStructBegin()
14727 
    while True:
14728 
      (fname, ftype, fid) = iprot.readFieldBegin()
14729 
      if ftype == TType.STOP:
14730 
        break
14731 
      if fid == 1:
14732 
        if ftype == TType.I64:
14733 
          self.itemId = iprot.readI64();
14734 
        else:
14735 
          iprot.skip(ftype)
14736 
      elif fid == 2:
14737 
        if ftype == TType.DOUBLE:
14738 
          self.price = iprot.readDouble();
14739 
        else:
14740 
          iprot.skip(ftype)
14741 
      else:
14742 
        iprot.skip(ftype)
14743 
      iprot.readFieldEnd()
14744 
    iprot.readStructEnd()
14745 
 
14746 
  def write(self, oprot):
14747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14749 
      return
14750 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14751 
    if self.itemId is not None:
14752 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14753 
      oprot.writeI64(self.itemId)
14754 
      oprot.writeFieldEnd()
14755 
    if self.price is not None:
14756 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
14757 
      oprot.writeDouble(self.price)
14758 
      oprot.writeFieldEnd()
14759 
    oprot.writeFieldStop()
14760 
    oprot.writeStructEnd()
14761 
 
14762 
  def validate(self):
14763 
    return
14764 
 
14765 
 
14766 
  def __repr__(self):
14767 
    L = ['%s=%r' % (key, value)
14768 
      for key, value in self.__dict__.iteritems()]
14769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14770 
 
14771 
  def __eq__(self, other):
14772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14773 
 
14774 
  def __ne__(self, other):
14775 
    return not (self == other)
14776 
 
14777 
class getVatPercentageForItem_result:
14778 
  """
14779 
  Attributes:
14780 
   - success
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14785 
  )
14786 
 
14787 
  def __init__(self, success=None,):
14788 
    self.success = success
14789 
 
14790 
  def read(self, iprot):
14791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14793 
      return
14794 
    iprot.readStructBegin()
14795 
    while True:
14796 
      (fname, ftype, fid) = iprot.readFieldBegin()
14797 
      if ftype == TType.STOP:
14798 
        break
14799 
      if fid == 0:
14800 
        if ftype == TType.DOUBLE:
14801 
          self.success = iprot.readDouble();
14802 
        else:
14803 
          iprot.skip(ftype)
14804 
      else:
14805 
        iprot.skip(ftype)
14806 
      iprot.readFieldEnd()
14807 
    iprot.readStructEnd()
14808 
 
14809 
  def write(self, oprot):
14810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14812 
      return
14813 
    oprot.writeStructBegin('getVatPercentageForItem_result')
14814 
    if self.success is not None:
14815 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14816 
      oprot.writeDouble(self.success)
14817 
      oprot.writeFieldEnd()
14818 
    oprot.writeFieldStop()
14819 
    oprot.writeStructEnd()
14820 
 
14821 
  def validate(self):
14822 
    return
14823 
 
14824 
 
14825 
  def __repr__(self):
14826 
    L = ['%s=%r' % (key, value)
14827 
      for key, value in self.__dict__.iteritems()]
14828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14829 
 
14830 
  def __eq__(self, other):
14831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14832 
 
14833 
  def __ne__(self, other):
14834 
    return not (self == other)
14835 
 
14836 
class getVatAmountForItem_args:
14837 
  """
14838 
  Attributes:
14839 
   - itemId
14840 
   - price
14841 
  """
14842 
 
14843 
  thrift_spec = (
14844 
    None, # 0
14845 
    (1, TType.I64, 'itemId', None, None, ), # 1
14846 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
14847 
  )
14848 
 
14849 
  def __init__(self, itemId=None, price=None,):
14850 
    self.itemId = itemId
14851 
    self.price = price
14852 
 
14853 
  def read(self, iprot):
14854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14856 
      return
14857 
    iprot.readStructBegin()
14858 
    while True:
14859 
      (fname, ftype, fid) = iprot.readFieldBegin()
14860 
      if ftype == TType.STOP:
14861 
        break
14862 
      if fid == 1:
14863 
        if ftype == TType.I64:
14864 
          self.itemId = iprot.readI64();
14865 
        else:
14866 
          iprot.skip(ftype)
14867 
      elif fid == 2:
14868 
        if ftype == TType.DOUBLE:
14869 
          self.price = iprot.readDouble();
14870 
        else:
14871 
          iprot.skip(ftype)
14872 
      else:
14873 
        iprot.skip(ftype)
14874 
      iprot.readFieldEnd()
14875 
    iprot.readStructEnd()
14876 
 
14877 
  def write(self, oprot):
14878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14880 
      return
14881 
    oprot.writeStructBegin('getVatAmountForItem_args')
14882 
    if self.itemId is not None:
14883 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14884 
      oprot.writeI64(self.itemId)
14885 
      oprot.writeFieldEnd()
14886 
    if self.price is not None:
14887 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
14888 
      oprot.writeDouble(self.price)
14889 
      oprot.writeFieldEnd()
14890 
    oprot.writeFieldStop()
14891 
    oprot.writeStructEnd()
14892 
 
14893 
  def validate(self):
14894 
    return
14895 
 
14896 
 
14897 
  def __repr__(self):
14898 
    L = ['%s=%r' % (key, value)
14899 
      for key, value in self.__dict__.iteritems()]
14900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14901 
 
14902 
  def __eq__(self, other):
14903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14904 
 
14905 
  def __ne__(self, other):
14906 
    return not (self == other)
14907 
 
14908 
class getVatAmountForItem_result:
14909 
  """
14910 
  Attributes:
14911 
   - success
14912 
  """
14913 
 
14914 
  thrift_spec = (
14915 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14916 
  )
14917 
 
14918 
  def __init__(self, success=None,):
14919 
    self.success = success
14920 
 
14921 
  def read(self, iprot):
14922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14924 
      return
14925 
    iprot.readStructBegin()
14926 
    while True:
14927 
      (fname, ftype, fid) = iprot.readFieldBegin()
14928 
      if ftype == TType.STOP:
14929 
        break
14930 
      if fid == 0:
14931 
        if ftype == TType.DOUBLE:
14932 
          self.success = iprot.readDouble();
14933 
        else:
14934 
          iprot.skip(ftype)
14935 
      else:
14936 
        iprot.skip(ftype)
14937 
      iprot.readFieldEnd()
14938 
    iprot.readStructEnd()
14939 
 
14940 
  def write(self, oprot):
14941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14943 
      return
14944 
    oprot.writeStructBegin('getVatAmountForItem_result')
14945 
    if self.success is not None:
14946 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14947 
      oprot.writeDouble(self.success)
14948 
      oprot.writeFieldEnd()
14949 
    oprot.writeFieldStop()
14950 
    oprot.writeStructEnd()
14951 
 
14952 
  def validate(self):
14953 
    return
14954 
 
14955 
 
14956 
  def __repr__(self):
14957 
    L = ['%s=%r' % (key, value)
14958 
      for key, value in self.__dict__.iteritems()]
14959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14960 
 
14961 
  def __eq__(self, other):
14962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14963 
 
14964 
  def __ne__(self, other):
14965 
    return not (self == other)
6531 vikram.rag 14966 
 
14967 
class getAllIgnoredInventoryUpdateItemsList_args:
14968 
  """
14969 
  Attributes:
14970 
   - offset
14971 
   - limit
14972 
  """
14973 
 
14974 
  thrift_spec = (
14975 
    None, # 0
14976 
    (1, TType.I32, 'offset', None, None, ), # 1
14977 
    (2, TType.I32, 'limit', None, None, ), # 2
14978 
  )
14979 
 
14980 
  def __init__(self, offset=None, limit=None,):
14981 
    self.offset = offset
14982 
    self.limit = limit
14983 
 
14984 
  def read(self, iprot):
14985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14987 
      return
14988 
    iprot.readStructBegin()
14989 
    while True:
14990 
      (fname, ftype, fid) = iprot.readFieldBegin()
14991 
      if ftype == TType.STOP:
14992 
        break
14993 
      if fid == 1:
14994 
        if ftype == TType.I32:
14995 
          self.offset = iprot.readI32();
14996 
        else:
14997 
          iprot.skip(ftype)
14998 
      elif fid == 2:
14999 
        if ftype == TType.I32:
15000 
          self.limit = iprot.readI32();
15001 
        else:
15002 
          iprot.skip(ftype)
15003 
      else:
15004 
        iprot.skip(ftype)
15005 
      iprot.readFieldEnd()
15006 
    iprot.readStructEnd()
15007 
 
15008 
  def write(self, oprot):
15009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15011 
      return
15012 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15013 
    if self.offset is not None:
15014 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15015 
      oprot.writeI32(self.offset)
15016 
      oprot.writeFieldEnd()
15017 
    if self.limit is not None:
15018 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15019 
      oprot.writeI32(self.limit)
15020 
      oprot.writeFieldEnd()
15021 
    oprot.writeFieldStop()
15022 
    oprot.writeStructEnd()
15023 
 
15024 
  def validate(self):
15025 
    return
15026 
 
15027 
 
15028 
  def __repr__(self):
15029 
    L = ['%s=%r' % (key, value)
15030 
      for key, value in self.__dict__.iteritems()]
15031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15032 
 
15033 
  def __eq__(self, other):
15034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15035 
 
15036 
  def __ne__(self, other):
15037 
    return not (self == other)
15038 
 
15039 
class getAllIgnoredInventoryUpdateItemsList_result:
15040 
  """
15041 
  Attributes:
15042 
   - success
15043 
  """
15044 
 
15045 
  thrift_spec = (
15046 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15047 
  )
15048 
 
15049 
  def __init__(self, success=None,):
15050 
    self.success = success
15051 
 
15052 
  def read(self, iprot):
15053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15055 
      return
15056 
    iprot.readStructBegin()
15057 
    while True:
15058 
      (fname, ftype, fid) = iprot.readFieldBegin()
15059 
      if ftype == TType.STOP:
15060 
        break
15061 
      if fid == 0:
15062 
        if ftype == TType.LIST:
15063 
          self.success = []
7256 rajveer 15064 
          (_etype280, _size277) = iprot.readListBegin()
15065 
          for _i281 in xrange(_size277):
15066 
            _elem282 = Item()
15067 
            _elem282.read(iprot)
15068 
            self.success.append(_elem282)
6531 vikram.rag 15069 
          iprot.readListEnd()
15070 
        else:
15071 
          iprot.skip(ftype)
15072 
      else:
15073 
        iprot.skip(ftype)
15074 
      iprot.readFieldEnd()
15075 
    iprot.readStructEnd()
15076 
 
15077 
  def write(self, oprot):
15078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15080 
      return
15081 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15082 
    if self.success is not None:
15083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15085 
      for iter283 in self.success:
15086 
        iter283.write(oprot)
6531 vikram.rag 15087 
      oprot.writeListEnd()
15088 
      oprot.writeFieldEnd()
15089 
    oprot.writeFieldStop()
15090 
    oprot.writeStructEnd()
15091 
 
15092 
  def validate(self):
15093 
    return
15094 
 
15095 
 
15096 
  def __repr__(self):
15097 
    L = ['%s=%r' % (key, value)
15098 
      for key, value in self.__dict__.iteritems()]
15099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15100 
 
15101 
  def __eq__(self, other):
15102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15103 
 
15104 
  def __ne__(self, other):
15105 
    return not (self == other)
6805 anupam.sin 15106 
 
6821 amar.kumar 15107 
class getAllAliveItems_args:
15108 
 
15109 
  thrift_spec = (
15110 
  )
15111 
 
15112 
  def read(self, iprot):
15113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15115 
      return
15116 
    iprot.readStructBegin()
15117 
    while True:
15118 
      (fname, ftype, fid) = iprot.readFieldBegin()
15119 
      if ftype == TType.STOP:
15120 
        break
15121 
      else:
15122 
        iprot.skip(ftype)
15123 
      iprot.readFieldEnd()
15124 
    iprot.readStructEnd()
15125 
 
15126 
  def write(self, oprot):
15127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15129 
      return
15130 
    oprot.writeStructBegin('getAllAliveItems_args')
15131 
    oprot.writeFieldStop()
15132 
    oprot.writeStructEnd()
15133 
 
15134 
  def validate(self):
15135 
    return
15136 
 
15137 
 
15138 
  def __repr__(self):
15139 
    L = ['%s=%r' % (key, value)
15140 
      for key, value in self.__dict__.iteritems()]
15141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15142 
 
15143 
  def __eq__(self, other):
15144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15145 
 
15146 
  def __ne__(self, other):
15147 
    return not (self == other)
15148 
 
15149 
class getAllAliveItems_result:
15150 
  """
15151 
  Attributes:
15152 
   - success
15153 
  """
15154 
 
15155 
  thrift_spec = (
15156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15157 
  )
15158 
 
15159 
  def __init__(self, success=None,):
15160 
    self.success = success
15161 
 
15162 
  def read(self, iprot):
15163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15165 
      return
15166 
    iprot.readStructBegin()
15167 
    while True:
15168 
      (fname, ftype, fid) = iprot.readFieldBegin()
15169 
      if ftype == TType.STOP:
15170 
        break
15171 
      if fid == 0:
15172 
        if ftype == TType.LIST:
15173 
          self.success = []
7256 rajveer 15174 
          (_etype287, _size284) = iprot.readListBegin()
15175 
          for _i288 in xrange(_size284):
15176 
            _elem289 = Item()
15177 
            _elem289.read(iprot)
15178 
            self.success.append(_elem289)
6821 amar.kumar 15179 
          iprot.readListEnd()
15180 
        else:
15181 
          iprot.skip(ftype)
15182 
      else:
15183 
        iprot.skip(ftype)
15184 
      iprot.readFieldEnd()
15185 
    iprot.readStructEnd()
15186 
 
15187 
  def write(self, oprot):
15188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15190 
      return
15191 
    oprot.writeStructBegin('getAllAliveItems_result')
15192 
    if self.success is not None:
15193 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15194 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15195 
      for iter290 in self.success:
15196 
        iter290.write(oprot)
6821 amar.kumar 15197 
      oprot.writeListEnd()
15198 
      oprot.writeFieldEnd()
15199 
    oprot.writeFieldStop()
15200 
    oprot.writeStructEnd()
15201 
 
15202 
  def validate(self):
15203 
    return
15204 
 
15205 
 
15206 
  def __repr__(self):
15207 
    L = ['%s=%r' % (key, value)
15208 
      for key, value in self.__dict__.iteritems()]
15209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15210 
 
15211 
  def __eq__(self, other):
15212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15213 
 
15214 
  def __ne__(self, other):
15215 
    return not (self == other)
15216 
 
6805 anupam.sin 15217 
class getInsuranceAmount_args:
15218 
  """
15219 
  Attributes:
15220 
   - itemId
6921 anupam.sin 15221 
   - price
6805 anupam.sin 15222 
   - insurerId
15223 
   - quantity
15224 
  """
15225 
 
15226 
  thrift_spec = (
15227 
    None, # 0
15228 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15229 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15230 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15231 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15232 
  )
15233 
 
6921 anupam.sin 15234 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15235 
    self.itemId = itemId
6921 anupam.sin 15236 
    self.price = price
6805 anupam.sin 15237 
    self.insurerId = insurerId
15238 
    self.quantity = quantity
15239 
 
15240 
  def read(self, iprot):
15241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15243 
      return
15244 
    iprot.readStructBegin()
15245 
    while True:
15246 
      (fname, ftype, fid) = iprot.readFieldBegin()
15247 
      if ftype == TType.STOP:
15248 
        break
15249 
      if fid == 1:
15250 
        if ftype == TType.I64:
15251 
          self.itemId = iprot.readI64();
15252 
        else:
15253 
          iprot.skip(ftype)
15254 
      elif fid == 2:
6921 anupam.sin 15255 
        if ftype == TType.DOUBLE:
15256 
          self.price = iprot.readDouble();
15257 
        else:
15258 
          iprot.skip(ftype)
15259 
      elif fid == 3:
6805 anupam.sin 15260 
        if ftype == TType.I64:
15261 
          self.insurerId = iprot.readI64();
15262 
        else:
15263 
          iprot.skip(ftype)
6921 anupam.sin 15264 
      elif fid == 4:
6805 anupam.sin 15265 
        if ftype == TType.I64:
15266 
          self.quantity = iprot.readI64();
15267 
        else:
15268 
          iprot.skip(ftype)
15269 
      else:
15270 
        iprot.skip(ftype)
15271 
      iprot.readFieldEnd()
15272 
    iprot.readStructEnd()
15273 
 
15274 
  def write(self, oprot):
15275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15277 
      return
15278 
    oprot.writeStructBegin('getInsuranceAmount_args')
15279 
    if self.itemId is not None:
15280 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15281 
      oprot.writeI64(self.itemId)
15282 
      oprot.writeFieldEnd()
6921 anupam.sin 15283 
    if self.price is not None:
15284 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15285 
      oprot.writeDouble(self.price)
15286 
      oprot.writeFieldEnd()
6805 anupam.sin 15287 
    if self.insurerId is not None:
6921 anupam.sin 15288 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15289 
      oprot.writeI64(self.insurerId)
15290 
      oprot.writeFieldEnd()
15291 
    if self.quantity is not None:
6921 anupam.sin 15292 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15293 
      oprot.writeI64(self.quantity)
15294 
      oprot.writeFieldEnd()
15295 
    oprot.writeFieldStop()
15296 
    oprot.writeStructEnd()
15297 
 
15298 
  def validate(self):
15299 
    return
15300 
 
15301 
 
15302 
  def __repr__(self):
15303 
    L = ['%s=%r' % (key, value)
15304 
      for key, value in self.__dict__.iteritems()]
15305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15306 
 
15307 
  def __eq__(self, other):
15308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15309 
 
15310 
  def __ne__(self, other):
15311 
    return not (self == other)
15312 
 
15313 
class getInsuranceAmount_result:
15314 
  """
15315 
  Attributes:
15316 
   - success
15317 
  """
15318 
 
15319 
  thrift_spec = (
15320 
    (0, TType.I64, 'success', None, None, ), # 0
15321 
  )
15322 
 
15323 
  def __init__(self, success=None,):
15324 
    self.success = success
15325 
 
15326 
  def read(self, iprot):
15327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15329 
      return
15330 
    iprot.readStructBegin()
15331 
    while True:
15332 
      (fname, ftype, fid) = iprot.readFieldBegin()
15333 
      if ftype == TType.STOP:
15334 
        break
15335 
      if fid == 0:
15336 
        if ftype == TType.I64:
15337 
          self.success = iprot.readI64();
15338 
        else:
15339 
          iprot.skip(ftype)
15340 
      else:
15341 
        iprot.skip(ftype)
15342 
      iprot.readFieldEnd()
15343 
    iprot.readStructEnd()
15344 
 
15345 
  def write(self, oprot):
15346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15348 
      return
15349 
    oprot.writeStructBegin('getInsuranceAmount_result')
15350 
    if self.success is not None:
15351 
      oprot.writeFieldBegin('success', TType.I64, 0)
15352 
      oprot.writeI64(self.success)
15353 
      oprot.writeFieldEnd()
15354 
    oprot.writeFieldStop()
15355 
    oprot.writeStructEnd()
15356 
 
15357 
  def validate(self):
15358 
    return
15359 
 
15360 
 
15361 
  def __repr__(self):
15362 
    L = ['%s=%r' % (key, value)
15363 
      for key, value in self.__dict__.iteritems()]
15364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15365 
 
15366 
  def __eq__(self, other):
15367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15368 
 
15369 
  def __ne__(self, other):
15370 
    return not (self == other)
15371 
 
15372 
class getInsurer_args:
15373 
  """
15374 
  Attributes:
15375 
   - insurerId
15376 
  """
15377 
 
15378 
  thrift_spec = (
15379 
    None, # 0
15380 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15381 
  )
15382 
 
15383 
  def __init__(self, insurerId=None,):
15384 
    self.insurerId = insurerId
15385 
 
15386 
  def read(self, iprot):
15387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15389 
      return
15390 
    iprot.readStructBegin()
15391 
    while True:
15392 
      (fname, ftype, fid) = iprot.readFieldBegin()
15393 
      if ftype == TType.STOP:
15394 
        break
15395 
      if fid == 1:
15396 
        if ftype == TType.I64:
15397 
          self.insurerId = iprot.readI64();
15398 
        else:
15399 
          iprot.skip(ftype)
15400 
      else:
15401 
        iprot.skip(ftype)
15402 
      iprot.readFieldEnd()
15403 
    iprot.readStructEnd()
15404 
 
15405 
  def write(self, oprot):
15406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15408 
      return
15409 
    oprot.writeStructBegin('getInsurer_args')
15410 
    if self.insurerId is not None:
15411 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15412 
      oprot.writeI64(self.insurerId)
15413 
      oprot.writeFieldEnd()
15414 
    oprot.writeFieldStop()
15415 
    oprot.writeStructEnd()
15416 
 
15417 
  def validate(self):
15418 
    return
15419 
 
15420 
 
15421 
  def __repr__(self):
15422 
    L = ['%s=%r' % (key, value)
15423 
      for key, value in self.__dict__.iteritems()]
15424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15425 
 
15426 
  def __eq__(self, other):
15427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15428 
 
15429 
  def __ne__(self, other):
15430 
    return not (self == other)
15431 
 
15432 
class getInsurer_result:
15433 
  """
15434 
  Attributes:
15435 
   - success
15436 
  """
15437 
 
15438 
  thrift_spec = (
15439 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15440 
  )
15441 
 
15442 
  def __init__(self, success=None,):
15443 
    self.success = success
15444 
 
15445 
  def read(self, iprot):
15446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15448 
      return
15449 
    iprot.readStructBegin()
15450 
    while True:
15451 
      (fname, ftype, fid) = iprot.readFieldBegin()
15452 
      if ftype == TType.STOP:
15453 
        break
15454 
      if fid == 0:
15455 
        if ftype == TType.STRUCT:
15456 
          self.success = Insurer()
15457 
          self.success.read(iprot)
15458 
        else:
15459 
          iprot.skip(ftype)
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('getInsurer_result')
15470 
    if self.success is not None:
15471 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15472 
      self.success.write(oprot)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
6838 vikram.rag 15491 
 
15492 
class getAllInsurers_args:
15493 
 
15494 
  thrift_spec = (
15495 
  )
15496 
 
15497 
  def read(self, iprot):
15498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15500 
      return
15501 
    iprot.readStructBegin()
15502 
    while True:
15503 
      (fname, ftype, fid) = iprot.readFieldBegin()
15504 
      if ftype == TType.STOP:
15505 
        break
15506 
      else:
15507 
        iprot.skip(ftype)
15508 
      iprot.readFieldEnd()
15509 
    iprot.readStructEnd()
15510 
 
15511 
  def write(self, oprot):
15512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15514 
      return
15515 
    oprot.writeStructBegin('getAllInsurers_args')
15516 
    oprot.writeFieldStop()
15517 
    oprot.writeStructEnd()
15518 
 
15519 
  def validate(self):
15520 
    return
15521 
 
15522 
 
15523 
  def __repr__(self):
15524 
    L = ['%s=%r' % (key, value)
15525 
      for key, value in self.__dict__.iteritems()]
15526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15527 
 
15528 
  def __eq__(self, other):
15529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15530 
 
15531 
  def __ne__(self, other):
15532 
    return not (self == other)
15533 
 
15534 
class getAllInsurers_result:
15535 
  """
15536 
  Attributes:
15537 
   - success
15538 
  """
15539 
 
15540 
  thrift_spec = (
15541 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15542 
  )
15543 
 
15544 
  def __init__(self, success=None,):
15545 
    self.success = success
15546 
 
15547 
  def read(self, iprot):
15548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15550 
      return
15551 
    iprot.readStructBegin()
15552 
    while True:
15553 
      (fname, ftype, fid) = iprot.readFieldBegin()
15554 
      if ftype == TType.STOP:
15555 
        break
15556 
      if fid == 0:
15557 
        if ftype == TType.LIST:
15558 
          self.success = []
7256 rajveer 15559 
          (_etype294, _size291) = iprot.readListBegin()
15560 
          for _i295 in xrange(_size291):
15561 
            _elem296 = Insurer()
15562 
            _elem296.read(iprot)
15563 
            self.success.append(_elem296)
6838 vikram.rag 15564 
          iprot.readListEnd()
15565 
        else:
15566 
          iprot.skip(ftype)
15567 
      else:
15568 
        iprot.skip(ftype)
15569 
      iprot.readFieldEnd()
15570 
    iprot.readStructEnd()
15571 
 
15572 
  def write(self, oprot):
15573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15575 
      return
15576 
    oprot.writeStructBegin('getAllInsurers_result')
15577 
    if self.success is not None:
15578 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15579 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15580 
      for iter297 in self.success:
15581 
        iter297.write(oprot)
6838 vikram.rag 15582 
      oprot.writeListEnd()
15583 
      oprot.writeFieldEnd()
15584 
    oprot.writeFieldStop()
15585 
    oprot.writeStructEnd()
15586 
 
15587 
  def validate(self):
15588 
    return
15589 
 
15590 
 
15591 
  def __repr__(self):
15592 
    L = ['%s=%r' % (key, value)
15593 
      for key, value in self.__dict__.iteritems()]
15594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15595 
 
15596 
  def __eq__(self, other):
15597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15598 
 
15599 
  def __ne__(self, other):
15600 
    return not (self == other)
6962 rajveer 15601 
 
15602 
class updateInsuranceDeclaredAmount_args:
15603 
  """
15604 
  Attributes:
15605 
   - insurerId
15606 
   - amount
15607 
  """
15608 
 
15609 
  thrift_spec = (
15610 
    None, # 0
15611 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15612 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15613 
  )
15614 
 
15615 
  def __init__(self, insurerId=None, amount=None,):
15616 
    self.insurerId = insurerId
15617 
    self.amount = amount
15618 
 
15619 
  def read(self, iprot):
15620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15622 
      return
15623 
    iprot.readStructBegin()
15624 
    while True:
15625 
      (fname, ftype, fid) = iprot.readFieldBegin()
15626 
      if ftype == TType.STOP:
15627 
        break
15628 
      if fid == 1:
15629 
        if ftype == TType.I64:
15630 
          self.insurerId = iprot.readI64();
15631 
        else:
15632 
          iprot.skip(ftype)
15633 
      elif fid == 2:
15634 
        if ftype == TType.DOUBLE:
15635 
          self.amount = iprot.readDouble();
15636 
        else:
15637 
          iprot.skip(ftype)
15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
15647 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15648 
    if self.insurerId is not None:
15649 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15650 
      oprot.writeI64(self.insurerId)
15651 
      oprot.writeFieldEnd()
15652 
    if self.amount is not None:
15653 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15654 
      oprot.writeDouble(self.amount)
15655 
      oprot.writeFieldEnd()
15656 
    oprot.writeFieldStop()
15657 
    oprot.writeStructEnd()
15658 
 
15659 
  def validate(self):
15660 
    return
15661 
 
15662 
 
15663 
  def __repr__(self):
15664 
    L = ['%s=%r' % (key, value)
15665 
      for key, value in self.__dict__.iteritems()]
15666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15667 
 
15668 
  def __eq__(self, other):
15669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15670 
 
15671 
  def __ne__(self, other):
15672 
    return not (self == other)
15673 
 
15674 
class updateInsuranceDeclaredAmount_result:
15675 
 
15676 
  thrift_spec = (
15677 
  )
15678 
 
15679 
  def read(self, iprot):
15680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15682 
      return
15683 
    iprot.readStructBegin()
15684 
    while True:
15685 
      (fname, ftype, fid) = iprot.readFieldBegin()
15686 
      if ftype == TType.STOP:
15687 
        break
15688 
      else:
15689 
        iprot.skip(ftype)
15690 
      iprot.readFieldEnd()
15691 
    iprot.readStructEnd()
15692 
 
15693 
  def write(self, oprot):
15694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15696 
      return
15697 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15698 
    oprot.writeFieldStop()
15699 
    oprot.writeStructEnd()
15700 
 
15701 
  def validate(self):
15702 
    return
15703 
 
15704 
 
15705 
  def __repr__(self):
15706 
    L = ['%s=%r' % (key, value)
15707 
      for key, value in self.__dict__.iteritems()]
15708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15709 
 
15710 
  def __eq__(self, other):
15711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15712 
 
15713 
  def __ne__(self, other):
15714 
    return not (self == other)
7190 amar.kumar 15715 
 
15716 
class getFreebieForItem_args:
15717 
  """
15718 
  Attributes:
15719 
   - itemId
15720 
  """
15721 
 
15722 
  thrift_spec = (
15723 
    None, # 0
15724 
    (1, TType.I64, 'itemId', None, None, ), # 1
15725 
  )
15726 
 
15727 
  def __init__(self, itemId=None,):
15728 
    self.itemId = itemId
15729 
 
15730 
  def read(self, iprot):
15731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15733 
      return
15734 
    iprot.readStructBegin()
15735 
    while True:
15736 
      (fname, ftype, fid) = iprot.readFieldBegin()
15737 
      if ftype == TType.STOP:
15738 
        break
15739 
      if fid == 1:
15740 
        if ftype == TType.I64:
15741 
          self.itemId = iprot.readI64();
15742 
        else:
15743 
          iprot.skip(ftype)
15744 
      else:
15745 
        iprot.skip(ftype)
15746 
      iprot.readFieldEnd()
15747 
    iprot.readStructEnd()
15748 
 
15749 
  def write(self, oprot):
15750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15752 
      return
15753 
    oprot.writeStructBegin('getFreebieForItem_args')
15754 
    if self.itemId is not None:
15755 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15756 
      oprot.writeI64(self.itemId)
15757 
      oprot.writeFieldEnd()
15758 
    oprot.writeFieldStop()
15759 
    oprot.writeStructEnd()
15760 
 
15761 
  def validate(self):
15762 
    return
15763 
 
15764 
 
15765 
  def __repr__(self):
15766 
    L = ['%s=%r' % (key, value)
15767 
      for key, value in self.__dict__.iteritems()]
15768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15769 
 
15770 
  def __eq__(self, other):
15771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15772 
 
15773 
  def __ne__(self, other):
15774 
    return not (self == other)
15775 
 
15776 
class getFreebieForItem_result:
15777 
  """
15778 
  Attributes:
15779 
   - success
15780 
  """
15781 
 
15782 
  thrift_spec = (
15783 
    (0, TType.I64, 'success', None, None, ), # 0
15784 
  )
15785 
 
15786 
  def __init__(self, success=None,):
15787 
    self.success = success
15788 
 
15789 
  def read(self, iprot):
15790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15792 
      return
15793 
    iprot.readStructBegin()
15794 
    while True:
15795 
      (fname, ftype, fid) = iprot.readFieldBegin()
15796 
      if ftype == TType.STOP:
15797 
        break
15798 
      if fid == 0:
15799 
        if ftype == TType.I64:
15800 
          self.success = iprot.readI64();
15801 
        else:
15802 
          iprot.skip(ftype)
15803 
      else:
15804 
        iprot.skip(ftype)
15805 
      iprot.readFieldEnd()
15806 
    iprot.readStructEnd()
15807 
 
15808 
  def write(self, oprot):
15809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15811 
      return
15812 
    oprot.writeStructBegin('getFreebieForItem_result')
15813 
    if self.success is not None:
15814 
      oprot.writeFieldBegin('success', TType.I64, 0)
15815 
      oprot.writeI64(self.success)
15816 
      oprot.writeFieldEnd()
15817 
    oprot.writeFieldStop()
15818 
    oprot.writeStructEnd()
15819 
 
15820 
  def validate(self):
15821 
    return
15822 
 
15823 
 
15824 
  def __repr__(self):
15825 
    L = ['%s=%r' % (key, value)
15826 
      for key, value in self.__dict__.iteritems()]
15827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15828 
 
15829 
  def __eq__(self, other):
15830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15831 
 
15832 
  def __ne__(self, other):
15833 
    return not (self == other)
15834 
 
15835 
class addOrUpdateFreebieForItem_args:
15836 
  """
15837 
  Attributes:
15838 
   - freebieItem
15839 
  """
15840 
 
15841 
  thrift_spec = (
15842 
    None, # 0
15843 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
15844 
  )
15845 
 
15846 
  def __init__(self, freebieItem=None,):
15847 
    self.freebieItem = freebieItem
15848 
 
15849 
  def read(self, iprot):
15850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15852 
      return
15853 
    iprot.readStructBegin()
15854 
    while True:
15855 
      (fname, ftype, fid) = iprot.readFieldBegin()
15856 
      if ftype == TType.STOP:
15857 
        break
15858 
      if fid == 1:
15859 
        if ftype == TType.STRUCT:
15860 
          self.freebieItem = FreebieItem()
15861 
          self.freebieItem.read(iprot)
15862 
        else:
15863 
          iprot.skip(ftype)
15864 
      else:
15865 
        iprot.skip(ftype)
15866 
      iprot.readFieldEnd()
15867 
    iprot.readStructEnd()
15868 
 
15869 
  def write(self, oprot):
15870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15872 
      return
15873 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
15874 
    if self.freebieItem is not None:
15875 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
15876 
      self.freebieItem.write(oprot)
15877 
      oprot.writeFieldEnd()
15878 
    oprot.writeFieldStop()
15879 
    oprot.writeStructEnd()
15880 
 
15881 
  def validate(self):
15882 
    return
15883 
 
15884 
 
15885 
  def __repr__(self):
15886 
    L = ['%s=%r' % (key, value)
15887 
      for key, value in self.__dict__.iteritems()]
15888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15889 
 
15890 
  def __eq__(self, other):
15891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15892 
 
15893 
  def __ne__(self, other):
15894 
    return not (self == other)
15895 
 
15896 
class addOrUpdateFreebieForItem_result:
15897 
 
15898 
  thrift_spec = (
15899 
  )
15900 
 
15901 
  def read(self, iprot):
15902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15904 
      return
15905 
    iprot.readStructBegin()
15906 
    while True:
15907 
      (fname, ftype, fid) = iprot.readFieldBegin()
15908 
      if ftype == TType.STOP:
15909 
        break
15910 
      else:
15911 
        iprot.skip(ftype)
15912 
      iprot.readFieldEnd()
15913 
    iprot.readStructEnd()
15914 
 
15915 
  def write(self, oprot):
15916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15918 
      return
15919 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
15920 
    oprot.writeFieldStop()
15921 
    oprot.writeStructEnd()
15922 
 
15923 
  def validate(self):
15924 
    return
15925 
 
15926 
 
15927 
  def __repr__(self):
15928 
    L = ['%s=%r' % (key, value)
15929 
      for key, value in self.__dict__.iteritems()]
15930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15931 
 
15932 
  def __eq__(self, other):
15933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15934 
 
15935 
  def __ne__(self, other):
15936 
    return not (self == other)
7256 rajveer 15937 
 
7272 amit.gupta 15938 
class addOrUpdateBrandInfo_args:
15939 
  """
15940 
  Attributes:
15941 
   - brandInfo
15942 
  """
15943 
 
15944 
  thrift_spec = (
15945 
    None, # 0
15946 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
15947 
  )
15948 
 
15949 
  def __init__(self, brandInfo=None,):
15950 
    self.brandInfo = brandInfo
15951 
 
15952 
  def read(self, iprot):
15953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15955 
      return
15956 
    iprot.readStructBegin()
15957 
    while True:
15958 
      (fname, ftype, fid) = iprot.readFieldBegin()
15959 
      if ftype == TType.STOP:
15960 
        break
15961 
      if fid == 1:
15962 
        if ftype == TType.STRUCT:
15963 
          self.brandInfo = BrandInfo()
15964 
          self.brandInfo.read(iprot)
15965 
        else:
15966 
          iprot.skip(ftype)
15967 
      else:
15968 
        iprot.skip(ftype)
15969 
      iprot.readFieldEnd()
15970 
    iprot.readStructEnd()
15971 
 
15972 
  def write(self, oprot):
15973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15975 
      return
15976 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
15977 
    if self.brandInfo is not None:
15978 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
15979 
      self.brandInfo.write(oprot)
15980 
      oprot.writeFieldEnd()
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
15999 
class addOrUpdateBrandInfo_result:
16000 
 
16001 
  thrift_spec = (
16002 
  )
16003 
 
16004 
  def read(self, iprot):
16005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16007 
      return
16008 
    iprot.readStructBegin()
16009 
    while True:
16010 
      (fname, ftype, fid) = iprot.readFieldBegin()
16011 
      if ftype == TType.STOP:
16012 
        break
16013 
      else:
16014 
        iprot.skip(ftype)
16015 
      iprot.readFieldEnd()
16016 
    iprot.readStructEnd()
16017 
 
16018 
  def write(self, oprot):
16019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16021 
      return
16022 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16023 
    oprot.writeFieldStop()
16024 
    oprot.writeStructEnd()
16025 
 
16026 
  def validate(self):
16027 
    return
16028 
 
16029 
 
16030 
  def __repr__(self):
16031 
    L = ['%s=%r' % (key, value)
16032 
      for key, value in self.__dict__.iteritems()]
16033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16034 
 
16035 
  def __eq__(self, other):
16036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16037 
 
16038 
  def __ne__(self, other):
16039 
    return not (self == other)
16040 
 
16041 
class getBrandInfo_args:
16042 
 
16043 
  thrift_spec = (
16044 
  )
16045 
 
16046 
  def read(self, iprot):
16047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16049 
      return
16050 
    iprot.readStructBegin()
16051 
    while True:
16052 
      (fname, ftype, fid) = iprot.readFieldBegin()
16053 
      if ftype == TType.STOP:
16054 
        break
16055 
      else:
16056 
        iprot.skip(ftype)
16057 
      iprot.readFieldEnd()
16058 
    iprot.readStructEnd()
16059 
 
16060 
  def write(self, oprot):
16061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16063 
      return
16064 
    oprot.writeStructBegin('getBrandInfo_args')
16065 
    oprot.writeFieldStop()
16066 
    oprot.writeStructEnd()
16067 
 
16068 
  def validate(self):
16069 
    return
16070 
 
16071 
 
16072 
  def __repr__(self):
16073 
    L = ['%s=%r' % (key, value)
16074 
      for key, value in self.__dict__.iteritems()]
16075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16076 
 
16077 
  def __eq__(self, other):
16078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16079 
 
16080 
  def __ne__(self, other):
16081 
    return not (self == other)
16082 
 
16083 
class getBrandInfo_result:
16084 
  """
16085 
  Attributes:
16086 
   - success
16087 
  """
16088 
 
16089 
  thrift_spec = (
16090 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16091 
  )
16092 
 
16093 
  def __init__(self, success=None,):
16094 
    self.success = success
16095 
 
16096 
  def read(self, iprot):
16097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16099 
      return
16100 
    iprot.readStructBegin()
16101 
    while True:
16102 
      (fname, ftype, fid) = iprot.readFieldBegin()
16103 
      if ftype == TType.STOP:
16104 
        break
16105 
      if fid == 0:
16106 
        if ftype == TType.MAP:
16107 
          self.success = {}
16108 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16109 
          for _i302 in xrange(_size298):
16110 
            _key303 = iprot.readString();
16111 
            _val304 = BrandInfo()
16112 
            _val304.read(iprot)
16113 
            self.success[_key303] = _val304
16114 
          iprot.readMapEnd()
16115 
        else:
16116 
          iprot.skip(ftype)
16117 
      else:
16118 
        iprot.skip(ftype)
16119 
      iprot.readFieldEnd()
16120 
    iprot.readStructEnd()
16121 
 
16122 
  def write(self, oprot):
16123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16125 
      return
16126 
    oprot.writeStructBegin('getBrandInfo_result')
16127 
    if self.success is not None:
16128 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16129 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16130 
      for kiter305,viter306 in self.success.items():
16131 
        oprot.writeString(kiter305)
16132 
        viter306.write(oprot)
16133 
      oprot.writeMapEnd()
16134 
      oprot.writeFieldEnd()
16135 
    oprot.writeFieldStop()
16136 
    oprot.writeStructEnd()
16137 
 
16138 
  def validate(self):
16139 
    return
16140 
 
16141 
 
16142 
  def __repr__(self):
16143 
    L = ['%s=%r' % (key, value)
16144 
      for key, value in self.__dict__.iteritems()]
16145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16146 
 
16147 
  def __eq__(self, other):
16148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16149 
 
16150 
  def __ne__(self, other):
16151 
    return not (self == other)
16152 
 
7256 rajveer 16153 
class getStorePricing_args:
16154 
  """
16155 
  Attributes:
16156 
   - itemId
16157 
  """
16158 
 
16159 
  thrift_spec = (
16160 
    None, # 0
16161 
    (1, TType.I64, 'itemId', None, None, ), # 1
16162 
  )
16163 
 
16164 
  def __init__(self, itemId=None,):
16165 
    self.itemId = itemId
16166 
 
16167 
  def read(self, iprot):
16168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16170 
      return
16171 
    iprot.readStructBegin()
16172 
    while True:
16173 
      (fname, ftype, fid) = iprot.readFieldBegin()
16174 
      if ftype == TType.STOP:
16175 
        break
16176 
      if fid == 1:
16177 
        if ftype == TType.I64:
16178 
          self.itemId = iprot.readI64();
16179 
        else:
16180 
          iprot.skip(ftype)
16181 
      else:
16182 
        iprot.skip(ftype)
16183 
      iprot.readFieldEnd()
16184 
    iprot.readStructEnd()
16185 
 
16186 
  def write(self, oprot):
16187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16189 
      return
16190 
    oprot.writeStructBegin('getStorePricing_args')
16191 
    if self.itemId is not None:
16192 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16193 
      oprot.writeI64(self.itemId)
16194 
      oprot.writeFieldEnd()
16195 
    oprot.writeFieldStop()
16196 
    oprot.writeStructEnd()
16197 
 
16198 
  def validate(self):
16199 
    return
16200 
 
16201 
 
16202 
  def __repr__(self):
16203 
    L = ['%s=%r' % (key, value)
16204 
      for key, value in self.__dict__.iteritems()]
16205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16206 
 
16207 
  def __eq__(self, other):
16208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16209 
 
16210 
  def __ne__(self, other):
16211 
    return not (self == other)
16212 
 
16213 
class getStorePricing_result:
16214 
  """
16215 
  Attributes:
16216 
   - success
16217 
  """
16218 
 
16219 
  thrift_spec = (
16220 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16221 
  )
16222 
 
16223 
  def __init__(self, success=None,):
16224 
    self.success = success
16225 
 
16226 
  def read(self, iprot):
16227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16229 
      return
16230 
    iprot.readStructBegin()
16231 
    while True:
16232 
      (fname, ftype, fid) = iprot.readFieldBegin()
16233 
      if ftype == TType.STOP:
16234 
        break
16235 
      if fid == 0:
16236 
        if ftype == TType.STRUCT:
16237 
          self.success = StorePricing()
16238 
          self.success.read(iprot)
16239 
        else:
16240 
          iprot.skip(ftype)
16241 
      else:
16242 
        iprot.skip(ftype)
16243 
      iprot.readFieldEnd()
16244 
    iprot.readStructEnd()
16245 
 
16246 
  def write(self, oprot):
16247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16249 
      return
16250 
    oprot.writeStructBegin('getStorePricing_result')
16251 
    if self.success is not None:
16252 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16253 
      self.success.write(oprot)
16254 
      oprot.writeFieldEnd()
16255 
    oprot.writeFieldStop()
16256 
    oprot.writeStructEnd()
16257 
 
16258 
  def validate(self):
16259 
    return
16260 
 
16261 
 
16262 
  def __repr__(self):
16263 
    L = ['%s=%r' % (key, value)
16264 
      for key, value in self.__dict__.iteritems()]
16265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16266 
 
16267 
  def __eq__(self, other):
16268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16269 
 
16270 
  def __ne__(self, other):
16271 
    return not (self == other)
7265 rajveer 16272 
 
16273 
class updateStorePricing_args:
16274 
  """
16275 
  Attributes:
16276 
   - sp
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    None, # 0
16281 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16282 
  )
16283 
 
16284 
  def __init__(self, sp=None,):
16285 
    self.sp = sp
16286 
 
16287 
  def read(self, iprot):
16288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16290 
      return
16291 
    iprot.readStructBegin()
16292 
    while True:
16293 
      (fname, ftype, fid) = iprot.readFieldBegin()
16294 
      if ftype == TType.STOP:
16295 
        break
16296 
      if fid == 1:
16297 
        if ftype == TType.STRUCT:
16298 
          self.sp = StorePricing()
16299 
          self.sp.read(iprot)
16300 
        else:
16301 
          iprot.skip(ftype)
16302 
      else:
16303 
        iprot.skip(ftype)
16304 
      iprot.readFieldEnd()
16305 
    iprot.readStructEnd()
16306 
 
16307 
  def write(self, oprot):
16308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16310 
      return
16311 
    oprot.writeStructBegin('updateStorePricing_args')
16312 
    if self.sp is not None:
16313 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16314 
      self.sp.write(oprot)
16315 
      oprot.writeFieldEnd()
16316 
    oprot.writeFieldStop()
16317 
    oprot.writeStructEnd()
16318 
 
16319 
  def validate(self):
16320 
    return
16321 
 
16322 
 
16323 
  def __repr__(self):
16324 
    L = ['%s=%r' % (key, value)
16325 
      for key, value in self.__dict__.iteritems()]
16326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16327 
 
16328 
  def __eq__(self, other):
16329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16330 
 
16331 
  def __ne__(self, other):
16332 
    return not (self == other)
16333 
 
16334 
class updateStorePricing_result:
16335 
 
16336 
  thrift_spec = (
16337 
  )
16338 
 
16339 
  def read(self, iprot):
16340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16342 
      return
16343 
    iprot.readStructBegin()
16344 
    while True:
16345 
      (fname, ftype, fid) = iprot.readFieldBegin()
16346 
      if ftype == TType.STOP:
16347 
        break
16348 
      else:
16349 
        iprot.skip(ftype)
16350 
      iprot.readFieldEnd()
16351 
    iprot.readStructEnd()
16352 
 
16353 
  def write(self, oprot):
16354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16356 
      return
16357 
    oprot.writeStructBegin('updateStorePricing_result')
16358 
    oprot.writeFieldStop()
16359 
    oprot.writeStructEnd()
16360 
 
16361 
  def validate(self):
16362 
    return
16363 
 
16364 
 
16365 
  def __repr__(self):
16366 
    L = ['%s=%r' % (key, value)
16367 
      for key, value in self.__dict__.iteritems()]
16368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16369 
 
16370 
  def __eq__(self, other):
16371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16372 
 
16373 
  def __ne__(self, other):
16374 
    return not (self == other)
7281 kshitij.so 16375 
 
16376 
class getAllAmazonListedItems_args:
16377 
 
16378 
  thrift_spec = (
16379 
  )
16380 
 
16381 
  def read(self, iprot):
16382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16384 
      return
16385 
    iprot.readStructBegin()
16386 
    while True:
16387 
      (fname, ftype, fid) = iprot.readFieldBegin()
16388 
      if ftype == TType.STOP:
16389 
        break
16390 
      else:
16391 
        iprot.skip(ftype)
16392 
      iprot.readFieldEnd()
16393 
    iprot.readStructEnd()
16394 
 
16395 
  def write(self, oprot):
16396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16398 
      return
16399 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16400 
    oprot.writeFieldStop()
16401 
    oprot.writeStructEnd()
16402 
 
16403 
  def validate(self):
16404 
    return
16405 
 
16406 
 
16407 
  def __repr__(self):
16408 
    L = ['%s=%r' % (key, value)
16409 
      for key, value in self.__dict__.iteritems()]
16410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16411 
 
16412 
  def __eq__(self, other):
16413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16414 
 
16415 
  def __ne__(self, other):
16416 
    return not (self == other)
16417 
 
16418 
class getAllAmazonListedItems_result:
16419 
  """
16420 
  Attributes:
16421 
   - success
16422 
  """
16423 
 
16424 
  thrift_spec = (
16425 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16426 
  )
16427 
 
16428 
  def __init__(self, success=None,):
16429 
    self.success = success
16430 
 
16431 
  def read(self, iprot):
16432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16434 
      return
16435 
    iprot.readStructBegin()
16436 
    while True:
16437 
      (fname, ftype, fid) = iprot.readFieldBegin()
16438 
      if ftype == TType.STOP:
16439 
        break
16440 
      if fid == 0:
16441 
        if ftype == TType.LIST:
16442 
          self.success = []
16443 
          (_etype310, _size307) = iprot.readListBegin()
16444 
          for _i311 in xrange(_size307):
16445 
            _elem312 = Amazonlisted()
16446 
            _elem312.read(iprot)
16447 
            self.success.append(_elem312)
16448 
          iprot.readListEnd()
16449 
        else:
16450 
          iprot.skip(ftype)
16451 
      else:
16452 
        iprot.skip(ftype)
16453 
      iprot.readFieldEnd()
16454 
    iprot.readStructEnd()
16455 
 
16456 
  def write(self, oprot):
16457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16459 
      return
16460 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16461 
    if self.success is not None:
16462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16464 
      for iter313 in self.success:
16465 
        iter313.write(oprot)
16466 
      oprot.writeListEnd()
16467 
      oprot.writeFieldEnd()
16468 
    oprot.writeFieldStop()
16469 
    oprot.writeStructEnd()
16470 
 
16471 
  def validate(self):
16472 
    return
16473 
 
16474 
 
16475 
  def __repr__(self):
16476 
    L = ['%s=%r' % (key, value)
16477 
      for key, value in self.__dict__.iteritems()]
16478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16479 
 
16480 
  def __eq__(self, other):
16481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16482 
 
16483 
  def __ne__(self, other):
16484 
    return not (self == other)
16485 
 
16486 
class getAmazonItemDetails_args:
16487 
  """
16488 
  Attributes:
16489 
   - itemId
16490 
  """
16491 
 
16492 
  thrift_spec = (
16493 
    None, # 0
16494 
    (1, TType.I64, 'itemId', None, None, ), # 1
16495 
  )
16496 
 
16497 
  def __init__(self, itemId=None,):
16498 
    self.itemId = itemId
16499 
 
16500 
  def read(self, iprot):
16501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16503 
      return
16504 
    iprot.readStructBegin()
16505 
    while True:
16506 
      (fname, ftype, fid) = iprot.readFieldBegin()
16507 
      if ftype == TType.STOP:
16508 
        break
16509 
      if fid == 1:
16510 
        if ftype == TType.I64:
16511 
          self.itemId = iprot.readI64();
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('getAmazonItemDetails_args')
16524 
    if self.itemId is not None:
16525 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16526 
      oprot.writeI64(self.itemId)
16527 
      oprot.writeFieldEnd()
16528 
    oprot.writeFieldStop()
16529 
    oprot.writeStructEnd()
16530 
 
16531 
  def validate(self):
16532 
    return
16533 
 
16534 
 
16535 
  def __repr__(self):
16536 
    L = ['%s=%r' % (key, value)
16537 
      for key, value in self.__dict__.iteritems()]
16538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16539 
 
16540 
  def __eq__(self, other):
16541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16542 
 
16543 
  def __ne__(self, other):
16544 
    return not (self == other)
16545 
 
16546 
class getAmazonItemDetails_result:
16547 
  """
16548 
  Attributes:
16549 
   - success
16550 
  """
16551 
 
16552 
  thrift_spec = (
16553 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16554 
  )
16555 
 
16556 
  def __init__(self, success=None,):
16557 
    self.success = success
16558 
 
16559 
  def read(self, iprot):
16560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16562 
      return
16563 
    iprot.readStructBegin()
16564 
    while True:
16565 
      (fname, ftype, fid) = iprot.readFieldBegin()
16566 
      if ftype == TType.STOP:
16567 
        break
16568 
      if fid == 0:
16569 
        if ftype == TType.STRUCT:
16570 
          self.success = Amazonlisted()
16571 
          self.success.read(iprot)
16572 
        else:
16573 
          iprot.skip(ftype)
16574 
      else:
16575 
        iprot.skip(ftype)
16576 
      iprot.readFieldEnd()
16577 
    iprot.readStructEnd()
16578 
 
16579 
  def write(self, oprot):
16580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16582 
      return
16583 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16584 
    if self.success is not None:
16585 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16586 
      self.success.write(oprot)
16587 
      oprot.writeFieldEnd()
16588 
    oprot.writeFieldStop()
16589 
    oprot.writeStructEnd()
16590 
 
16591 
  def validate(self):
16592 
    return
16593 
 
16594 
 
16595 
  def __repr__(self):
16596 
    L = ['%s=%r' % (key, value)
16597 
      for key, value in self.__dict__.iteritems()]
16598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16599 
 
16600 
  def __eq__(self, other):
16601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16602 
 
16603 
  def __ne__(self, other):
16604 
    return not (self == other)
16605 
 
16606 
class updateAmazonItemDetails_args:
16607 
  """
16608 
  Attributes:
16609 
   - itemId
16610 
   - fbaPrice
16611 
   - sellingPrice
16612 
   - isFba
16613 
   - isNonFba
16614 
   - isInventoryOverride
16615 
  """
16616 
 
16617 
  thrift_spec = (
16618 
    None, # 0
16619 
    (1, TType.I64, 'itemId', None, None, ), # 1
16620 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16621 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16622 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16623 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16624 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
16625 
  )
16626 
 
16627 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None,):
16628 
    self.itemId = itemId
16629 
    self.fbaPrice = fbaPrice
16630 
    self.sellingPrice = sellingPrice
16631 
    self.isFba = isFba
16632 
    self.isNonFba = isNonFba
16633 
    self.isInventoryOverride = isInventoryOverride
16634 
 
16635 
  def read(self, iprot):
16636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16638 
      return
16639 
    iprot.readStructBegin()
16640 
    while True:
16641 
      (fname, ftype, fid) = iprot.readFieldBegin()
16642 
      if ftype == TType.STOP:
16643 
        break
16644 
      if fid == 1:
16645 
        if ftype == TType.I64:
16646 
          self.itemId = iprot.readI64();
16647 
        else:
16648 
          iprot.skip(ftype)
16649 
      elif fid == 2:
16650 
        if ftype == TType.DOUBLE:
16651 
          self.fbaPrice = iprot.readDouble();
16652 
        else:
16653 
          iprot.skip(ftype)
16654 
      elif fid == 3:
16655 
        if ftype == TType.DOUBLE:
16656 
          self.sellingPrice = iprot.readDouble();
16657 
        else:
16658 
          iprot.skip(ftype)
16659 
      elif fid == 4:
16660 
        if ftype == TType.BOOL:
16661 
          self.isFba = iprot.readBool();
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      elif fid == 5:
16665 
        if ftype == TType.BOOL:
16666 
          self.isNonFba = iprot.readBool();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      elif fid == 6:
16670 
        if ftype == TType.BOOL:
16671 
          self.isInventoryOverride = iprot.readBool();
16672 
        else:
16673 
          iprot.skip(ftype)
16674 
      else:
16675 
        iprot.skip(ftype)
16676 
      iprot.readFieldEnd()
16677 
    iprot.readStructEnd()
16678 
 
16679 
  def write(self, oprot):
16680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16682 
      return
16683 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
16684 
    if self.itemId is not None:
16685 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16686 
      oprot.writeI64(self.itemId)
16687 
      oprot.writeFieldEnd()
16688 
    if self.fbaPrice is not None:
16689 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
16690 
      oprot.writeDouble(self.fbaPrice)
16691 
      oprot.writeFieldEnd()
16692 
    if self.sellingPrice is not None:
16693 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
16694 
      oprot.writeDouble(self.sellingPrice)
16695 
      oprot.writeFieldEnd()
16696 
    if self.isFba is not None:
16697 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
16698 
      oprot.writeBool(self.isFba)
16699 
      oprot.writeFieldEnd()
16700 
    if self.isNonFba is not None:
16701 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
16702 
      oprot.writeBool(self.isNonFba)
16703 
      oprot.writeFieldEnd()
16704 
    if self.isInventoryOverride is not None:
16705 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
16706 
      oprot.writeBool(self.isInventoryOverride)
16707 
      oprot.writeFieldEnd()
16708 
    oprot.writeFieldStop()
16709 
    oprot.writeStructEnd()
16710 
 
16711 
  def validate(self):
16712 
    return
16713 
 
16714 
 
16715 
  def __repr__(self):
16716 
    L = ['%s=%r' % (key, value)
16717 
      for key, value in self.__dict__.iteritems()]
16718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16719 
 
16720 
  def __eq__(self, other):
16721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16722 
 
16723 
  def __ne__(self, other):
16724 
    return not (self == other)
16725 
 
16726 
class updateAmazonItemDetails_result:
16727 
 
16728 
  thrift_spec = (
16729 
  )
16730 
 
16731 
  def read(self, iprot):
16732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16734 
      return
16735 
    iprot.readStructBegin()
16736 
    while True:
16737 
      (fname, ftype, fid) = iprot.readFieldBegin()
16738 
      if ftype == TType.STOP:
16739 
        break
16740 
      else:
16741 
        iprot.skip(ftype)
16742 
      iprot.readFieldEnd()
16743 
    iprot.readStructEnd()
16744 
 
16745 
  def write(self, oprot):
16746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16748 
      return
16749 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
16750 
    oprot.writeFieldStop()
16751 
    oprot.writeStructEnd()
16752 
 
16753 
  def validate(self):
16754 
    return
16755 
 
16756 
 
16757 
  def __repr__(self):
16758 
    L = ['%s=%r' % (key, value)
16759 
      for key, value in self.__dict__.iteritems()]
16760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16761 
 
16762 
  def __eq__(self, other):
16763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16764 
 
16765 
  def __ne__(self, other):
16766 
    return not (self == other)
16767 
 
16768 
class addAmazonItem_args:
16769 
  """
16770 
  Attributes:
16771 
   - amazonlisted
16772 
  """
16773 
 
16774 
  thrift_spec = (
16775 
    None, # 0
16776 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
16777 
  )
16778 
 
16779 
  def __init__(self, amazonlisted=None,):
16780 
    self.amazonlisted = amazonlisted
16781 
 
16782 
  def read(self, iprot):
16783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16785 
      return
16786 
    iprot.readStructBegin()
16787 
    while True:
16788 
      (fname, ftype, fid) = iprot.readFieldBegin()
16789 
      if ftype == TType.STOP:
16790 
        break
16791 
      if fid == 1:
16792 
        if ftype == TType.STRUCT:
16793 
          self.amazonlisted = Amazonlisted()
16794 
          self.amazonlisted.read(iprot)
16795 
        else:
16796 
          iprot.skip(ftype)
16797 
      else:
16798 
        iprot.skip(ftype)
16799 
      iprot.readFieldEnd()
16800 
    iprot.readStructEnd()
16801 
 
16802 
  def write(self, oprot):
16803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16805 
      return
16806 
    oprot.writeStructBegin('addAmazonItem_args')
16807 
    if self.amazonlisted is not None:
16808 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
16809 
      self.amazonlisted.write(oprot)
16810 
      oprot.writeFieldEnd()
16811 
    oprot.writeFieldStop()
16812 
    oprot.writeStructEnd()
16813 
 
16814 
  def validate(self):
16815 
    return
16816 
 
16817 
 
16818 
  def __repr__(self):
16819 
    L = ['%s=%r' % (key, value)
16820 
      for key, value in self.__dict__.iteritems()]
16821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16822 
 
16823 
  def __eq__(self, other):
16824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16825 
 
16826 
  def __ne__(self, other):
16827 
    return not (self == other)
16828 
 
16829 
class addAmazonItem_result:
16830 
 
16831 
  thrift_spec = (
16832 
  )
16833 
 
16834 
  def read(self, iprot):
16835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16837 
      return
16838 
    iprot.readStructBegin()
16839 
    while True:
16840 
      (fname, ftype, fid) = iprot.readFieldBegin()
16841 
      if ftype == TType.STOP:
16842 
        break
16843 
      else:
16844 
        iprot.skip(ftype)
16845 
      iprot.readFieldEnd()
16846 
    iprot.readStructEnd()
16847 
 
16848 
  def write(self, oprot):
16849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16851 
      return
16852 
    oprot.writeStructBegin('addAmazonItem_result')
16853 
    oprot.writeFieldStop()
16854 
    oprot.writeStructEnd()
16855 
 
16856 
  def validate(self):
16857 
    return
16858 
 
16859 
 
16860 
  def __repr__(self):
16861 
    L = ['%s=%r' % (key, value)
16862 
      for key, value in self.__dict__.iteritems()]
16863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16864 
 
16865 
  def __eq__(self, other):
16866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16867 
 
16868 
  def __ne__(self, other):
16869 
    return not (self == other)