Subversion Repositories SmartDukaan

Rev

Rev 7281 | Rev 7306 | 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 
 
7291 vikram.rag 722 
  def getAsinItems(self, ):
723 
    pass
7281 kshitij.so 724 
 
7291 vikram.rag 725 
  def getAllFbaListedItems(self, ):
726 
    pass
727 
 
728 
  def getAllNonFbaListedItems(self, ):
729 
    pass
730 
 
731 
 
5944 mandeep.dh 732 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
733 
  def __init__(self, iprot, oprot=None):
734 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
735 
 
736 
  def addItem(self, item):
737 
    """
738 
    Availability and inventory attributes
739 
 
740 
    Parameters:
741 
     - item
742 
    """
743 
    self.send_addItem(item)
744 
    return self.recv_addItem()
745 
 
746 
  def send_addItem(self, item):
747 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
748 
    args = addItem_args()
749 
    args.item = item
750 
    args.write(self._oprot)
751 
    self._oprot.writeMessageEnd()
752 
    self._oprot.trans.flush()
753 
 
754 
  def recv_addItem(self, ):
755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
756 
    if mtype == TMessageType.EXCEPTION:
757 
      x = TApplicationException()
758 
      x.read(self._iprot)
759 
      self._iprot.readMessageEnd()
760 
      raise x
761 
    result = addItem_result()
762 
    result.read(self._iprot)
763 
    self._iprot.readMessageEnd()
764 
    if result.success is not None:
765 
      return result.success
766 
    if result.cex is not None:
767 
      raise result.cex
768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
769 
 
770 
  def updateItem(self, item):
771 
    """
772 
    Parameters:
773 
     - item
774 
    """
775 
    self.send_updateItem(item)
776 
    return self.recv_updateItem()
777 
 
778 
  def send_updateItem(self, item):
779 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
780 
    args = updateItem_args()
781 
    args.item = item
782 
    args.write(self._oprot)
783 
    self._oprot.writeMessageEnd()
784 
    self._oprot.trans.flush()
785 
 
786 
  def recv_updateItem(self, ):
787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
788 
    if mtype == TMessageType.EXCEPTION:
789 
      x = TApplicationException()
790 
      x.read(self._iprot)
791 
      self._iprot.readMessageEnd()
792 
      raise x
793 
    result = updateItem_result()
794 
    result.read(self._iprot)
795 
    self._iprot.readMessageEnd()
796 
    if result.success is not None:
797 
      return result.success
798 
    if result.cex is not None:
799 
      raise result.cex
800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
801 
 
802 
  def isActive(self, itemId):
803 
    """
804 
    Checks if the item given to the corresponding itemId is active. If it's active,
805 
    whether it's risky and if it's risky, its inventory position.
806 
 
807 
    Parameters:
808 
     - itemId
809 
    """
810 
    self.send_isActive(itemId)
811 
    return self.recv_isActive()
812 
 
813 
  def send_isActive(self, itemId):
814 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
815 
    args = isActive_args()
816 
    args.itemId = itemId
817 
    args.write(self._oprot)
818 
    self._oprot.writeMessageEnd()
819 
    self._oprot.trans.flush()
820 
 
821 
  def recv_isActive(self, ):
822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
823 
    if mtype == TMessageType.EXCEPTION:
824 
      x = TApplicationException()
825 
      x.read(self._iprot)
826 
      self._iprot.readMessageEnd()
827 
      raise x
828 
    result = isActive_result()
829 
    result.read(self._iprot)
830 
    self._iprot.readMessageEnd()
831 
    if result.success is not None:
832 
      return result.success
833 
    if result.isex is not None:
834 
      raise result.isex
835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
836 
 
837 
  def getItemStatusDescription(self, itemId):
838 
    """
839 
    Parameters:
840 
     - itemId
841 
    """
842 
    self.send_getItemStatusDescription(itemId)
843 
    return self.recv_getItemStatusDescription()
844 
 
845 
  def send_getItemStatusDescription(self, itemId):
846 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
847 
    args = getItemStatusDescription_args()
848 
    args.itemId = itemId
849 
    args.write(self._oprot)
850 
    self._oprot.writeMessageEnd()
851 
    self._oprot.trans.flush()
852 
 
853 
  def recv_getItemStatusDescription(self, ):
854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
855 
    if mtype == TMessageType.EXCEPTION:
856 
      x = TApplicationException()
857 
      x.read(self._iprot)
858 
      self._iprot.readMessageEnd()
859 
      raise x
860 
    result = getItemStatusDescription_result()
861 
    result.read(self._iprot)
862 
    self._iprot.readMessageEnd()
863 
    if result.success is not None:
864 
      return result.success
865 
    if result.isex is not None:
866 
      raise result.isex
867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
868 
 
869 
  def startItemOn(self, item_id, timestamp):
870 
    """
871 
    Parameters:
872 
     - item_id
873 
     - timestamp
874 
    """
875 
    self.send_startItemOn(item_id, timestamp)
876 
    self.recv_startItemOn()
877 
 
878 
  def send_startItemOn(self, item_id, timestamp):
879 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
880 
    args = startItemOn_args()
881 
    args.item_id = item_id
882 
    args.timestamp = timestamp
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_startItemOn(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = startItemOn_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
897 
    if result.cex is not None:
898 
      raise result.cex
899 
    return
900 
 
901 
  def retireItemOn(self, item_id, timestamp):
902 
    """
903 
    Parameters:
904 
     - item_id
905 
     - timestamp
906 
    """
907 
    self.send_retireItemOn(item_id, timestamp)
908 
    self.recv_retireItemOn()
909 
 
910 
  def send_retireItemOn(self, item_id, timestamp):
911 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
912 
    args = retireItemOn_args()
913 
    args.item_id = item_id
914 
    args.timestamp = timestamp
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_retireItemOn(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = retireItemOn_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
929 
    if result.cex is not None:
930 
      raise result.cex
931 
    return
932 
 
933 
  def changeItemStatus(self, item_id, timestamp, newstatus):
934 
    """
935 
    Parameters:
936 
     - item_id
937 
     - timestamp
938 
     - newstatus
939 
    """
940 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
941 
    self.recv_changeItemStatus()
942 
 
943 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
944 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
945 
    args = changeItemStatus_args()
946 
    args.item_id = item_id
947 
    args.timestamp = timestamp
948 
    args.newstatus = newstatus
949 
    args.write(self._oprot)
950 
    self._oprot.writeMessageEnd()
951 
    self._oprot.trans.flush()
952 
 
953 
  def recv_changeItemStatus(self, ):
954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
955 
    if mtype == TMessageType.EXCEPTION:
956 
      x = TApplicationException()
957 
      x.read(self._iprot)
958 
      self._iprot.readMessageEnd()
959 
      raise x
960 
    result = changeItemStatus_result()
961 
    result.read(self._iprot)
962 
    self._iprot.readMessageEnd()
963 
    if result.cex is not None:
964 
      raise result.cex
965 
    return
966 
 
967 
  def getItem(self, item_id):
968 
    """
969 
    Parameters:
970 
     - item_id
971 
    """
972 
    self.send_getItem(item_id)
973 
    return self.recv_getItem()
974 
 
975 
  def send_getItem(self, item_id):
976 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
977 
    args = getItem_args()
978 
    args.item_id = item_id
979 
    args.write(self._oprot)
980 
    self._oprot.writeMessageEnd()
981 
    self._oprot.trans.flush()
982 
 
983 
  def recv_getItem(self, ):
984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
985 
    if mtype == TMessageType.EXCEPTION:
986 
      x = TApplicationException()
987 
      x.read(self._iprot)
988 
      self._iprot.readMessageEnd()
989 
      raise x
990 
    result = getItem_result()
991 
    result.read(self._iprot)
992 
    self._iprot.readMessageEnd()
993 
    if result.success is not None:
994 
      return result.success
995 
    if result.cex is not None:
996 
      raise result.cex
997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
998 
 
999 
  def getItemsByCatalogId(self, catalog_item_id):
1000 
    """
1001 
    Parameters:
1002 
     - catalog_item_id
1003 
    """
1004 
    self.send_getItemsByCatalogId(catalog_item_id)
1005 
    return self.recv_getItemsByCatalogId()
1006 
 
1007 
  def send_getItemsByCatalogId(self, catalog_item_id):
1008 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1009 
    args = getItemsByCatalogId_args()
1010 
    args.catalog_item_id = catalog_item_id
1011 
    args.write(self._oprot)
1012 
    self._oprot.writeMessageEnd()
1013 
    self._oprot.trans.flush()
1014 
 
1015 
  def recv_getItemsByCatalogId(self, ):
1016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1017 
    if mtype == TMessageType.EXCEPTION:
1018 
      x = TApplicationException()
1019 
      x.read(self._iprot)
1020 
      self._iprot.readMessageEnd()
1021 
      raise x
1022 
    result = getItemsByCatalogId_result()
1023 
    result.read(self._iprot)
1024 
    self._iprot.readMessageEnd()
1025 
    if result.success is not None:
1026 
      return result.success
1027 
    if result.cex is not None:
1028 
      raise result.cex
1029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1030 
 
1031 
  def getValidItemsByCatalogId(self, catalog_item_id):
1032 
    """
1033 
    Parameters:
1034 
     - catalog_item_id
1035 
    """
1036 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1037 
    return self.recv_getValidItemsByCatalogId()
1038 
 
1039 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1040 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1041 
    args = getValidItemsByCatalogId_args()
1042 
    args.catalog_item_id = catalog_item_id
1043 
    args.write(self._oprot)
1044 
    self._oprot.writeMessageEnd()
1045 
    self._oprot.trans.flush()
1046 
 
1047 
  def recv_getValidItemsByCatalogId(self, ):
1048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1049 
    if mtype == TMessageType.EXCEPTION:
1050 
      x = TApplicationException()
1051 
      x.read(self._iprot)
1052 
      self._iprot.readMessageEnd()
1053 
      raise x
1054 
    result = getValidItemsByCatalogId_result()
1055 
    result.read(self._iprot)
1056 
    self._iprot.readMessageEnd()
1057 
    if result.success is not None:
1058 
      return result.success
1059 
    if result.cex is not None:
1060 
      raise result.cex
1061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1062 
 
1063 
  def getAllItems(self, isActive):
1064 
    """
1065 
    Parameters:
1066 
     - isActive
1067 
    """
1068 
    self.send_getAllItems(isActive)
1069 
    return self.recv_getAllItems()
1070 
 
1071 
  def send_getAllItems(self, isActive):
1072 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1073 
    args = getAllItems_args()
1074 
    args.isActive = isActive
1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
1079 
  def recv_getAllItems(self, ):
1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
1086 
    result = getAllItems_result()
1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
1089 
    if result.success is not None:
1090 
      return result.success
1091 
    if result.cex is not None:
1092 
      raise result.cex
1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1094 
 
1095 
  def getAllItemsByStatus(self, itemStatus):
1096 
    """
1097 
    Parameters:
1098 
     - itemStatus
1099 
    """
1100 
    self.send_getAllItemsByStatus(itemStatus)
1101 
    return self.recv_getAllItemsByStatus()
1102 
 
1103 
  def send_getAllItemsByStatus(self, itemStatus):
1104 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1105 
    args = getAllItemsByStatus_args()
1106 
    args.itemStatus = itemStatus
1107 
    args.write(self._oprot)
1108 
    self._oprot.writeMessageEnd()
1109 
    self._oprot.trans.flush()
1110 
 
1111 
  def recv_getAllItemsByStatus(self, ):
1112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1113 
    if mtype == TMessageType.EXCEPTION:
1114 
      x = TApplicationException()
1115 
      x.read(self._iprot)
1116 
      self._iprot.readMessageEnd()
1117 
      raise x
1118 
    result = getAllItemsByStatus_result()
1119 
    result.read(self._iprot)
1120 
    self._iprot.readMessageEnd()
1121 
    if result.success is not None:
1122 
      return result.success
1123 
    if result.cex is not None:
1124 
      raise result.cex
1125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1126 
 
1127 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1128 
    """
1129 
    Parameters:
1130 
     - entityId
1131 
     - category
1132 
     - brand
1133 
     - modelName
1134 
     - modelNumber
1135 
    """
1136 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1137 
    return self.recv_markItemAsContentComplete()
1138 
 
1139 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1140 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1141 
    args = markItemAsContentComplete_args()
1142 
    args.entityId = entityId
1143 
    args.category = category
1144 
    args.brand = brand
1145 
    args.modelName = modelName
1146 
    args.modelNumber = modelNumber
1147 
    args.write(self._oprot)
1148 
    self._oprot.writeMessageEnd()
1149 
    self._oprot.trans.flush()
1150 
 
1151 
  def recv_markItemAsContentComplete(self, ):
1152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1153 
    if mtype == TMessageType.EXCEPTION:
1154 
      x = TApplicationException()
1155 
      x.read(self._iprot)
1156 
      self._iprot.readMessageEnd()
1157 
      raise x
1158 
    result = markItemAsContentComplete_result()
1159 
    result.read(self._iprot)
1160 
    self._iprot.readMessageEnd()
1161 
    if result.success is not None:
1162 
      return result.success
1163 
    if result.cex is not None:
1164 
      raise result.cex
1165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1166 
 
1167 
  def getAllItemsInRange(self, offset, limit):
1168 
    """
1169 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1170 
 
1171 
    Parameters:
1172 
     - offset
1173 
     - limit
1174 
    """
1175 
    self.send_getAllItemsInRange(offset, limit)
1176 
    return self.recv_getAllItemsInRange()
1177 
 
1178 
  def send_getAllItemsInRange(self, offset, limit):
1179 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1180 
    args = getAllItemsInRange_args()
1181 
    args.offset = offset
1182 
    args.limit = limit
1183 
    args.write(self._oprot)
1184 
    self._oprot.writeMessageEnd()
1185 
    self._oprot.trans.flush()
1186 
 
1187 
  def recv_getAllItemsInRange(self, ):
1188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1189 
    if mtype == TMessageType.EXCEPTION:
1190 
      x = TApplicationException()
1191 
      x.read(self._iprot)
1192 
      self._iprot.readMessageEnd()
1193 
      raise x
1194 
    result = getAllItemsInRange_result()
1195 
    result.read(self._iprot)
1196 
    self._iprot.readMessageEnd()
1197 
    if result.success is not None:
1198 
      return result.success
1199 
    if result.cex is not None:
1200 
      raise result.cex
1201 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1202 
 
1203 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1204 
    """
1205 
    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.
1206 
 
1207 
    Parameters:
1208 
     - itemStatus
1209 
     - offset
1210 
     - limit
1211 
    """
1212 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1213 
    return self.recv_getAllItemsByStatusInRange()
1214 
 
1215 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1216 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1217 
    args = getAllItemsByStatusInRange_args()
1218 
    args.itemStatus = itemStatus
1219 
    args.offset = offset
1220 
    args.limit = limit
1221 
    args.write(self._oprot)
1222 
    self._oprot.writeMessageEnd()
1223 
    self._oprot.trans.flush()
1224 
 
1225 
  def recv_getAllItemsByStatusInRange(self, ):
1226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1227 
    if mtype == TMessageType.EXCEPTION:
1228 
      x = TApplicationException()
1229 
      x.read(self._iprot)
1230 
      self._iprot.readMessageEnd()
1231 
      raise x
1232 
    result = getAllItemsByStatusInRange_result()
1233 
    result.read(self._iprot)
1234 
    self._iprot.readMessageEnd()
1235 
    if result.success is not None:
1236 
      return result.success
1237 
    if result.cex is not None:
1238 
      raise result.cex
1239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1240 
 
1241 
  def getItemCountByStatus(self, useStatus, itemStatus):
1242 
    """
1243 
    Gets a count of all items by status
1244 
 
1245 
    Parameters:
1246 
     - useStatus
1247 
     - itemStatus
1248 
    """
1249 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1250 
    return self.recv_getItemCountByStatus()
1251 
 
1252 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1253 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1254 
    args = getItemCountByStatus_args()
1255 
    args.useStatus = useStatus
1256 
    args.itemStatus = itemStatus
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getItemCountByStatus(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getItemCountByStatus_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
1271 
    if result.success is not None:
1272 
      return result.success
1273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1274 
 
1275 
  def getBestSellers(self, ):
1276 
    self.send_getBestSellers()
1277 
    return self.recv_getBestSellers()
1278 
 
1279 
  def send_getBestSellers(self, ):
1280 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1281 
    args = getBestSellers_args()
1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
1286 
  def recv_getBestSellers(self, ):
1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
1293 
    result = getBestSellers_result()
1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
1296 
    if result.success is not None:
1297 
      return result.success
1298 
    if result.isex is not None:
1299 
      raise result.isex
1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1301 
 
1302 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1303 
    """
1304 
    Parameters:
1305 
     - beginIndex
1306 
     - totalItems
1307 
     - brand
1308 
     - category
1309 
    """
1310 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1311 
    return self.recv_getBestSellersCatalogIds()
1312 
 
1313 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1314 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1315 
    args = getBestSellersCatalogIds_args()
1316 
    args.beginIndex = beginIndex
1317 
    args.totalItems = totalItems
1318 
    args.brand = brand
1319 
    args.category = category
1320 
    args.write(self._oprot)
1321 
    self._oprot.writeMessageEnd()
1322 
    self._oprot.trans.flush()
1323 
 
1324 
  def recv_getBestSellersCatalogIds(self, ):
1325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1326 
    if mtype == TMessageType.EXCEPTION:
1327 
      x = TApplicationException()
1328 
      x.read(self._iprot)
1329 
      self._iprot.readMessageEnd()
1330 
      raise x
1331 
    result = getBestSellersCatalogIds_result()
1332 
    result.read(self._iprot)
1333 
    self._iprot.readMessageEnd()
1334 
    if result.success is not None:
1335 
      return result.success
1336 
    if result.cex is not None:
1337 
      raise result.cex
1338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1339 
 
1340 
  def getBestSellersCount(self, ):
1341 
    self.send_getBestSellersCount()
1342 
    return self.recv_getBestSellersCount()
1343 
 
1344 
  def send_getBestSellersCount(self, ):
1345 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1346 
    args = getBestSellersCount_args()
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_getBestSellersCount(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = getBestSellersCount_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
1361 
    if result.success is not None:
1362 
      return result.success
1363 
    if result.cex is not None:
1364 
      raise result.cex
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1366 
 
1367 
  def getBestDeals(self, ):
1368 
    self.send_getBestDeals()
1369 
    return self.recv_getBestDeals()
1370 
 
1371 
  def send_getBestDeals(self, ):
1372 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1373 
    args = getBestDeals_args()
1374 
    args.write(self._oprot)
1375 
    self._oprot.writeMessageEnd()
1376 
    self._oprot.trans.flush()
1377 
 
1378 
  def recv_getBestDeals(self, ):
1379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1380 
    if mtype == TMessageType.EXCEPTION:
1381 
      x = TApplicationException()
1382 
      x.read(self._iprot)
1383 
      self._iprot.readMessageEnd()
1384 
      raise x
1385 
    result = getBestDeals_result()
1386 
    result.read(self._iprot)
1387 
    self._iprot.readMessageEnd()
1388 
    if result.success is not None:
1389 
      return result.success
1390 
    if result.isex is not None:
1391 
      raise result.isex
1392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1393 
 
1394 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1395 
    """
1396 
    Parameters:
1397 
     - beginIndex
1398 
     - totalItems
1399 
     - brand
1400 
     - category
1401 
    """
1402 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1403 
    return self.recv_getBestDealsCatalogIds()
1404 
 
1405 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1406 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1407 
    args = getBestDealsCatalogIds_args()
1408 
    args.beginIndex = beginIndex
1409 
    args.totalItems = totalItems
1410 
    args.brand = brand
1411 
    args.category = category
1412 
    args.write(self._oprot)
1413 
    self._oprot.writeMessageEnd()
1414 
    self._oprot.trans.flush()
1415 
 
1416 
  def recv_getBestDealsCatalogIds(self, ):
1417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1418 
    if mtype == TMessageType.EXCEPTION:
1419 
      x = TApplicationException()
1420 
      x.read(self._iprot)
1421 
      self._iprot.readMessageEnd()
1422 
      raise x
1423 
    result = getBestDealsCatalogIds_result()
1424 
    result.read(self._iprot)
1425 
    self._iprot.readMessageEnd()
1426 
    if result.success is not None:
1427 
      return result.success
1428 
    if result.cex is not None:
1429 
      raise result.cex
1430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1431 
 
1432 
  def getBestDealsCount(self, ):
1433 
    self.send_getBestDealsCount()
1434 
    return self.recv_getBestDealsCount()
1435 
 
1436 
  def send_getBestDealsCount(self, ):
1437 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1438 
    args = getBestDealsCount_args()
1439 
    args.write(self._oprot)
1440 
    self._oprot.writeMessageEnd()
1441 
    self._oprot.trans.flush()
1442 
 
1443 
  def recv_getBestDealsCount(self, ):
1444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1445 
    if mtype == TMessageType.EXCEPTION:
1446 
      x = TApplicationException()
1447 
      x.read(self._iprot)
1448 
      self._iprot.readMessageEnd()
1449 
      raise x
1450 
    result = getBestDealsCount_result()
1451 
    result.read(self._iprot)
1452 
    self._iprot.readMessageEnd()
1453 
    if result.success is not None:
1454 
      return result.success
1455 
    if result.cex is not None:
1456 
      raise result.cex
1457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1458 
 
1459 
  def getComingSoon(self, ):
1460 
    self.send_getComingSoon()
1461 
    return self.recv_getComingSoon()
1462 
 
1463 
  def send_getComingSoon(self, ):
1464 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1465 
    args = getComingSoon_args()
1466 
    args.write(self._oprot)
1467 
    self._oprot.writeMessageEnd()
1468 
    self._oprot.trans.flush()
1469 
 
1470 
  def recv_getComingSoon(self, ):
1471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1472 
    if mtype == TMessageType.EXCEPTION:
1473 
      x = TApplicationException()
1474 
      x.read(self._iprot)
1475 
      self._iprot.readMessageEnd()
1476 
      raise x
1477 
    result = getComingSoon_result()
1478 
    result.read(self._iprot)
1479 
    self._iprot.readMessageEnd()
1480 
    if result.success is not None:
1481 
      return result.success
1482 
    if result.isex is not None:
1483 
      raise result.isex
1484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1485 
 
1486 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1487 
    """
1488 
    Parameters:
1489 
     - beginIndex
1490 
     - totalItems
1491 
     - brand
1492 
     - category
1493 
    """
1494 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1495 
    return self.recv_getComingSoonCatalogIds()
1496 
 
1497 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1498 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1499 
    args = getComingSoonCatalogIds_args()
1500 
    args.beginIndex = beginIndex
1501 
    args.totalItems = totalItems
1502 
    args.brand = brand
1503 
    args.category = category
1504 
    args.write(self._oprot)
1505 
    self._oprot.writeMessageEnd()
1506 
    self._oprot.trans.flush()
1507 
 
1508 
  def recv_getComingSoonCatalogIds(self, ):
1509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1510 
    if mtype == TMessageType.EXCEPTION:
1511 
      x = TApplicationException()
1512 
      x.read(self._iprot)
1513 
      self._iprot.readMessageEnd()
1514 
      raise x
1515 
    result = getComingSoonCatalogIds_result()
1516 
    result.read(self._iprot)
1517 
    self._iprot.readMessageEnd()
1518 
    if result.success is not None:
1519 
      return result.success
1520 
    if result.cex is not None:
1521 
      raise result.cex
1522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1523 
 
1524 
  def getComingSoonCount(self, ):
1525 
    self.send_getComingSoonCount()
1526 
    return self.recv_getComingSoonCount()
1527 
 
1528 
  def send_getComingSoonCount(self, ):
1529 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1530 
    args = getComingSoonCount_args()
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getComingSoonCount(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getComingSoonCount_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
1545 
    if result.success is not None:
1546 
      return result.success
1547 
    if result.cex is not None:
1548 
      raise result.cex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1550 
 
1551 
  def getLatestArrivals(self, ):
1552 
    """
1553 
    Returns a list of items sorted in the descending order by start date.
1554 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1555 
    """
1556 
    self.send_getLatestArrivals()
1557 
    return self.recv_getLatestArrivals()
1558 
 
1559 
  def send_getLatestArrivals(self, ):
1560 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1561 
    args = getLatestArrivals_args()
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_getLatestArrivals(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = getLatestArrivals_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
1576 
    if result.success is not None:
1577 
      return result.success
1578 
    if result.isex is not None:
1579 
      raise result.isex
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1581 
 
1582 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1583 
    """
1584 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1585 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1586 
 
1587 
    Parameters:
1588 
     - beginIndex
1589 
     - totalItems
1590 
     - brand
1591 
     - categories
1592 
    """
1593 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1594 
    return self.recv_getLatestArrivalsCatalogIds()
1595 
 
1596 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1597 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1598 
    args = getLatestArrivalsCatalogIds_args()
1599 
    args.beginIndex = beginIndex
1600 
    args.totalItems = totalItems
1601 
    args.brand = brand
1602 
    args.categories = categories
1603 
    args.write(self._oprot)
1604 
    self._oprot.writeMessageEnd()
1605 
    self._oprot.trans.flush()
1606 
 
1607 
  def recv_getLatestArrivalsCatalogIds(self, ):
1608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1609 
    if mtype == TMessageType.EXCEPTION:
1610 
      x = TApplicationException()
1611 
      x.read(self._iprot)
1612 
      self._iprot.readMessageEnd()
1613 
      raise x
1614 
    result = getLatestArrivalsCatalogIds_result()
1615 
    result.read(self._iprot)
1616 
    self._iprot.readMessageEnd()
1617 
    if result.success is not None:
1618 
      return result.success
1619 
    if result.cex is not None:
1620 
      raise result.cex
1621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1622 
 
1623 
  def getLatestArrivalsCount(self, ):
1624 
    """
1625 
    Get the total number of latest arrivals we are willing to show.
1626 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1627 
    """
1628 
    self.send_getLatestArrivalsCount()
1629 
    return self.recv_getLatestArrivalsCount()
1630 
 
1631 
  def send_getLatestArrivalsCount(self, ):
1632 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1633 
    args = getLatestArrivalsCount_args()
1634 
    args.write(self._oprot)
1635 
    self._oprot.writeMessageEnd()
1636 
    self._oprot.trans.flush()
1637 
 
1638 
  def recv_getLatestArrivalsCount(self, ):
1639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1640 
    if mtype == TMessageType.EXCEPTION:
1641 
      x = TApplicationException()
1642 
      x.read(self._iprot)
1643 
      self._iprot.readMessageEnd()
1644 
      raise x
1645 
    result = getLatestArrivalsCount_result()
1646 
    result.read(self._iprot)
1647 
    self._iprot.readMessageEnd()
1648 
    if result.success is not None:
1649 
      return result.success
1650 
    if result.cex is not None:
1651 
      raise result.cex
1652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1653 
 
1654 
  def generateNewEntityID(self, ):
1655 
    self.send_generateNewEntityID()
1656 
    return self.recv_generateNewEntityID()
1657 
 
1658 
  def send_generateNewEntityID(self, ):
1659 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1660 
    args = generateNewEntityID_args()
1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
1665 
  def recv_generateNewEntityID(self, ):
1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
1672 
    result = generateNewEntityID_result()
1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
1675 
    if result.success is not None:
1676 
      return result.success
1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1678 
 
1679 
  def addCategory(self, category):
1680 
    """
1681 
    All category related functions
1682 
 
1683 
    Parameters:
1684 
     - category
1685 
    """
1686 
    self.send_addCategory(category)
1687 
    return self.recv_addCategory()
1688 
 
1689 
  def send_addCategory(self, category):
1690 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1691 
    args = addCategory_args()
1692 
    args.category = category
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_addCategory(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = addCategory_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
1707 
    if result.success is not None:
1708 
      return result.success
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1710 
 
1711 
  def getCategory(self, id):
1712 
    """
1713 
    Parameters:
1714 
     - id
1715 
    """
1716 
    self.send_getCategory(id)
1717 
    return self.recv_getCategory()
1718 
 
1719 
  def send_getCategory(self, id):
1720 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1721 
    args = getCategory_args()
1722 
    args.id = id
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_getCategory(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = getCategory_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
1737 
    if result.success is not None:
1738 
      return result.success
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1740 
 
1741 
  def getAllCategories(self, ):
1742 
    self.send_getAllCategories()
1743 
    return self.recv_getAllCategories()
1744 
 
1745 
  def send_getAllCategories(self, ):
1746 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1747 
    args = getAllCategories_args()
1748 
    args.write(self._oprot)
1749 
    self._oprot.writeMessageEnd()
1750 
    self._oprot.trans.flush()
1751 
 
1752 
  def recv_getAllCategories(self, ):
1753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1754 
    if mtype == TMessageType.EXCEPTION:
1755 
      x = TApplicationException()
1756 
      x.read(self._iprot)
1757 
      self._iprot.readMessageEnd()
1758 
      raise x
1759 
    result = getAllCategories_result()
1760 
    result.read(self._iprot)
1761 
    self._iprot.readMessageEnd()
1762 
    if result.success is not None:
1763 
      return result.success
1764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1765 
 
1766 
  def getAllSimilarItems(self, itemId):
1767 
    """
1768 
    Returns the list of similar items.
1769 
 
1770 
    Parameters:
1771 
     - itemId
1772 
    """
1773 
    self.send_getAllSimilarItems(itemId)
1774 
    return self.recv_getAllSimilarItems()
1775 
 
1776 
  def send_getAllSimilarItems(self, itemId):
1777 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1778 
    args = getAllSimilarItems_args()
1779 
    args.itemId = itemId
1780 
    args.write(self._oprot)
1781 
    self._oprot.writeMessageEnd()
1782 
    self._oprot.trans.flush()
1783 
 
1784 
  def recv_getAllSimilarItems(self, ):
1785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1786 
    if mtype == TMessageType.EXCEPTION:
1787 
      x = TApplicationException()
1788 
      x.read(self._iprot)
1789 
      self._iprot.readMessageEnd()
1790 
      raise x
1791 
    result = getAllSimilarItems_result()
1792 
    result.read(self._iprot)
1793 
    self._iprot.readMessageEnd()
1794 
    if result.success is not None:
1795 
      return result.success
1796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1797 
 
1798 
  def addSimilarItem(self, itemId, catalogItemId):
1799 
    """
1800 
    Adds similar item.
1801 
 
1802 
    Parameters:
1803 
     - itemId
1804 
     - catalogItemId
1805 
    """
1806 
    self.send_addSimilarItem(itemId, catalogItemId)
1807 
    return self.recv_addSimilarItem()
1808 
 
1809 
  def send_addSimilarItem(self, itemId, catalogItemId):
1810 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1811 
    args = addSimilarItem_args()
1812 
    args.itemId = itemId
1813 
    args.catalogItemId = catalogItemId
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_addSimilarItem(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = addSimilarItem_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.success is not None:
1829 
      return result.success
1830 
    if result.cex is not None:
1831 
      raise result.cex
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1833 
 
6512 kshitij.so 1834 
  def addTag(self, displayName, itemId):
1835 
    """
1836 
    Tag Related
1837 
 
1838 
    Parameters:
1839 
     - displayName
1840 
     - itemId
1841 
    """
1842 
    self.send_addTag(displayName, itemId)
1843 
    return self.recv_addTag()
1844 
 
1845 
  def send_addTag(self, displayName, itemId):
1846 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1847 
    args = addTag_args()
1848 
    args.displayName = displayName
1849 
    args.itemId = itemId
1850 
    args.write(self._oprot)
1851 
    self._oprot.writeMessageEnd()
1852 
    self._oprot.trans.flush()
1853 
 
1854 
  def recv_addTag(self, ):
1855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1856 
    if mtype == TMessageType.EXCEPTION:
1857 
      x = TApplicationException()
1858 
      x.read(self._iprot)
1859 
      self._iprot.readMessageEnd()
1860 
      raise x
1861 
    result = addTag_result()
1862 
    result.read(self._iprot)
1863 
    self._iprot.readMessageEnd()
1864 
    if result.success is not None:
1865 
      return result.success
1866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1867 
 
1868 
  def deleteEntityTag(self, displayName, itemId):
1869 
    """
1870 
    Parameters:
1871 
     - displayName
1872 
     - itemId
1873 
    """
1874 
    self.send_deleteEntityTag(displayName, itemId)
1875 
    return self.recv_deleteEntityTag()
1876 
 
1877 
  def send_deleteEntityTag(self, displayName, itemId):
1878 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1879 
    args = deleteEntityTag_args()
1880 
    args.displayName = displayName
1881 
    args.itemId = itemId
1882 
    args.write(self._oprot)
1883 
    self._oprot.writeMessageEnd()
1884 
    self._oprot.trans.flush()
1885 
 
1886 
  def recv_deleteEntityTag(self, ):
1887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1888 
    if mtype == TMessageType.EXCEPTION:
1889 
      x = TApplicationException()
1890 
      x.read(self._iprot)
1891 
      self._iprot.readMessageEnd()
1892 
      raise x
1893 
    result = deleteEntityTag_result()
1894 
    result.read(self._iprot)
1895 
    self._iprot.readMessageEnd()
1896 
    if result.success is not None:
1897 
      return result.success
1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1899 
 
1900 
  def deleteTag(self, displayName):
1901 
    """
1902 
    Parameters:
1903 
     - displayName
1904 
    """
1905 
    self.send_deleteTag(displayName)
1906 
    return self.recv_deleteTag()
1907 
 
1908 
  def send_deleteTag(self, displayName):
1909 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1910 
    args = deleteTag_args()
1911 
    args.displayName = displayName
1912 
    args.write(self._oprot)
1913 
    self._oprot.writeMessageEnd()
1914 
    self._oprot.trans.flush()
1915 
 
1916 
  def recv_deleteTag(self, ):
1917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1918 
    if mtype == TMessageType.EXCEPTION:
1919 
      x = TApplicationException()
1920 
      x.read(self._iprot)
1921 
      self._iprot.readMessageEnd()
1922 
      raise x
1923 
    result = deleteTag_result()
1924 
    result.read(self._iprot)
1925 
    self._iprot.readMessageEnd()
1926 
    if result.success is not None:
1927 
      return result.success
1928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1929 
 
1930 
  def getAllTags(self, ):
1931 
    self.send_getAllTags()
1932 
    return self.recv_getAllTags()
1933 
 
1934 
  def send_getAllTags(self, ):
1935 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1936 
    args = getAllTags_args()
1937 
    args.write(self._oprot)
1938 
    self._oprot.writeMessageEnd()
1939 
    self._oprot.trans.flush()
1940 
 
1941 
  def recv_getAllTags(self, ):
1942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1943 
    if mtype == TMessageType.EXCEPTION:
1944 
      x = TApplicationException()
1945 
      x.read(self._iprot)
1946 
      self._iprot.readMessageEnd()
1947 
      raise x
1948 
    result = getAllTags_result()
1949 
    result.read(self._iprot)
1950 
    self._iprot.readMessageEnd()
1951 
    if result.success is not None:
1952 
      return result.success
1953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1954 
 
1955 
  def getAllEntitiesByTagName(self, displayName):
1956 
    """
1957 
    Parameters:
1958 
     - displayName
1959 
    """
1960 
    self.send_getAllEntitiesByTagName(displayName)
1961 
    return self.recv_getAllEntitiesByTagName()
1962 
 
1963 
  def send_getAllEntitiesByTagName(self, displayName):
1964 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1965 
    args = getAllEntitiesByTagName_args()
1966 
    args.displayName = displayName
1967 
    args.write(self._oprot)
1968 
    self._oprot.writeMessageEnd()
1969 
    self._oprot.trans.flush()
1970 
 
1971 
  def recv_getAllEntitiesByTagName(self, ):
1972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1973 
    if mtype == TMessageType.EXCEPTION:
1974 
      x = TApplicationException()
1975 
      x.read(self._iprot)
1976 
      self._iprot.readMessageEnd()
1977 
      raise x
1978 
    result = getAllEntitiesByTagName_result()
1979 
    result.read(self._iprot)
1980 
    self._iprot.readMessageEnd()
1981 
    if result.success is not None:
1982 
      return result.success
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1984 
 
6845 amit.gupta 1985 
  def getAllEntityTags(self, ):
1986 
    self.send_getAllEntityTags()
1987 
    return self.recv_getAllEntityTags()
1988 
 
1989 
  def send_getAllEntityTags(self, ):
1990 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
1991 
    args = getAllEntityTags_args()
1992 
    args.write(self._oprot)
1993 
    self._oprot.writeMessageEnd()
1994 
    self._oprot.trans.flush()
1995 
 
1996 
  def recv_getAllEntityTags(self, ):
1997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1998 
    if mtype == TMessageType.EXCEPTION:
1999 
      x = TApplicationException()
2000 
      x.read(self._iprot)
2001 
      self._iprot.readMessageEnd()
2002 
      raise x
2003 
    result = getAllEntityTags_result()
2004 
    result.read(self._iprot)
2005 
    self._iprot.readMessageEnd()
2006 
    if result.success is not None:
2007 
      return result.success
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2009 
 
6850 kshitij.so 2010 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2011 
    """
2012 
    Parameters:
2013 
     - bannerName
2014 
     - imageName
2015 
     - link
2016 
     - priority
2017 
     - isActive
2018 
     - hasMap
2019 
    """
2020 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2021 
    return self.recv_addBanner()
2022 
 
2023 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2024 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2025 
    args = addBanner_args()
2026 
    args.bannerName = bannerName
2027 
    args.imageName = imageName
2028 
    args.link = link
2029 
    args.priority = priority
2030 
    args.isActive = isActive
2031 
    args.hasMap = hasMap
2032 
    args.write(self._oprot)
2033 
    self._oprot.writeMessageEnd()
2034 
    self._oprot.trans.flush()
2035 
 
2036 
  def recv_addBanner(self, ):
2037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2038 
    if mtype == TMessageType.EXCEPTION:
2039 
      x = TApplicationException()
2040 
      x.read(self._iprot)
2041 
      self._iprot.readMessageEnd()
2042 
      raise x
2043 
    result = addBanner_result()
2044 
    result.read(self._iprot)
2045 
    self._iprot.readMessageEnd()
2046 
    if result.success is not None:
2047 
      return result.success
2048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2049 
 
2050 
  def getAllBanners(self, ):
2051 
    self.send_getAllBanners()
2052 
    return self.recv_getAllBanners()
2053 
 
2054 
  def send_getAllBanners(self, ):
2055 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2056 
    args = getAllBanners_args()
2057 
    args.write(self._oprot)
2058 
    self._oprot.writeMessageEnd()
2059 
    self._oprot.trans.flush()
2060 
 
2061 
  def recv_getAllBanners(self, ):
2062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2063 
    if mtype == TMessageType.EXCEPTION:
2064 
      x = TApplicationException()
2065 
      x.read(self._iprot)
2066 
      self._iprot.readMessageEnd()
2067 
      raise x
2068 
    result = getAllBanners_result()
2069 
    result.read(self._iprot)
2070 
    self._iprot.readMessageEnd()
2071 
    if result.success is not None:
2072 
      return result.success
2073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2074 
 
2075 
  def deleteBanner(self, bannerName):
2076 
    """
2077 
    Parameters:
2078 
     - bannerName
2079 
    """
2080 
    self.send_deleteBanner(bannerName)
2081 
    return self.recv_deleteBanner()
2082 
 
2083 
  def send_deleteBanner(self, bannerName):
2084 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2085 
    args = deleteBanner_args()
2086 
    args.bannerName = bannerName
2087 
    args.write(self._oprot)
2088 
    self._oprot.writeMessageEnd()
2089 
    self._oprot.trans.flush()
2090 
 
2091 
  def recv_deleteBanner(self, ):
2092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2093 
    if mtype == TMessageType.EXCEPTION:
2094 
      x = TApplicationException()
2095 
      x.read(self._iprot)
2096 
      self._iprot.readMessageEnd()
2097 
      raise x
2098 
    result = deleteBanner_result()
2099 
    result.read(self._iprot)
2100 
    self._iprot.readMessageEnd()
2101 
    if result.success is not None:
2102 
      return result.success
2103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2104 
 
2105 
  def getBannerDetails(self, bannerName):
2106 
    """
2107 
    Parameters:
2108 
     - bannerName
2109 
    """
2110 
    self.send_getBannerDetails(bannerName)
2111 
    return self.recv_getBannerDetails()
2112 
 
2113 
  def send_getBannerDetails(self, bannerName):
2114 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2115 
    args = getBannerDetails_args()
2116 
    args.bannerName = bannerName
2117 
    args.write(self._oprot)
2118 
    self._oprot.writeMessageEnd()
2119 
    self._oprot.trans.flush()
2120 
 
2121 
  def recv_getBannerDetails(self, ):
2122 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2123 
    if mtype == TMessageType.EXCEPTION:
2124 
      x = TApplicationException()
2125 
      x.read(self._iprot)
2126 
      self._iprot.readMessageEnd()
2127 
      raise x
2128 
    result = getBannerDetails_result()
2129 
    result.read(self._iprot)
2130 
    self._iprot.readMessageEnd()
2131 
    if result.success is not None:
2132 
      return result.success
2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2134 
 
2135 
  def getActiveBanners(self, ):
2136 
    self.send_getActiveBanners()
2137 
    return self.recv_getActiveBanners()
2138 
 
2139 
  def send_getActiveBanners(self, ):
2140 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2141 
    args = getActiveBanners_args()
2142 
    args.write(self._oprot)
2143 
    self._oprot.writeMessageEnd()
2144 
    self._oprot.trans.flush()
2145 
 
2146 
  def recv_getActiveBanners(self, ):
2147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2148 
    if mtype == TMessageType.EXCEPTION:
2149 
      x = TApplicationException()
2150 
      x.read(self._iprot)
2151 
      self._iprot.readMessageEnd()
2152 
      raise x
2153 
    result = getActiveBanners_result()
2154 
    result.read(self._iprot)
2155 
    self._iprot.readMessageEnd()
2156 
    if result.success is not None:
2157 
      return result.success
2158 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2159 
 
6849 kshitij.so 2160 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2161 
    """
2162 
    Parameters:
2163 
     - bannerName
2164 
     - mapLink
2165 
     - coordinates
2166 
    """
2167 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2168 
    return self.recv_addBannerMap()
2169 
 
2170 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2171 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2172 
    args = addBannerMap_args()
2173 
    args.bannerName = bannerName
2174 
    args.mapLink = mapLink
2175 
    args.coordinates = coordinates
2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
2180 
  def recv_addBannerMap(self, ):
2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
2187 
    result = addBannerMap_result()
2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
2190 
    if result.success is not None:
2191 
      return result.success
2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2193 
 
2194 
  def deleteBannerMap(self, bannerName):
2195 
    """
2196 
    Parameters:
2197 
     - bannerName
2198 
    """
2199 
    self.send_deleteBannerMap(bannerName)
2200 
    return self.recv_deleteBannerMap()
2201 
 
2202 
  def send_deleteBannerMap(self, bannerName):
2203 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2204 
    args = deleteBannerMap_args()
2205 
    args.bannerName = bannerName
2206 
    args.write(self._oprot)
2207 
    self._oprot.writeMessageEnd()
2208 
    self._oprot.trans.flush()
2209 
 
2210 
  def recv_deleteBannerMap(self, ):
2211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2212 
    if mtype == TMessageType.EXCEPTION:
2213 
      x = TApplicationException()
2214 
      x.read(self._iprot)
2215 
      self._iprot.readMessageEnd()
2216 
      raise x
2217 
    result = deleteBannerMap_result()
2218 
    result.read(self._iprot)
2219 
    self._iprot.readMessageEnd()
2220 
    if result.success is not None:
2221 
      return result.success
2222 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2223 
 
2224 
  def getBannerMapDetails(self, bannerName):
2225 
    """
2226 
    Parameters:
2227 
     - bannerName
2228 
    """
2229 
    self.send_getBannerMapDetails(bannerName)
2230 
    return self.recv_getBannerMapDetails()
2231 
 
2232 
  def send_getBannerMapDetails(self, bannerName):
2233 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2234 
    args = getBannerMapDetails_args()
2235 
    args.bannerName = bannerName
2236 
    args.write(self._oprot)
2237 
    self._oprot.writeMessageEnd()
2238 
    self._oprot.trans.flush()
2239 
 
2240 
  def recv_getBannerMapDetails(self, ):
2241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2242 
    if mtype == TMessageType.EXCEPTION:
2243 
      x = TApplicationException()
2244 
      x.read(self._iprot)
2245 
      self._iprot.readMessageEnd()
2246 
      raise x
2247 
    result = getBannerMapDetails_result()
2248 
    result.read(self._iprot)
2249 
    self._iprot.readMessageEnd()
2250 
    if result.success is not None:
2251 
      return result.success
2252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2253 
 
5944 mandeep.dh 2254 
  def deleteSimilarItem(self, itemId, catalogItemId):
2255 
    """
2256 
    Delete similar item.
2257 
 
2258 
    Parameters:
2259 
     - itemId
2260 
     - catalogItemId
2261 
    """
2262 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2263 
    return self.recv_deleteSimilarItem()
2264 
 
2265 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2266 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2267 
    args = deleteSimilarItem_args()
2268 
    args.itemId = itemId
2269 
    args.catalogItemId = catalogItemId
2270 
    args.write(self._oprot)
2271 
    self._oprot.writeMessageEnd()
2272 
    self._oprot.trans.flush()
2273 
 
2274 
  def recv_deleteSimilarItem(self, ):
2275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2276 
    if mtype == TMessageType.EXCEPTION:
2277 
      x = TApplicationException()
2278 
      x.read(self._iprot)
2279 
      self._iprot.readMessageEnd()
2280 
      raise x
2281 
    result = deleteSimilarItem_result()
2282 
    result.read(self._iprot)
2283 
    self._iprot.readMessageEnd()
2284 
    if result.success is not None:
2285 
      return result.success
2286 
    if result.cex is not None:
2287 
      raise result.cex
2288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2289 
 
2290 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2291 
    """
2292 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2293 
    If yes, returns the itemId else returns 0
2294 
 
2295 
    Parameters:
2296 
     - brand
2297 
     - modelNumber
2298 
     - modelName
2299 
     - color
2300 
    """
2301 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2302 
    return self.recv_checkSimilarItem()
2303 
 
2304 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2305 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2306 
    args = checkSimilarItem_args()
2307 
    args.brand = brand
2308 
    args.modelNumber = modelNumber
2309 
    args.modelName = modelName
2310 
    args.color = color
2311 
    args.write(self._oprot)
2312 
    self._oprot.writeMessageEnd()
2313 
    self._oprot.trans.flush()
2314 
 
2315 
  def recv_checkSimilarItem(self, ):
2316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2317 
    if mtype == TMessageType.EXCEPTION:
2318 
      x = TApplicationException()
2319 
      x.read(self._iprot)
2320 
      self._iprot.readMessageEnd()
2321 
      raise x
2322 
    result = checkSimilarItem_result()
2323 
    result.read(self._iprot)
2324 
    self._iprot.readMessageEnd()
2325 
    if result.success is not None:
2326 
      return result.success
2327 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2328 
 
2329 
  def validateRiskyStatus(self, itemId):
2330 
    """
2331 
    Check wether item is risky and change status if inventory is not available for risky items
2332 
 
2333 
    Parameters:
2334 
     - itemId
2335 
    """
2336 
    self.send_validateRiskyStatus(itemId)
2337 
    self.recv_validateRiskyStatus()
2338 
 
2339 
  def send_validateRiskyStatus(self, itemId):
2340 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2341 
    args = validateRiskyStatus_args()
2342 
    args.itemId = itemId
2343 
    args.write(self._oprot)
2344 
    self._oprot.writeMessageEnd()
2345 
    self._oprot.trans.flush()
2346 
 
2347 
  def recv_validateRiskyStatus(self, ):
2348 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2349 
    if mtype == TMessageType.EXCEPTION:
2350 
      x = TApplicationException()
2351 
      x.read(self._iprot)
2352 
      self._iprot.readMessageEnd()
2353 
      raise x
2354 
    result = validateRiskyStatus_result()
2355 
    result.read(self._iprot)
2356 
    self._iprot.readMessageEnd()
2357 
    return
2358 
 
2359 
  def changeItemRiskyFlag(self, itemId, risky):
2360 
    """
2361 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2362 
 
2363 
    Parameters:
2364 
     - itemId
2365 
     - risky
2366 
    """
2367 
    self.send_changeItemRiskyFlag(itemId, risky)
2368 
    self.recv_changeItemRiskyFlag()
2369 
 
2370 
  def send_changeItemRiskyFlag(self, itemId, risky):
2371 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2372 
    args = changeItemRiskyFlag_args()
2373 
    args.itemId = itemId
2374 
    args.risky = risky
2375 
    args.write(self._oprot)
2376 
    self._oprot.writeMessageEnd()
2377 
    self._oprot.trans.flush()
2378 
 
2379 
  def recv_changeItemRiskyFlag(self, ):
2380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2381 
    if mtype == TMessageType.EXCEPTION:
2382 
      x = TApplicationException()
2383 
      x.read(self._iprot)
2384 
      self._iprot.readMessageEnd()
2385 
      raise x
2386 
    result = changeItemRiskyFlag_result()
2387 
    result.read(self._iprot)
2388 
    self._iprot.readMessageEnd()
2389 
    return
2390 
 
2391 
  def getItemsByRiskyFlag(self, ):
2392 
    """
2393 
    Returns list of items marked as risky.
2394 
    """
2395 
    self.send_getItemsByRiskyFlag()
2396 
    return self.recv_getItemsByRiskyFlag()
2397 
 
2398 
  def send_getItemsByRiskyFlag(self, ):
2399 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2400 
    args = getItemsByRiskyFlag_args()
2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_getItemsByRiskyFlag(self, ):
2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
2412 
    result = getItemsByRiskyFlag_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
2415 
    if result.success is not None:
2416 
      return result.success
2417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2418 
 
2419 
  def getItemsForMasterSheet(self, category, brand):
2420 
    """
2421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2422 
 
2423 
    Parameters:
2424 
     - category
2425 
     - brand
2426 
    """
2427 
    self.send_getItemsForMasterSheet(category, brand)
2428 
    return self.recv_getItemsForMasterSheet()
2429 
 
2430 
  def send_getItemsForMasterSheet(self, category, brand):
2431 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2432 
    args = getItemsForMasterSheet_args()
2433 
    args.category = category
2434 
    args.brand = brand
2435 
    args.write(self._oprot)
2436 
    self._oprot.writeMessageEnd()
2437 
    self._oprot.trans.flush()
2438 
 
2439 
  def recv_getItemsForMasterSheet(self, ):
2440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2441 
    if mtype == TMessageType.EXCEPTION:
2442 
      x = TApplicationException()
2443 
      x.read(self._iprot)
2444 
      self._iprot.readMessageEnd()
2445 
      raise x
2446 
    result = getItemsForMasterSheet_result()
2447 
    result.read(self._iprot)
2448 
    self._iprot.readMessageEnd()
2449 
    if result.success is not None:
2450 
      return result.success
2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2452 
 
2453 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2454 
    """
2455 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2456 
 
2457 
    Parameters:
2458 
     - beginIndex
2459 
     - totalItems
2460 
     - itemId
2461 
    """
2462 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2463 
    return self.recv_getSimilarItemsCatalogIds()
2464 
 
2465 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2466 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2467 
    args = getSimilarItemsCatalogIds_args()
2468 
    args.beginIndex = beginIndex
2469 
    args.totalItems = totalItems
2470 
    args.itemId = itemId
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_getSimilarItemsCatalogIds(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = getSimilarItemsCatalogIds_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    if result.success is not None:
2486 
      return result.success
2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2488 
 
2489 
  def addProductNotification(self, itemId, email):
2490 
    """
2491 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2492 
 
2493 
    Parameters:
2494 
     - itemId
2495 
     - email
2496 
    """
2497 
    self.send_addProductNotification(itemId, email)
2498 
    return self.recv_addProductNotification()
2499 
 
2500 
  def send_addProductNotification(self, itemId, email):
2501 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2502 
    args = addProductNotification_args()
2503 
    args.itemId = itemId
2504 
    args.email = email
2505 
    args.write(self._oprot)
2506 
    self._oprot.writeMessageEnd()
2507 
    self._oprot.trans.flush()
2508 
 
2509 
  def recv_addProductNotification(self, ):
2510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2511 
    if mtype == TMessageType.EXCEPTION:
2512 
      x = TApplicationException()
2513 
      x.read(self._iprot)
2514 
      self._iprot.readMessageEnd()
2515 
      raise x
2516 
    result = addProductNotification_result()
2517 
    result.read(self._iprot)
2518 
    self._iprot.readMessageEnd()
2519 
    if result.success is not None:
2520 
      return result.success
2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2522 
 
2523 
  def sendProductNotifications(self, ):
2524 
    """
2525 
    Send the product notifications to the users for items which has stock.
2526 
    """
2527 
    self.send_sendProductNotifications()
2528 
    return self.recv_sendProductNotifications()
2529 
 
2530 
  def send_sendProductNotifications(self, ):
2531 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2532 
    args = sendProductNotifications_args()
2533 
    args.write(self._oprot)
2534 
    self._oprot.writeMessageEnd()
2535 
    self._oprot.trans.flush()
2536 
 
2537 
  def recv_sendProductNotifications(self, ):
2538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2539 
    if mtype == TMessageType.EXCEPTION:
2540 
      x = TApplicationException()
2541 
      x.read(self._iprot)
2542 
      self._iprot.readMessageEnd()
2543 
      raise x
2544 
    result = sendProductNotifications_result()
2545 
    result.read(self._iprot)
2546 
    self._iprot.readMessageEnd()
2547 
    if result.success is not None:
2548 
      return result.success
2549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2550 
 
2551 
  def getAllBrandsByCategory(self, categoryId):
2552 
    """
2553 
    Returns list of brand names for a given category Id
2554 
 
2555 
    Parameters:
2556 
     - categoryId
2557 
    """
2558 
    self.send_getAllBrandsByCategory(categoryId)
2559 
    return self.recv_getAllBrandsByCategory()
2560 
 
2561 
  def send_getAllBrandsByCategory(self, categoryId):
2562 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2563 
    args = getAllBrandsByCategory_args()
2564 
    args.categoryId = categoryId
2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_getAllBrandsByCategory(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = getAllBrandsByCategory_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
2579 
    if result.success is not None:
2580 
      return result.success
2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2582 
 
2583 
  def getAllBrands(self, ):
2584 
    """
2585 
    Returns list of brand names
2586 
    """
2587 
    self.send_getAllBrands()
2588 
    return self.recv_getAllBrands()
2589 
 
2590 
  def send_getAllBrands(self, ):
2591 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2592 
    args = getAllBrands_args()
2593 
    args.write(self._oprot)
2594 
    self._oprot.writeMessageEnd()
2595 
    self._oprot.trans.flush()
2596 
 
2597 
  def recv_getAllBrands(self, ):
2598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2599 
    if mtype == TMessageType.EXCEPTION:
2600 
      x = TApplicationException()
2601 
      x.read(self._iprot)
2602 
      self._iprot.readMessageEnd()
2603 
      raise x
2604 
    result = getAllBrands_result()
2605 
    result.read(self._iprot)
2606 
    self._iprot.readMessageEnd()
2607 
    if result.success is not None:
2608 
      return result.success
2609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2610 
 
2611 
  def getAllSources(self, ):
2612 
    """
2613 
    Return list of all sources
2614 
    """
2615 
    self.send_getAllSources()
2616 
    return self.recv_getAllSources()
2617 
 
2618 
  def send_getAllSources(self, ):
2619 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2620 
    args = getAllSources_args()
2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
2625 
  def recv_getAllSources(self, ):
2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
2632 
    result = getAllSources_result()
2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
2635 
    if result.success is not None:
2636 
      return result.success
2637 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2638 
 
2639 
  def getItemPricingBySource(self, itemId, sourceId):
2640 
    """
2641 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2642 
 
2643 
    Parameters:
2644 
     - itemId
2645 
     - sourceId
2646 
    """
2647 
    self.send_getItemPricingBySource(itemId, sourceId)
2648 
    return self.recv_getItemPricingBySource()
2649 
 
2650 
  def send_getItemPricingBySource(self, itemId, sourceId):
2651 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2652 
    args = getItemPricingBySource_args()
2653 
    args.itemId = itemId
2654 
    args.sourceId = sourceId
2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
2659 
  def recv_getItemPricingBySource(self, ):
2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
2666 
    result = getItemPricingBySource_result()
2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
2669 
    if result.success is not None:
2670 
      return result.success
2671 
    if result.cex is not None:
2672 
      raise result.cex
2673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2674 
 
2675 
  def addSourceItemPricing(self, sourceItemPricing):
2676 
    """
2677 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2678 
    If item is not found or source is not found, it will throw exception.
2679 
 
2680 
    Parameters:
2681 
     - sourceItemPricing
2682 
    """
2683 
    self.send_addSourceItemPricing(sourceItemPricing)
2684 
    self.recv_addSourceItemPricing()
2685 
 
2686 
  def send_addSourceItemPricing(self, sourceItemPricing):
2687 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2688 
    args = addSourceItemPricing_args()
2689 
    args.sourceItemPricing = sourceItemPricing
2690 
    args.write(self._oprot)
2691 
    self._oprot.writeMessageEnd()
2692 
    self._oprot.trans.flush()
2693 
 
2694 
  def recv_addSourceItemPricing(self, ):
2695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2696 
    if mtype == TMessageType.EXCEPTION:
2697 
      x = TApplicationException()
2698 
      x.read(self._iprot)
2699 
      self._iprot.readMessageEnd()
2700 
      raise x
2701 
    result = addSourceItemPricing_result()
2702 
    result.read(self._iprot)
2703 
    self._iprot.readMessageEnd()
2704 
    if result.cex is not None:
2705 
      raise result.cex
2706 
    return
2707 
 
2708 
  def getAllSourcePricing(self, itemId):
2709 
    """
2710 
    Returns the list of source pricing information of an item.
2711 
    Raises an exception if item not found corresponding to itemId
2712 
 
2713 
    Parameters:
2714 
     - itemId
2715 
    """
2716 
    self.send_getAllSourcePricing(itemId)
2717 
    return self.recv_getAllSourcePricing()
2718 
 
2719 
  def send_getAllSourcePricing(self, itemId):
2720 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2721 
    args = getAllSourcePricing_args()
2722 
    args.itemId = itemId
2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2727 
  def recv_getAllSourcePricing(self, ):
2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2734 
    result = getAllSourcePricing_result()
2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.success is not None:
2738 
      return result.success
2739 
    if result.cex is not None:
2740 
      raise result.cex
2741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2742 
 
2743 
  def getItemForSource(self, item_id, sourceId):
2744 
    """
2745 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2746 
 
2747 
    Parameters:
2748 
     - item_id
2749 
     - sourceId
2750 
    """
2751 
    self.send_getItemForSource(item_id, sourceId)
2752 
    return self.recv_getItemForSource()
2753 
 
2754 
  def send_getItemForSource(self, item_id, sourceId):
2755 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2756 
    args = getItemForSource_args()
2757 
    args.item_id = item_id
2758 
    args.sourceId = sourceId
2759 
    args.write(self._oprot)
2760 
    self._oprot.writeMessageEnd()
2761 
    self._oprot.trans.flush()
2762 
 
2763 
  def recv_getItemForSource(self, ):
2764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2765 
    if mtype == TMessageType.EXCEPTION:
2766 
      x = TApplicationException()
2767 
      x.read(self._iprot)
2768 
      self._iprot.readMessageEnd()
2769 
      raise x
2770 
    result = getItemForSource_result()
2771 
    result.read(self._iprot)
2772 
    self._iprot.readMessageEnd()
2773 
    if result.success is not None:
2774 
      return result.success
2775 
    if result.cex is not None:
2776 
      raise result.cex
2777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2778 
 
2779 
  def searchItemsInRange(self, searchTerms, offset, limit):
2780 
    """
2781 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2782 
 
2783 
    Parameters:
2784 
     - searchTerms
2785 
     - offset
2786 
     - limit
2787 
    """
2788 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2789 
    return self.recv_searchItemsInRange()
2790 
 
2791 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2792 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2793 
    args = searchItemsInRange_args()
2794 
    args.searchTerms = searchTerms
2795 
    args.offset = offset
2796 
    args.limit = limit
2797 
    args.write(self._oprot)
2798 
    self._oprot.writeMessageEnd()
2799 
    self._oprot.trans.flush()
2800 
 
2801 
  def recv_searchItemsInRange(self, ):
2802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2803 
    if mtype == TMessageType.EXCEPTION:
2804 
      x = TApplicationException()
2805 
      x.read(self._iprot)
2806 
      self._iprot.readMessageEnd()
2807 
      raise x
2808 
    result = searchItemsInRange_result()
2809 
    result.read(self._iprot)
2810 
    self._iprot.readMessageEnd()
2811 
    if result.success is not None:
2812 
      return result.success
2813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2814 
 
2815 
  def getSearchResultCount(self, searchTerms):
2816 
    """
2817 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2818 
 
2819 
    Parameters:
2820 
     - searchTerms
2821 
    """
2822 
    self.send_getSearchResultCount(searchTerms)
2823 
    return self.recv_getSearchResultCount()
2824 
 
2825 
  def send_getSearchResultCount(self, searchTerms):
2826 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2827 
    args = getSearchResultCount_args()
2828 
    args.searchTerms = searchTerms
2829 
    args.write(self._oprot)
2830 
    self._oprot.writeMessageEnd()
2831 
    self._oprot.trans.flush()
2832 
 
2833 
  def recv_getSearchResultCount(self, ):
2834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2835 
    if mtype == TMessageType.EXCEPTION:
2836 
      x = TApplicationException()
2837 
      x.read(self._iprot)
2838 
      self._iprot.readMessageEnd()
2839 
      raise x
2840 
    result = getSearchResultCount_result()
2841 
    result.read(self._iprot)
2842 
    self._iprot.readMessageEnd()
2843 
    if result.success is not None:
2844 
      return result.success
2845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2846 
 
2847 
  def getProductNotifications(self, startDateTime):
2848 
    """
2849 
    Returns a list of product notifications added after a supplied datetime
2850 
 
2851 
    Parameters:
2852 
     - startDateTime
2853 
    """
2854 
    self.send_getProductNotifications(startDateTime)
2855 
    return self.recv_getProductNotifications()
2856 
 
2857 
  def send_getProductNotifications(self, startDateTime):
2858 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2859 
    args = getProductNotifications_args()
2860 
    args.startDateTime = startDateTime
2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
2865 
  def recv_getProductNotifications(self, ):
2866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2867 
    if mtype == TMessageType.EXCEPTION:
2868 
      x = TApplicationException()
2869 
      x.read(self._iprot)
2870 
      self._iprot.readMessageEnd()
2871 
      raise x
2872 
    result = getProductNotifications_result()
2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
2875 
    if result.success is not None:
2876 
      return result.success
2877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2878 
 
2879 
  def getProductNotificationRequestCount(self, startDateTime):
2880 
    """
2881 
    Returns a list of count of requests for product notification against each item
2882 
 
2883 
    Parameters:
2884 
     - startDateTime
2885 
    """
2886 
    self.send_getProductNotificationRequestCount(startDateTime)
2887 
    return self.recv_getProductNotificationRequestCount()
2888 
 
2889 
  def send_getProductNotificationRequestCount(self, startDateTime):
2890 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2891 
    args = getProductNotificationRequestCount_args()
2892 
    args.startDateTime = startDateTime
2893 
    args.write(self._oprot)
2894 
    self._oprot.writeMessageEnd()
2895 
    self._oprot.trans.flush()
2896 
 
2897 
  def recv_getProductNotificationRequestCount(self, ):
2898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2899 
    if mtype == TMessageType.EXCEPTION:
2900 
      x = TApplicationException()
2901 
      x.read(self._iprot)
2902 
      self._iprot.readMessageEnd()
2903 
      raise x
2904 
    result = getProductNotificationRequestCount_result()
2905 
    result.read(self._iprot)
2906 
    self._iprot.readMessageEnd()
2907 
    if result.success is not None:
2908 
      return result.success
2909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2910 
 
2911 
  def addAuthorizationLog(self, itemId, username, reason):
2912 
    """
2913 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2914 
 
2915 
    Parameters:
2916 
     - itemId
2917 
     - username
2918 
     - reason
2919 
    """
2920 
    self.send_addAuthorizationLog(itemId, username, reason)
2921 
    return self.recv_addAuthorizationLog()
2922 
 
2923 
  def send_addAuthorizationLog(self, itemId, username, reason):
2924 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2925 
    args = addAuthorizationLog_args()
2926 
    args.itemId = itemId
2927 
    args.username = username
2928 
    args.reason = reason
2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
2933 
  def recv_addAuthorizationLog(self, ):
2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
2940 
    result = addAuthorizationLog_result()
2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
2943 
    if result.success is not None:
2944 
      return result.success
2945 
    if result.cex is not None:
2946 
      raise result.cex
2947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2948 
 
2949 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2950 
    """
2951 
    Parameters:
2952 
     - catalog_item_id
2953 
     - voucherType
2954 
     - voucherAmount
2955 
    """
2956 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2957 
    return self.recv_addupdateVoucherForItem()
2958 
 
2959 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2960 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2961 
    args = addupdateVoucherForItem_args()
2962 
    args.catalog_item_id = catalog_item_id
2963 
    args.voucherType = voucherType
2964 
    args.voucherAmount = voucherAmount
2965 
    args.write(self._oprot)
2966 
    self._oprot.writeMessageEnd()
2967 
    self._oprot.trans.flush()
2968 
 
2969 
  def recv_addupdateVoucherForItem(self, ):
2970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2971 
    if mtype == TMessageType.EXCEPTION:
2972 
      x = TApplicationException()
2973 
      x.read(self._iprot)
2974 
      self._iprot.readMessageEnd()
2975 
      raise x
2976 
    result = addupdateVoucherForItem_result()
2977 
    result.read(self._iprot)
2978 
    self._iprot.readMessageEnd()
2979 
    if result.success is not None:
2980 
      return result.success
2981 
    if result.cex is not None:
2982 
      raise result.cex
2983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2984 
 
2985 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2986 
    """
2987 
    Parameters:
2988 
     - catalog_item_id
2989 
     - voucherType
2990 
    """
2991 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
2992 
    return self.recv_deleteVoucherForItem()
2993 
 
2994 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
2995 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
2996 
    args = deleteVoucherForItem_args()
2997 
    args.catalog_item_id = catalog_item_id
2998 
    args.voucherType = voucherType
2999 
    args.write(self._oprot)
3000 
    self._oprot.writeMessageEnd()
3001 
    self._oprot.trans.flush()
3002 
 
3003 
  def recv_deleteVoucherForItem(self, ):
3004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3005 
    if mtype == TMessageType.EXCEPTION:
3006 
      x = TApplicationException()
3007 
      x.read(self._iprot)
3008 
      self._iprot.readMessageEnd()
3009 
      raise x
3010 
    result = deleteVoucherForItem_result()
3011 
    result.read(self._iprot)
3012 
    self._iprot.readMessageEnd()
3013 
    if result.success is not None:
3014 
      return result.success
3015 
    if result.cex is not None:
3016 
      raise result.cex
3017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3018 
 
3019 
  def getVoucherAmount(self, itemId, voucherType):
3020 
    """
3021 
    Parameters:
3022 
     - itemId
3023 
     - voucherType
3024 
    """
3025 
    self.send_getVoucherAmount(itemId, voucherType)
3026 
    return self.recv_getVoucherAmount()
3027 
 
3028 
  def send_getVoucherAmount(self, itemId, voucherType):
3029 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3030 
    args = getVoucherAmount_args()
3031 
    args.itemId = itemId
3032 
    args.voucherType = voucherType
3033 
    args.write(self._oprot)
3034 
    self._oprot.writeMessageEnd()
3035 
    self._oprot.trans.flush()
3036 
 
3037 
  def recv_getVoucherAmount(self, ):
3038 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3039 
    if mtype == TMessageType.EXCEPTION:
3040 
      x = TApplicationException()
3041 
      x.read(self._iprot)
3042 
      self._iprot.readMessageEnd()
3043 
      raise x
3044 
    result = getVoucherAmount_result()
3045 
    result.read(self._iprot)
3046 
    self._iprot.readMessageEnd()
3047 
    if result.success is not None:
3048 
      return result.success
3049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3050 
 
3051 
  def getAllItemVouchers(self, itemId):
3052 
    """
3053 
    Parameters:
3054 
     - itemId
3055 
    """
3056 
    self.send_getAllItemVouchers(itemId)
3057 
    return self.recv_getAllItemVouchers()
3058 
 
3059 
  def send_getAllItemVouchers(self, itemId):
3060 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3061 
    args = getAllItemVouchers_args()
3062 
    args.itemId = itemId
3063 
    args.write(self._oprot)
3064 
    self._oprot.writeMessageEnd()
3065 
    self._oprot.trans.flush()
3066 
 
3067 
  def recv_getAllItemVouchers(self, ):
3068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3069 
    if mtype == TMessageType.EXCEPTION:
3070 
      x = TApplicationException()
3071 
      x.read(self._iprot)
3072 
      self._iprot.readMessageEnd()
3073 
      raise x
3074 
    result = getAllItemVouchers_result()
3075 
    result.read(self._iprot)
3076 
    self._iprot.readMessageEnd()
3077 
    if result.success is not None:
3078 
      return result.success
3079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3080 
 
3081 
  def isValidCatalogItemId(self, catalog_item_id):
3082 
    """
3083 
    Parameters:
3084 
     - catalog_item_id
3085 
    """
3086 
    self.send_isValidCatalogItemId(catalog_item_id)
3087 
    return self.recv_isValidCatalogItemId()
3088 
 
3089 
  def send_isValidCatalogItemId(self, catalog_item_id):
3090 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3091 
    args = isValidCatalogItemId_args()
3092 
    args.catalog_item_id = catalog_item_id
3093 
    args.write(self._oprot)
3094 
    self._oprot.writeMessageEnd()
3095 
    self._oprot.trans.flush()
3096 
 
3097 
  def recv_isValidCatalogItemId(self, ):
3098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3099 
    if mtype == TMessageType.EXCEPTION:
3100 
      x = TApplicationException()
3101 
      x.read(self._iprot)
3102 
      self._iprot.readMessageEnd()
3103 
      raise x
3104 
    result = isValidCatalogItemId_result()
3105 
    result.read(self._iprot)
3106 
    self._iprot.readMessageEnd()
3107 
    if result.success is not None:
3108 
      return result.success
3109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3110 
 
6039 amit.gupta 3111 
  def getVatPercentageForItem(self, itemId, price):
3112 
    """
3113 
    Parameters:
3114 
     - itemId
3115 
     - price
3116 
    """
3117 
    self.send_getVatPercentageForItem(itemId, price)
3118 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3119 
 
6039 amit.gupta 3120 
  def send_getVatPercentageForItem(self, itemId, price):
3121 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3122 
    args = getVatPercentageForItem_args()
3123 
    args.itemId = itemId
3124 
    args.price = price
3125 
    args.write(self._oprot)
3126 
    self._oprot.writeMessageEnd()
3127 
    self._oprot.trans.flush()
3128 
 
3129 
  def recv_getVatPercentageForItem(self, ):
3130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3131 
    if mtype == TMessageType.EXCEPTION:
3132 
      x = TApplicationException()
3133 
      x.read(self._iprot)
3134 
      self._iprot.readMessageEnd()
3135 
      raise x
3136 
    result = getVatPercentageForItem_result()
3137 
    result.read(self._iprot)
3138 
    self._iprot.readMessageEnd()
3139 
    if result.success is not None:
3140 
      return result.success
3141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3142 
 
3143 
  def getVatAmountForItem(self, itemId, price):
3144 
    """
3145 
    Parameters:
3146 
     - itemId
3147 
     - price
3148 
    """
3149 
    self.send_getVatAmountForItem(itemId, price)
3150 
    return self.recv_getVatAmountForItem()
3151 
 
3152 
  def send_getVatAmountForItem(self, itemId, price):
3153 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3154 
    args = getVatAmountForItem_args()
3155 
    args.itemId = itemId
3156 
    args.price = price
3157 
    args.write(self._oprot)
3158 
    self._oprot.writeMessageEnd()
3159 
    self._oprot.trans.flush()
3160 
 
3161 
  def recv_getVatAmountForItem(self, ):
3162 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3163 
    if mtype == TMessageType.EXCEPTION:
3164 
      x = TApplicationException()
3165 
      x.read(self._iprot)
3166 
      self._iprot.readMessageEnd()
3167 
      raise x
3168 
    result = getVatAmountForItem_result()
3169 
    result.read(self._iprot)
3170 
    self._iprot.readMessageEnd()
3171 
    if result.success is not None:
3172 
      return result.success
3173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3174 
 
6531 vikram.rag 3175 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3176 
    """
3177 
    Parameters:
3178 
     - offset
3179 
     - limit
3180 
    """
3181 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3182 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3183 
 
6531 vikram.rag 3184 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3185 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3186 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3187 
    args.offset = offset
3188 
    args.limit = limit
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.success is not None:
3204 
      return result.success
3205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3206 
 
6821 amar.kumar 3207 
  def getAllAliveItems(self, ):
3208 
    self.send_getAllAliveItems()
3209 
    return self.recv_getAllAliveItems()
3210 
 
3211 
  def send_getAllAliveItems(self, ):
3212 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3213 
    args = getAllAliveItems_args()
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
3218 
  def recv_getAllAliveItems(self, ):
3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
3225 
    result = getAllAliveItems_result()
3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3231 
 
6921 anupam.sin 3232 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3233 
    """
3234 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3235 
 
6805 anupam.sin 3236 
    Parameters:
3237 
     - itemId
6921 anupam.sin 3238 
     - price
6805 anupam.sin 3239 
     - insurerId
3240 
     - quantity
3241 
    """
6921 anupam.sin 3242 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3243 
    return self.recv_getInsuranceAmount()
3244 
 
6921 anupam.sin 3245 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3246 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3247 
    args = getInsuranceAmount_args()
3248 
    args.itemId = itemId
6921 anupam.sin 3249 
    args.price = price
6805 anupam.sin 3250 
    args.insurerId = insurerId
3251 
    args.quantity = quantity
3252 
    args.write(self._oprot)
3253 
    self._oprot.writeMessageEnd()
3254 
    self._oprot.trans.flush()
3255 
 
3256 
  def recv_getInsuranceAmount(self, ):
3257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3258 
    if mtype == TMessageType.EXCEPTION:
3259 
      x = TApplicationException()
3260 
      x.read(self._iprot)
3261 
      self._iprot.readMessageEnd()
3262 
      raise x
3263 
    result = getInsuranceAmount_result()
3264 
    result.read(self._iprot)
3265 
    self._iprot.readMessageEnd()
3266 
    if result.success is not None:
3267 
      return result.success
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3269 
 
3270 
  def getInsurer(self, insurerId):
3271 
    """
3272 
    Parameters:
3273 
     - insurerId
3274 
    """
3275 
    self.send_getInsurer(insurerId)
3276 
    return self.recv_getInsurer()
3277 
 
3278 
  def send_getInsurer(self, insurerId):
3279 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3280 
    args = getInsurer_args()
3281 
    args.insurerId = insurerId
3282 
    args.write(self._oprot)
3283 
    self._oprot.writeMessageEnd()
3284 
    self._oprot.trans.flush()
3285 
 
3286 
  def recv_getInsurer(self, ):
3287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3288 
    if mtype == TMessageType.EXCEPTION:
3289 
      x = TApplicationException()
3290 
      x.read(self._iprot)
3291 
      self._iprot.readMessageEnd()
3292 
      raise x
3293 
    result = getInsurer_result()
3294 
    result.read(self._iprot)
3295 
    self._iprot.readMessageEnd()
3296 
    if result.success is not None:
3297 
      return result.success
3298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3299 
 
6838 vikram.rag 3300 
  def getAllInsurers(self, ):
3301 
    self.send_getAllInsurers()
3302 
    return self.recv_getAllInsurers()
6805 anupam.sin 3303 
 
6838 vikram.rag 3304 
  def send_getAllInsurers(self, ):
3305 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3306 
    args = getAllInsurers_args()
3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_getAllInsurers(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = getAllInsurers_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
3321 
    if result.success is not None:
3322 
      return result.success
3323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3324 
 
6962 rajveer 3325 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3326 
    """
3327 
    Parameters:
3328 
     - insurerId
3329 
     - amount
3330 
    """
3331 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3332 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3333 
 
6962 rajveer 3334 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3335 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3336 
    args = updateInsuranceDeclaredAmount_args()
3337 
    args.insurerId = insurerId
3338 
    args.amount = amount
3339 
    args.write(self._oprot)
3340 
    self._oprot.writeMessageEnd()
3341 
    self._oprot.trans.flush()
3342 
 
3343 
  def recv_updateInsuranceDeclaredAmount(self, ):
3344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3345 
    if mtype == TMessageType.EXCEPTION:
3346 
      x = TApplicationException()
3347 
      x.read(self._iprot)
3348 
      self._iprot.readMessageEnd()
3349 
      raise x
3350 
    result = updateInsuranceDeclaredAmount_result()
3351 
    result.read(self._iprot)
3352 
    self._iprot.readMessageEnd()
3353 
    return
3354 
 
7190 amar.kumar 3355 
  def getFreebieForItem(self, itemId):
3356 
    """
3357 
    Parameters:
3358 
     - itemId
3359 
    """
3360 
    self.send_getFreebieForItem(itemId)
3361 
    return self.recv_getFreebieForItem()
6962 rajveer 3362 
 
7190 amar.kumar 3363 
  def send_getFreebieForItem(self, itemId):
3364 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3365 
    args = getFreebieForItem_args()
3366 
    args.itemId = itemId
3367 
    args.write(self._oprot)
3368 
    self._oprot.writeMessageEnd()
3369 
    self._oprot.trans.flush()
3370 
 
3371 
  def recv_getFreebieForItem(self, ):
3372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3373 
    if mtype == TMessageType.EXCEPTION:
3374 
      x = TApplicationException()
3375 
      x.read(self._iprot)
3376 
      self._iprot.readMessageEnd()
3377 
      raise x
3378 
    result = getFreebieForItem_result()
3379 
    result.read(self._iprot)
3380 
    self._iprot.readMessageEnd()
3381 
    if result.success is not None:
3382 
      return result.success
3383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3384 
 
3385 
  def addOrUpdateFreebieForItem(self, freebieItem):
3386 
    """
3387 
    Parameters:
3388 
     - freebieItem
3389 
    """
3390 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3391 
    self.recv_addOrUpdateFreebieForItem()
3392 
 
3393 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3394 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3395 
    args = addOrUpdateFreebieForItem_args()
3396 
    args.freebieItem = freebieItem
3397 
    args.write(self._oprot)
3398 
    self._oprot.writeMessageEnd()
3399 
    self._oprot.trans.flush()
3400 
 
3401 
  def recv_addOrUpdateFreebieForItem(self, ):
3402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3403 
    if mtype == TMessageType.EXCEPTION:
3404 
      x = TApplicationException()
3405 
      x.read(self._iprot)
3406 
      self._iprot.readMessageEnd()
3407 
      raise x
3408 
    result = addOrUpdateFreebieForItem_result()
3409 
    result.read(self._iprot)
3410 
    self._iprot.readMessageEnd()
3411 
    return
3412 
 
7272 amit.gupta 3413 
  def addOrUpdateBrandInfo(self, brandInfo):
3414 
    """
3415 
    Parameters:
3416 
     - brandInfo
3417 
    """
3418 
    self.send_addOrUpdateBrandInfo(brandInfo)
3419 
    self.recv_addOrUpdateBrandInfo()
3420 
 
3421 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3422 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3423 
    args = addOrUpdateBrandInfo_args()
3424 
    args.brandInfo = brandInfo
3425 
    args.write(self._oprot)
3426 
    self._oprot.writeMessageEnd()
3427 
    self._oprot.trans.flush()
3428 
 
3429 
  def recv_addOrUpdateBrandInfo(self, ):
3430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3431 
    if mtype == TMessageType.EXCEPTION:
3432 
      x = TApplicationException()
3433 
      x.read(self._iprot)
3434 
      self._iprot.readMessageEnd()
3435 
      raise x
3436 
    result = addOrUpdateBrandInfo_result()
3437 
    result.read(self._iprot)
3438 
    self._iprot.readMessageEnd()
3439 
    return
3440 
 
3441 
  def getBrandInfo(self, ):
3442 
    self.send_getBrandInfo()
3443 
    return self.recv_getBrandInfo()
3444 
 
3445 
  def send_getBrandInfo(self, ):
3446 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3447 
    args = getBrandInfo_args()
3448 
    args.write(self._oprot)
3449 
    self._oprot.writeMessageEnd()
3450 
    self._oprot.trans.flush()
3451 
 
3452 
  def recv_getBrandInfo(self, ):
3453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3454 
    if mtype == TMessageType.EXCEPTION:
3455 
      x = TApplicationException()
3456 
      x.read(self._iprot)
3457 
      self._iprot.readMessageEnd()
3458 
      raise x
3459 
    result = getBrandInfo_result()
3460 
    result.read(self._iprot)
3461 
    self._iprot.readMessageEnd()
3462 
    if result.success is not None:
3463 
      return result.success
3464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3465 
 
7256 rajveer 3466 
  def getStorePricing(self, itemId):
3467 
    """
3468 
    Parameters:
3469 
     - itemId
3470 
    """
3471 
    self.send_getStorePricing(itemId)
3472 
    return self.recv_getStorePricing()
7190 amar.kumar 3473 
 
7256 rajveer 3474 
  def send_getStorePricing(self, itemId):
3475 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3476 
    args = getStorePricing_args()
3477 
    args.itemId = itemId
3478 
    args.write(self._oprot)
3479 
    self._oprot.writeMessageEnd()
3480 
    self._oprot.trans.flush()
3481 
 
3482 
  def recv_getStorePricing(self, ):
3483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3484 
    if mtype == TMessageType.EXCEPTION:
3485 
      x = TApplicationException()
3486 
      x.read(self._iprot)
3487 
      self._iprot.readMessageEnd()
3488 
      raise x
3489 
    result = getStorePricing_result()
3490 
    result.read(self._iprot)
3491 
    self._iprot.readMessageEnd()
3492 
    if result.success is not None:
3493 
      return result.success
3494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3495 
 
7265 rajveer 3496 
  def updateStorePricing(self, sp):
3497 
    """
3498 
    Parameters:
3499 
     - sp
3500 
    """
3501 
    self.send_updateStorePricing(sp)
3502 
    self.recv_updateStorePricing()
7256 rajveer 3503 
 
7265 rajveer 3504 
  def send_updateStorePricing(self, sp):
3505 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3506 
    args = updateStorePricing_args()
3507 
    args.sp = sp
3508 
    args.write(self._oprot)
3509 
    self._oprot.writeMessageEnd()
3510 
    self._oprot.trans.flush()
3511 
 
3512 
  def recv_updateStorePricing(self, ):
3513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3514 
    if mtype == TMessageType.EXCEPTION:
3515 
      x = TApplicationException()
3516 
      x.read(self._iprot)
3517 
      self._iprot.readMessageEnd()
3518 
      raise x
3519 
    result = updateStorePricing_result()
3520 
    result.read(self._iprot)
3521 
    self._iprot.readMessageEnd()
3522 
    return
3523 
 
7281 kshitij.so 3524 
  def getAllAmazonListedItems(self, ):
3525 
    self.send_getAllAmazonListedItems()
3526 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3527 
 
7281 kshitij.so 3528 
  def send_getAllAmazonListedItems(self, ):
3529 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3530 
    args = getAllAmazonListedItems_args()
3531 
    args.write(self._oprot)
3532 
    self._oprot.writeMessageEnd()
3533 
    self._oprot.trans.flush()
3534 
 
3535 
  def recv_getAllAmazonListedItems(self, ):
3536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3537 
    if mtype == TMessageType.EXCEPTION:
3538 
      x = TApplicationException()
3539 
      x.read(self._iprot)
3540 
      self._iprot.readMessageEnd()
3541 
      raise x
3542 
    result = getAllAmazonListedItems_result()
3543 
    result.read(self._iprot)
3544 
    self._iprot.readMessageEnd()
3545 
    if result.success is not None:
3546 
      return result.success
3547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3548 
 
3549 
  def getAmazonItemDetails(self, itemId):
3550 
    """
3551 
    Parameters:
3552 
     - itemId
3553 
    """
3554 
    self.send_getAmazonItemDetails(itemId)
3555 
    return self.recv_getAmazonItemDetails()
3556 
 
3557 
  def send_getAmazonItemDetails(self, itemId):
3558 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3559 
    args = getAmazonItemDetails_args()
3560 
    args.itemId = itemId
3561 
    args.write(self._oprot)
3562 
    self._oprot.writeMessageEnd()
3563 
    self._oprot.trans.flush()
3564 
 
3565 
  def recv_getAmazonItemDetails(self, ):
3566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3567 
    if mtype == TMessageType.EXCEPTION:
3568 
      x = TApplicationException()
3569 
      x.read(self._iprot)
3570 
      self._iprot.readMessageEnd()
3571 
      raise x
3572 
    result = getAmazonItemDetails_result()
3573 
    result.read(self._iprot)
3574 
    self._iprot.readMessageEnd()
3575 
    if result.success is not None:
3576 
      return result.success
3577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3578 
 
3579 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3580 
    """
3581 
    Parameters:
3582 
     - itemId
3583 
     - fbaPrice
3584 
     - sellingPrice
3585 
     - isFba
3586 
     - isNonFba
3587 
     - isInventoryOverride
3588 
    """
3589 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride)
3590 
    self.recv_updateAmazonItemDetails()
3591 
 
3592 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3593 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3594 
    args = updateAmazonItemDetails_args()
3595 
    args.itemId = itemId
3596 
    args.fbaPrice = fbaPrice
3597 
    args.sellingPrice = sellingPrice
3598 
    args.isFba = isFba
3599 
    args.isNonFba = isNonFba
3600 
    args.isInventoryOverride = isInventoryOverride
3601 
    args.write(self._oprot)
3602 
    self._oprot.writeMessageEnd()
3603 
    self._oprot.trans.flush()
3604 
 
3605 
  def recv_updateAmazonItemDetails(self, ):
3606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3607 
    if mtype == TMessageType.EXCEPTION:
3608 
      x = TApplicationException()
3609 
      x.read(self._iprot)
3610 
      self._iprot.readMessageEnd()
3611 
      raise x
3612 
    result = updateAmazonItemDetails_result()
3613 
    result.read(self._iprot)
3614 
    self._iprot.readMessageEnd()
3615 
    return
3616 
 
3617 
  def addAmazonItem(self, amazonlisted):
3618 
    """
3619 
    Parameters:
3620 
     - amazonlisted
3621 
    """
3622 
    self.send_addAmazonItem(amazonlisted)
3623 
    self.recv_addAmazonItem()
3624 
 
3625 
  def send_addAmazonItem(self, amazonlisted):
3626 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3627 
    args = addAmazonItem_args()
3628 
    args.amazonlisted = amazonlisted
3629 
    args.write(self._oprot)
3630 
    self._oprot.writeMessageEnd()
3631 
    self._oprot.trans.flush()
3632 
 
3633 
  def recv_addAmazonItem(self, ):
3634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3635 
    if mtype == TMessageType.EXCEPTION:
3636 
      x = TApplicationException()
3637 
      x.read(self._iprot)
3638 
      self._iprot.readMessageEnd()
3639 
      raise x
3640 
    result = addAmazonItem_result()
3641 
    result.read(self._iprot)
3642 
    self._iprot.readMessageEnd()
3643 
    return
3644 
 
7291 vikram.rag 3645 
  def getAsinItems(self, ):
3646 
    self.send_getAsinItems()
3647 
    return self.recv_getAsinItems()
7281 kshitij.so 3648 
 
7291 vikram.rag 3649 
  def send_getAsinItems(self, ):
3650 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3651 
    args = getAsinItems_args()
3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_getAsinItems(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = getAsinItems_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
3666 
    if result.success is not None:
3667 
      return result.success
3668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3669 
 
3670 
  def getAllFbaListedItems(self, ):
3671 
    self.send_getAllFbaListedItems()
3672 
    return self.recv_getAllFbaListedItems()
3673 
 
3674 
  def send_getAllFbaListedItems(self, ):
3675 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3676 
    args = getAllFbaListedItems_args()
3677 
    args.write(self._oprot)
3678 
    self._oprot.writeMessageEnd()
3679 
    self._oprot.trans.flush()
3680 
 
3681 
  def recv_getAllFbaListedItems(self, ):
3682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3683 
    if mtype == TMessageType.EXCEPTION:
3684 
      x = TApplicationException()
3685 
      x.read(self._iprot)
3686 
      self._iprot.readMessageEnd()
3687 
      raise x
3688 
    result = getAllFbaListedItems_result()
3689 
    result.read(self._iprot)
3690 
    self._iprot.readMessageEnd()
3691 
    if result.success is not None:
3692 
      return result.success
3693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3694 
 
3695 
  def getAllNonFbaListedItems(self, ):
3696 
    self.send_getAllNonFbaListedItems()
3697 
    return self.recv_getAllNonFbaListedItems()
3698 
 
3699 
  def send_getAllNonFbaListedItems(self, ):
3700 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3701 
    args = getAllNonFbaListedItems_args()
3702 
    args.write(self._oprot)
3703 
    self._oprot.writeMessageEnd()
3704 
    self._oprot.trans.flush()
3705 
 
3706 
  def recv_getAllNonFbaListedItems(self, ):
3707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3708 
    if mtype == TMessageType.EXCEPTION:
3709 
      x = TApplicationException()
3710 
      x.read(self._iprot)
3711 
      self._iprot.readMessageEnd()
3712 
      raise x
3713 
    result = getAllNonFbaListedItems_result()
3714 
    result.read(self._iprot)
3715 
    self._iprot.readMessageEnd()
3716 
    if result.success is not None:
3717 
      return result.success
3718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3719 
 
3720 
 
5944 mandeep.dh 3721 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3722 
  def __init__(self, handler):
3723 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3724 
    self._processMap["addItem"] = Processor.process_addItem
3725 
    self._processMap["updateItem"] = Processor.process_updateItem
3726 
    self._processMap["isActive"] = Processor.process_isActive
3727 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3728 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3729 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3730 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3731 
    self._processMap["getItem"] = Processor.process_getItem
3732 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3733 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3734 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3735 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3736 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3737 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3738 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3739 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3740 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3741 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3742 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3743 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3744 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3745 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3746 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3747 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3748 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3749 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3750 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3751 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3752 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3753 
    self._processMap["addCategory"] = Processor.process_addCategory
3754 
    self._processMap["getCategory"] = Processor.process_getCategory
3755 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3756 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3757 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3758 
    self._processMap["addTag"] = Processor.process_addTag
3759 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3760 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3761 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3762 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3763 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3764 
    self._processMap["addBanner"] = Processor.process_addBanner
3765 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3766 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3767 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3768 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3769 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3770 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3771 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3772 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3773 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3774 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3775 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3776 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3777 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3778 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3779 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3780 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3781 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3782 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3783 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3784 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3785 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3786 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3787 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3788 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3789 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3790 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3791 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3792 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3793 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3794 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3795 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3796 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3797 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3798 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3799 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3800 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3801 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3802 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3803 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3804 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3805 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3806 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3807 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3808 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3809 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3810 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7265 rajveer 3811 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3812 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3813 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3814 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3815 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3816 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3817 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3818 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3819 
 
3820 
  def process(self, iprot, oprot):
3821 
    (name, type, seqid) = iprot.readMessageBegin()
3822 
    if name not in self._processMap:
3823 
      iprot.skip(TType.STRUCT)
3824 
      iprot.readMessageEnd()
3825 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3826 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3827 
      x.write(oprot)
3828 
      oprot.writeMessageEnd()
3829 
      oprot.trans.flush()
3830 
      return
3831 
    else:
3832 
      self._processMap[name](self, seqid, iprot, oprot)
3833 
    return True
3834 
 
3835 
  def process_addItem(self, seqid, iprot, oprot):
3836 
    args = addItem_args()
3837 
    args.read(iprot)
3838 
    iprot.readMessageEnd()
3839 
    result = addItem_result()
3840 
    try:
3841 
      result.success = self._handler.addItem(args.item)
3842 
    except CatalogServiceException, cex:
3843 
      result.cex = cex
3844 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3845 
    result.write(oprot)
3846 
    oprot.writeMessageEnd()
3847 
    oprot.trans.flush()
3848 
 
3849 
  def process_updateItem(self, seqid, iprot, oprot):
3850 
    args = updateItem_args()
3851 
    args.read(iprot)
3852 
    iprot.readMessageEnd()
3853 
    result = updateItem_result()
3854 
    try:
3855 
      result.success = self._handler.updateItem(args.item)
3856 
    except CatalogServiceException, cex:
3857 
      result.cex = cex
3858 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3859 
    result.write(oprot)
3860 
    oprot.writeMessageEnd()
3861 
    oprot.trans.flush()
3862 
 
3863 
  def process_isActive(self, seqid, iprot, oprot):
3864 
    args = isActive_args()
3865 
    args.read(iprot)
3866 
    iprot.readMessageEnd()
3867 
    result = isActive_result()
3868 
    try:
3869 
      result.success = self._handler.isActive(args.itemId)
3870 
    except CatalogServiceException, isex:
3871 
      result.isex = isex
3872 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3873 
    result.write(oprot)
3874 
    oprot.writeMessageEnd()
3875 
    oprot.trans.flush()
3876 
 
3877 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3878 
    args = getItemStatusDescription_args()
3879 
    args.read(iprot)
3880 
    iprot.readMessageEnd()
3881 
    result = getItemStatusDescription_result()
3882 
    try:
3883 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3884 
    except CatalogServiceException, isex:
3885 
      result.isex = isex
3886 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3887 
    result.write(oprot)
3888 
    oprot.writeMessageEnd()
3889 
    oprot.trans.flush()
3890 
 
3891 
  def process_startItemOn(self, seqid, iprot, oprot):
3892 
    args = startItemOn_args()
3893 
    args.read(iprot)
3894 
    iprot.readMessageEnd()
3895 
    result = startItemOn_result()
3896 
    try:
3897 
      self._handler.startItemOn(args.item_id, args.timestamp)
3898 
    except CatalogServiceException, cex:
3899 
      result.cex = cex
3900 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3901 
    result.write(oprot)
3902 
    oprot.writeMessageEnd()
3903 
    oprot.trans.flush()
3904 
 
3905 
  def process_retireItemOn(self, seqid, iprot, oprot):
3906 
    args = retireItemOn_args()
3907 
    args.read(iprot)
3908 
    iprot.readMessageEnd()
3909 
    result = retireItemOn_result()
3910 
    try:
3911 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3912 
    except CatalogServiceException, cex:
3913 
      result.cex = cex
3914 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3915 
    result.write(oprot)
3916 
    oprot.writeMessageEnd()
3917 
    oprot.trans.flush()
3918 
 
3919 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3920 
    args = changeItemStatus_args()
3921 
    args.read(iprot)
3922 
    iprot.readMessageEnd()
3923 
    result = changeItemStatus_result()
3924 
    try:
3925 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3926 
    except CatalogServiceException, cex:
3927 
      result.cex = cex
3928 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3929 
    result.write(oprot)
3930 
    oprot.writeMessageEnd()
3931 
    oprot.trans.flush()
3932 
 
3933 
  def process_getItem(self, seqid, iprot, oprot):
3934 
    args = getItem_args()
3935 
    args.read(iprot)
3936 
    iprot.readMessageEnd()
3937 
    result = getItem_result()
3938 
    try:
3939 
      result.success = self._handler.getItem(args.item_id)
3940 
    except CatalogServiceException, cex:
3941 
      result.cex = cex
3942 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3943 
    result.write(oprot)
3944 
    oprot.writeMessageEnd()
3945 
    oprot.trans.flush()
3946 
 
3947 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3948 
    args = getItemsByCatalogId_args()
3949 
    args.read(iprot)
3950 
    iprot.readMessageEnd()
3951 
    result = getItemsByCatalogId_result()
3952 
    try:
3953 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
3954 
    except CatalogServiceException, cex:
3955 
      result.cex = cex
3956 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
3957 
    result.write(oprot)
3958 
    oprot.writeMessageEnd()
3959 
    oprot.trans.flush()
3960 
 
3961 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
3962 
    args = getValidItemsByCatalogId_args()
3963 
    args.read(iprot)
3964 
    iprot.readMessageEnd()
3965 
    result = getValidItemsByCatalogId_result()
3966 
    try:
3967 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
3968 
    except CatalogServiceException, cex:
3969 
      result.cex = cex
3970 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
3971 
    result.write(oprot)
3972 
    oprot.writeMessageEnd()
3973 
    oprot.trans.flush()
3974 
 
3975 
  def process_getAllItems(self, seqid, iprot, oprot):
3976 
    args = getAllItems_args()
3977 
    args.read(iprot)
3978 
    iprot.readMessageEnd()
3979 
    result = getAllItems_result()
3980 
    try:
3981 
      result.success = self._handler.getAllItems(args.isActive)
3982 
    except CatalogServiceException, cex:
3983 
      result.cex = cex
3984 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
3985 
    result.write(oprot)
3986 
    oprot.writeMessageEnd()
3987 
    oprot.trans.flush()
3988 
 
3989 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
3990 
    args = getAllItemsByStatus_args()
3991 
    args.read(iprot)
3992 
    iprot.readMessageEnd()
3993 
    result = getAllItemsByStatus_result()
3994 
    try:
3995 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
3996 
    except CatalogServiceException, cex:
3997 
      result.cex = cex
3998 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
3999 
    result.write(oprot)
4000 
    oprot.writeMessageEnd()
4001 
    oprot.trans.flush()
4002 
 
4003 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4004 
    args = markItemAsContentComplete_args()
4005 
    args.read(iprot)
4006 
    iprot.readMessageEnd()
4007 
    result = markItemAsContentComplete_result()
4008 
    try:
4009 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4010 
    except CatalogServiceException, cex:
4011 
      result.cex = cex
4012 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4013 
    result.write(oprot)
4014 
    oprot.writeMessageEnd()
4015 
    oprot.trans.flush()
4016 
 
4017 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4018 
    args = getAllItemsInRange_args()
4019 
    args.read(iprot)
4020 
    iprot.readMessageEnd()
4021 
    result = getAllItemsInRange_result()
4022 
    try:
4023 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4024 
    except CatalogServiceException, cex:
4025 
      result.cex = cex
4026 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4027 
    result.write(oprot)
4028 
    oprot.writeMessageEnd()
4029 
    oprot.trans.flush()
4030 
 
4031 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4032 
    args = getAllItemsByStatusInRange_args()
4033 
    args.read(iprot)
4034 
    iprot.readMessageEnd()
4035 
    result = getAllItemsByStatusInRange_result()
4036 
    try:
4037 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4038 
    except CatalogServiceException, cex:
4039 
      result.cex = cex
4040 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4041 
    result.write(oprot)
4042 
    oprot.writeMessageEnd()
4043 
    oprot.trans.flush()
4044 
 
4045 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4046 
    args = getItemCountByStatus_args()
4047 
    args.read(iprot)
4048 
    iprot.readMessageEnd()
4049 
    result = getItemCountByStatus_result()
4050 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4051 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4052 
    result.write(oprot)
4053 
    oprot.writeMessageEnd()
4054 
    oprot.trans.flush()
4055 
 
4056 
  def process_getBestSellers(self, seqid, iprot, oprot):
4057 
    args = getBestSellers_args()
4058 
    args.read(iprot)
4059 
    iprot.readMessageEnd()
4060 
    result = getBestSellers_result()
4061 
    try:
4062 
      result.success = self._handler.getBestSellers()
4063 
    except CatalogServiceException, isex:
4064 
      result.isex = isex
4065 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4066 
    result.write(oprot)
4067 
    oprot.writeMessageEnd()
4068 
    oprot.trans.flush()
4069 
 
4070 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4071 
    args = getBestSellersCatalogIds_args()
4072 
    args.read(iprot)
4073 
    iprot.readMessageEnd()
4074 
    result = getBestSellersCatalogIds_result()
4075 
    try:
4076 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4077 
    except CatalogServiceException, cex:
4078 
      result.cex = cex
4079 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4080 
    result.write(oprot)
4081 
    oprot.writeMessageEnd()
4082 
    oprot.trans.flush()
4083 
 
4084 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4085 
    args = getBestSellersCount_args()
4086 
    args.read(iprot)
4087 
    iprot.readMessageEnd()
4088 
    result = getBestSellersCount_result()
4089 
    try:
4090 
      result.success = self._handler.getBestSellersCount()
4091 
    except CatalogServiceException, cex:
4092 
      result.cex = cex
4093 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4094 
    result.write(oprot)
4095 
    oprot.writeMessageEnd()
4096 
    oprot.trans.flush()
4097 
 
4098 
  def process_getBestDeals(self, seqid, iprot, oprot):
4099 
    args = getBestDeals_args()
4100 
    args.read(iprot)
4101 
    iprot.readMessageEnd()
4102 
    result = getBestDeals_result()
4103 
    try:
4104 
      result.success = self._handler.getBestDeals()
4105 
    except CatalogServiceException, isex:
4106 
      result.isex = isex
4107 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4108 
    result.write(oprot)
4109 
    oprot.writeMessageEnd()
4110 
    oprot.trans.flush()
4111 
 
4112 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4113 
    args = getBestDealsCatalogIds_args()
4114 
    args.read(iprot)
4115 
    iprot.readMessageEnd()
4116 
    result = getBestDealsCatalogIds_result()
4117 
    try:
4118 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4119 
    except CatalogServiceException, cex:
4120 
      result.cex = cex
4121 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4122 
    result.write(oprot)
4123 
    oprot.writeMessageEnd()
4124 
    oprot.trans.flush()
4125 
 
4126 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4127 
    args = getBestDealsCount_args()
4128 
    args.read(iprot)
4129 
    iprot.readMessageEnd()
4130 
    result = getBestDealsCount_result()
4131 
    try:
4132 
      result.success = self._handler.getBestDealsCount()
4133 
    except CatalogServiceException, cex:
4134 
      result.cex = cex
4135 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4136 
    result.write(oprot)
4137 
    oprot.writeMessageEnd()
4138 
    oprot.trans.flush()
4139 
 
4140 
  def process_getComingSoon(self, seqid, iprot, oprot):
4141 
    args = getComingSoon_args()
4142 
    args.read(iprot)
4143 
    iprot.readMessageEnd()
4144 
    result = getComingSoon_result()
4145 
    try:
4146 
      result.success = self._handler.getComingSoon()
4147 
    except CatalogServiceException, isex:
4148 
      result.isex = isex
4149 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4150 
    result.write(oprot)
4151 
    oprot.writeMessageEnd()
4152 
    oprot.trans.flush()
4153 
 
4154 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4155 
    args = getComingSoonCatalogIds_args()
4156 
    args.read(iprot)
4157 
    iprot.readMessageEnd()
4158 
    result = getComingSoonCatalogIds_result()
4159 
    try:
4160 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4161 
    except CatalogServiceException, cex:
4162 
      result.cex = cex
4163 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4164 
    result.write(oprot)
4165 
    oprot.writeMessageEnd()
4166 
    oprot.trans.flush()
4167 
 
4168 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4169 
    args = getComingSoonCount_args()
4170 
    args.read(iprot)
4171 
    iprot.readMessageEnd()
4172 
    result = getComingSoonCount_result()
4173 
    try:
4174 
      result.success = self._handler.getComingSoonCount()
4175 
    except CatalogServiceException, cex:
4176 
      result.cex = cex
4177 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4178 
    result.write(oprot)
4179 
    oprot.writeMessageEnd()
4180 
    oprot.trans.flush()
4181 
 
4182 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4183 
    args = getLatestArrivals_args()
4184 
    args.read(iprot)
4185 
    iprot.readMessageEnd()
4186 
    result = getLatestArrivals_result()
4187 
    try:
4188 
      result.success = self._handler.getLatestArrivals()
4189 
    except CatalogServiceException, isex:
4190 
      result.isex = isex
4191 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4192 
    result.write(oprot)
4193 
    oprot.writeMessageEnd()
4194 
    oprot.trans.flush()
4195 
 
4196 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4197 
    args = getLatestArrivalsCatalogIds_args()
4198 
    args.read(iprot)
4199 
    iprot.readMessageEnd()
4200 
    result = getLatestArrivalsCatalogIds_result()
4201 
    try:
4202 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4203 
    except CatalogServiceException, cex:
4204 
      result.cex = cex
4205 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4206 
    result.write(oprot)
4207 
    oprot.writeMessageEnd()
4208 
    oprot.trans.flush()
4209 
 
4210 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4211 
    args = getLatestArrivalsCount_args()
4212 
    args.read(iprot)
4213 
    iprot.readMessageEnd()
4214 
    result = getLatestArrivalsCount_result()
4215 
    try:
4216 
      result.success = self._handler.getLatestArrivalsCount()
4217 
    except CatalogServiceException, cex:
4218 
      result.cex = cex
4219 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4220 
    result.write(oprot)
4221 
    oprot.writeMessageEnd()
4222 
    oprot.trans.flush()
4223 
 
4224 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4225 
    args = generateNewEntityID_args()
4226 
    args.read(iprot)
4227 
    iprot.readMessageEnd()
4228 
    result = generateNewEntityID_result()
4229 
    result.success = self._handler.generateNewEntityID()
4230 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4231 
    result.write(oprot)
4232 
    oprot.writeMessageEnd()
4233 
    oprot.trans.flush()
4234 
 
4235 
  def process_addCategory(self, seqid, iprot, oprot):
4236 
    args = addCategory_args()
4237 
    args.read(iprot)
4238 
    iprot.readMessageEnd()
4239 
    result = addCategory_result()
4240 
    result.success = self._handler.addCategory(args.category)
4241 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4242 
    result.write(oprot)
4243 
    oprot.writeMessageEnd()
4244 
    oprot.trans.flush()
4245 
 
4246 
  def process_getCategory(self, seqid, iprot, oprot):
4247 
    args = getCategory_args()
4248 
    args.read(iprot)
4249 
    iprot.readMessageEnd()
4250 
    result = getCategory_result()
4251 
    result.success = self._handler.getCategory(args.id)
4252 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4253 
    result.write(oprot)
4254 
    oprot.writeMessageEnd()
4255 
    oprot.trans.flush()
4256 
 
4257 
  def process_getAllCategories(self, seqid, iprot, oprot):
4258 
    args = getAllCategories_args()
4259 
    args.read(iprot)
4260 
    iprot.readMessageEnd()
4261 
    result = getAllCategories_result()
4262 
    result.success = self._handler.getAllCategories()
4263 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4264 
    result.write(oprot)
4265 
    oprot.writeMessageEnd()
4266 
    oprot.trans.flush()
4267 
 
4268 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4269 
    args = getAllSimilarItems_args()
4270 
    args.read(iprot)
4271 
    iprot.readMessageEnd()
4272 
    result = getAllSimilarItems_result()
4273 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4274 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4275 
    result.write(oprot)
4276 
    oprot.writeMessageEnd()
4277 
    oprot.trans.flush()
4278 
 
4279 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4280 
    args = addSimilarItem_args()
4281 
    args.read(iprot)
4282 
    iprot.readMessageEnd()
4283 
    result = addSimilarItem_result()
4284 
    try:
4285 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4286 
    except CatalogServiceException, cex:
4287 
      result.cex = cex
4288 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4289 
    result.write(oprot)
4290 
    oprot.writeMessageEnd()
4291 
    oprot.trans.flush()
4292 
 
6512 kshitij.so 4293 
  def process_addTag(self, seqid, iprot, oprot):
4294 
    args = addTag_args()
4295 
    args.read(iprot)
4296 
    iprot.readMessageEnd()
4297 
    result = addTag_result()
4298 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4299 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
4303 
 
4304 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4305 
    args = deleteEntityTag_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = deleteEntityTag_result()
4309 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4310 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4311 
    result.write(oprot)
4312 
    oprot.writeMessageEnd()
4313 
    oprot.trans.flush()
4314 
 
4315 
  def process_deleteTag(self, seqid, iprot, oprot):
4316 
    args = deleteTag_args()
4317 
    args.read(iprot)
4318 
    iprot.readMessageEnd()
4319 
    result = deleteTag_result()
4320 
    result.success = self._handler.deleteTag(args.displayName)
4321 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4322 
    result.write(oprot)
4323 
    oprot.writeMessageEnd()
4324 
    oprot.trans.flush()
4325 
 
4326 
  def process_getAllTags(self, seqid, iprot, oprot):
4327 
    args = getAllTags_args()
4328 
    args.read(iprot)
4329 
    iprot.readMessageEnd()
4330 
    result = getAllTags_result()
4331 
    result.success = self._handler.getAllTags()
4332 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4333 
    result.write(oprot)
4334 
    oprot.writeMessageEnd()
4335 
    oprot.trans.flush()
4336 
 
4337 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4338 
    args = getAllEntitiesByTagName_args()
4339 
    args.read(iprot)
4340 
    iprot.readMessageEnd()
4341 
    result = getAllEntitiesByTagName_result()
4342 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4343 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4344 
    result.write(oprot)
4345 
    oprot.writeMessageEnd()
4346 
    oprot.trans.flush()
4347 
 
6845 amit.gupta 4348 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4349 
    args = getAllEntityTags_args()
4350 
    args.read(iprot)
4351 
    iprot.readMessageEnd()
4352 
    result = getAllEntityTags_result()
4353 
    result.success = self._handler.getAllEntityTags()
4354 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4355 
    result.write(oprot)
4356 
    oprot.writeMessageEnd()
4357 
    oprot.trans.flush()
4358 
 
6850 kshitij.so 4359 
  def process_addBanner(self, seqid, iprot, oprot):
4360 
    args = addBanner_args()
4361 
    args.read(iprot)
4362 
    iprot.readMessageEnd()
4363 
    result = addBanner_result()
4364 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4365 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4366 
    result.write(oprot)
4367 
    oprot.writeMessageEnd()
4368 
    oprot.trans.flush()
4369 
 
4370 
  def process_getAllBanners(self, seqid, iprot, oprot):
4371 
    args = getAllBanners_args()
4372 
    args.read(iprot)
4373 
    iprot.readMessageEnd()
4374 
    result = getAllBanners_result()
4375 
    result.success = self._handler.getAllBanners()
4376 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4377 
    result.write(oprot)
4378 
    oprot.writeMessageEnd()
4379 
    oprot.trans.flush()
4380 
 
4381 
  def process_deleteBanner(self, seqid, iprot, oprot):
4382 
    args = deleteBanner_args()
4383 
    args.read(iprot)
4384 
    iprot.readMessageEnd()
4385 
    result = deleteBanner_result()
4386 
    result.success = self._handler.deleteBanner(args.bannerName)
4387 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4388 
    result.write(oprot)
4389 
    oprot.writeMessageEnd()
4390 
    oprot.trans.flush()
4391 
 
4392 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4393 
    args = getBannerDetails_args()
4394 
    args.read(iprot)
4395 
    iprot.readMessageEnd()
4396 
    result = getBannerDetails_result()
4397 
    result.success = self._handler.getBannerDetails(args.bannerName)
4398 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4399 
    result.write(oprot)
4400 
    oprot.writeMessageEnd()
4401 
    oprot.trans.flush()
4402 
 
4403 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4404 
    args = getActiveBanners_args()
4405 
    args.read(iprot)
4406 
    iprot.readMessageEnd()
4407 
    result = getActiveBanners_result()
4408 
    result.success = self._handler.getActiveBanners()
4409 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4410 
    result.write(oprot)
4411 
    oprot.writeMessageEnd()
4412 
    oprot.trans.flush()
4413 
 
6849 kshitij.so 4414 
  def process_addBannerMap(self, seqid, iprot, oprot):
4415 
    args = addBannerMap_args()
4416 
    args.read(iprot)
4417 
    iprot.readMessageEnd()
4418 
    result = addBannerMap_result()
4419 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4420 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4421 
    result.write(oprot)
4422 
    oprot.writeMessageEnd()
4423 
    oprot.trans.flush()
4424 
 
4425 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4426 
    args = deleteBannerMap_args()
4427 
    args.read(iprot)
4428 
    iprot.readMessageEnd()
4429 
    result = deleteBannerMap_result()
4430 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4431 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4432 
    result.write(oprot)
4433 
    oprot.writeMessageEnd()
4434 
    oprot.trans.flush()
4435 
 
4436 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4437 
    args = getBannerMapDetails_args()
4438 
    args.read(iprot)
4439 
    iprot.readMessageEnd()
4440 
    result = getBannerMapDetails_result()
4441 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4442 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4443 
    result.write(oprot)
4444 
    oprot.writeMessageEnd()
4445 
    oprot.trans.flush()
4446 
 
5944 mandeep.dh 4447 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4448 
    args = deleteSimilarItem_args()
4449 
    args.read(iprot)
4450 
    iprot.readMessageEnd()
4451 
    result = deleteSimilarItem_result()
4452 
    try:
4453 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4454 
    except CatalogServiceException, cex:
4455 
      result.cex = cex
4456 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4457 
    result.write(oprot)
4458 
    oprot.writeMessageEnd()
4459 
    oprot.trans.flush()
4460 
 
4461 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4462 
    args = checkSimilarItem_args()
4463 
    args.read(iprot)
4464 
    iprot.readMessageEnd()
4465 
    result = checkSimilarItem_result()
4466 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4467 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4468 
    result.write(oprot)
4469 
    oprot.writeMessageEnd()
4470 
    oprot.trans.flush()
4471 
 
4472 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4473 
    args = validateRiskyStatus_args()
4474 
    args.read(iprot)
4475 
    iprot.readMessageEnd()
4476 
    result = validateRiskyStatus_result()
4477 
    self._handler.validateRiskyStatus(args.itemId)
4478 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4479 
    result.write(oprot)
4480 
    oprot.writeMessageEnd()
4481 
    oprot.trans.flush()
4482 
 
4483 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4484 
    args = changeItemRiskyFlag_args()
4485 
    args.read(iprot)
4486 
    iprot.readMessageEnd()
4487 
    result = changeItemRiskyFlag_result()
4488 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4489 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4490 
    result.write(oprot)
4491 
    oprot.writeMessageEnd()
4492 
    oprot.trans.flush()
4493 
 
4494 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4495 
    args = getItemsByRiskyFlag_args()
4496 
    args.read(iprot)
4497 
    iprot.readMessageEnd()
4498 
    result = getItemsByRiskyFlag_result()
4499 
    result.success = self._handler.getItemsByRiskyFlag()
4500 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4501 
    result.write(oprot)
4502 
    oprot.writeMessageEnd()
4503 
    oprot.trans.flush()
4504 
 
4505 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4506 
    args = getItemsForMasterSheet_args()
4507 
    args.read(iprot)
4508 
    iprot.readMessageEnd()
4509 
    result = getItemsForMasterSheet_result()
4510 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4511 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4512 
    result.write(oprot)
4513 
    oprot.writeMessageEnd()
4514 
    oprot.trans.flush()
4515 
 
4516 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4517 
    args = getSimilarItemsCatalogIds_args()
4518 
    args.read(iprot)
4519 
    iprot.readMessageEnd()
4520 
    result = getSimilarItemsCatalogIds_result()
4521 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4522 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4523 
    result.write(oprot)
4524 
    oprot.writeMessageEnd()
4525 
    oprot.trans.flush()
4526 
 
4527 
  def process_addProductNotification(self, seqid, iprot, oprot):
4528 
    args = addProductNotification_args()
4529 
    args.read(iprot)
4530 
    iprot.readMessageEnd()
4531 
    result = addProductNotification_result()
4532 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4533 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4534 
    result.write(oprot)
4535 
    oprot.writeMessageEnd()
4536 
    oprot.trans.flush()
4537 
 
4538 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4539 
    args = sendProductNotifications_args()
4540 
    args.read(iprot)
4541 
    iprot.readMessageEnd()
4542 
    result = sendProductNotifications_result()
4543 
    result.success = self._handler.sendProductNotifications()
4544 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4545 
    result.write(oprot)
4546 
    oprot.writeMessageEnd()
4547 
    oprot.trans.flush()
4548 
 
4549 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4550 
    args = getAllBrandsByCategory_args()
4551 
    args.read(iprot)
4552 
    iprot.readMessageEnd()
4553 
    result = getAllBrandsByCategory_result()
4554 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4555 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4556 
    result.write(oprot)
4557 
    oprot.writeMessageEnd()
4558 
    oprot.trans.flush()
4559 
 
4560 
  def process_getAllBrands(self, seqid, iprot, oprot):
4561 
    args = getAllBrands_args()
4562 
    args.read(iprot)
4563 
    iprot.readMessageEnd()
4564 
    result = getAllBrands_result()
4565 
    result.success = self._handler.getAllBrands()
4566 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4567 
    result.write(oprot)
4568 
    oprot.writeMessageEnd()
4569 
    oprot.trans.flush()
4570 
 
4571 
  def process_getAllSources(self, seqid, iprot, oprot):
4572 
    args = getAllSources_args()
4573 
    args.read(iprot)
4574 
    iprot.readMessageEnd()
4575 
    result = getAllSources_result()
4576 
    result.success = self._handler.getAllSources()
4577 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4578 
    result.write(oprot)
4579 
    oprot.writeMessageEnd()
4580 
    oprot.trans.flush()
4581 
 
4582 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4583 
    args = getItemPricingBySource_args()
4584 
    args.read(iprot)
4585 
    iprot.readMessageEnd()
4586 
    result = getItemPricingBySource_result()
4587 
    try:
4588 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4589 
    except CatalogServiceException, cex:
4590 
      result.cex = cex
4591 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4592 
    result.write(oprot)
4593 
    oprot.writeMessageEnd()
4594 
    oprot.trans.flush()
4595 
 
4596 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4597 
    args = addSourceItemPricing_args()
4598 
    args.read(iprot)
4599 
    iprot.readMessageEnd()
4600 
    result = addSourceItemPricing_result()
4601 
    try:
4602 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4603 
    except CatalogServiceException, cex:
4604 
      result.cex = cex
4605 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4606 
    result.write(oprot)
4607 
    oprot.writeMessageEnd()
4608 
    oprot.trans.flush()
4609 
 
4610 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4611 
    args = getAllSourcePricing_args()
4612 
    args.read(iprot)
4613 
    iprot.readMessageEnd()
4614 
    result = getAllSourcePricing_result()
4615 
    try:
4616 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4617 
    except CatalogServiceException, cex:
4618 
      result.cex = cex
4619 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4620 
    result.write(oprot)
4621 
    oprot.writeMessageEnd()
4622 
    oprot.trans.flush()
4623 
 
4624 
  def process_getItemForSource(self, seqid, iprot, oprot):
4625 
    args = getItemForSource_args()
4626 
    args.read(iprot)
4627 
    iprot.readMessageEnd()
4628 
    result = getItemForSource_result()
4629 
    try:
4630 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4631 
    except CatalogServiceException, cex:
4632 
      result.cex = cex
4633 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4634 
    result.write(oprot)
4635 
    oprot.writeMessageEnd()
4636 
    oprot.trans.flush()
4637 
 
4638 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4639 
    args = searchItemsInRange_args()
4640 
    args.read(iprot)
4641 
    iprot.readMessageEnd()
4642 
    result = searchItemsInRange_result()
4643 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4644 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4645 
    result.write(oprot)
4646 
    oprot.writeMessageEnd()
4647 
    oprot.trans.flush()
4648 
 
4649 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4650 
    args = getSearchResultCount_args()
4651 
    args.read(iprot)
4652 
    iprot.readMessageEnd()
4653 
    result = getSearchResultCount_result()
4654 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4655 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4656 
    result.write(oprot)
4657 
    oprot.writeMessageEnd()
4658 
    oprot.trans.flush()
4659 
 
4660 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4661 
    args = getProductNotifications_args()
4662 
    args.read(iprot)
4663 
    iprot.readMessageEnd()
4664 
    result = getProductNotifications_result()
4665 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4666 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4667 
    result.write(oprot)
4668 
    oprot.writeMessageEnd()
4669 
    oprot.trans.flush()
4670 
 
4671 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4672 
    args = getProductNotificationRequestCount_args()
4673 
    args.read(iprot)
4674 
    iprot.readMessageEnd()
4675 
    result = getProductNotificationRequestCount_result()
4676 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4677 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4678 
    result.write(oprot)
4679 
    oprot.writeMessageEnd()
4680 
    oprot.trans.flush()
4681 
 
4682 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4683 
    args = addAuthorizationLog_args()
4684 
    args.read(iprot)
4685 
    iprot.readMessageEnd()
4686 
    result = addAuthorizationLog_result()
4687 
    try:
4688 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4689 
    except CatalogServiceException, cex:
4690 
      result.cex = cex
4691 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4692 
    result.write(oprot)
4693 
    oprot.writeMessageEnd()
4694 
    oprot.trans.flush()
4695 
 
4696 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4697 
    args = addupdateVoucherForItem_args()
4698 
    args.read(iprot)
4699 
    iprot.readMessageEnd()
4700 
    result = addupdateVoucherForItem_result()
4701 
    try:
4702 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4703 
    except CatalogServiceException, cex:
4704 
      result.cex = cex
4705 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4706 
    result.write(oprot)
4707 
    oprot.writeMessageEnd()
4708 
    oprot.trans.flush()
4709 
 
4710 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4711 
    args = deleteVoucherForItem_args()
4712 
    args.read(iprot)
4713 
    iprot.readMessageEnd()
4714 
    result = deleteVoucherForItem_result()
4715 
    try:
4716 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4717 
    except CatalogServiceException, cex:
4718 
      result.cex = cex
4719 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4720 
    result.write(oprot)
4721 
    oprot.writeMessageEnd()
4722 
    oprot.trans.flush()
4723 
 
4724 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4725 
    args = getVoucherAmount_args()
4726 
    args.read(iprot)
4727 
    iprot.readMessageEnd()
4728 
    result = getVoucherAmount_result()
4729 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4730 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4731 
    result.write(oprot)
4732 
    oprot.writeMessageEnd()
4733 
    oprot.trans.flush()
4734 
 
4735 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4736 
    args = getAllItemVouchers_args()
4737 
    args.read(iprot)
4738 
    iprot.readMessageEnd()
4739 
    result = getAllItemVouchers_result()
4740 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4741 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4742 
    result.write(oprot)
4743 
    oprot.writeMessageEnd()
4744 
    oprot.trans.flush()
4745 
 
4746 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4747 
    args = isValidCatalogItemId_args()
4748 
    args.read(iprot)
4749 
    iprot.readMessageEnd()
4750 
    result = isValidCatalogItemId_result()
4751 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4752 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4753 
    result.write(oprot)
4754 
    oprot.writeMessageEnd()
4755 
    oprot.trans.flush()
4756 
 
6039 amit.gupta 4757 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4758 
    args = getVatPercentageForItem_args()
4759 
    args.read(iprot)
4760 
    iprot.readMessageEnd()
4761 
    result = getVatPercentageForItem_result()
4762 
    result.success = self._handler.getVatPercentageForItem(args.itemId, args.price)
4763 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4764 
    result.write(oprot)
4765 
    oprot.writeMessageEnd()
4766 
    oprot.trans.flush()
5944 mandeep.dh 4767 
 
6039 amit.gupta 4768 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4769 
    args = getVatAmountForItem_args()
4770 
    args.read(iprot)
4771 
    iprot.readMessageEnd()
4772 
    result = getVatAmountForItem_result()
4773 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4774 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4775 
    result.write(oprot)
4776 
    oprot.writeMessageEnd()
4777 
    oprot.trans.flush()
4778 
 
6531 vikram.rag 4779 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4780 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4781 
    args.read(iprot)
4782 
    iprot.readMessageEnd()
4783 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4784 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4785 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4786 
    result.write(oprot)
4787 
    oprot.writeMessageEnd()
4788 
    oprot.trans.flush()
6039 amit.gupta 4789 
 
6821 amar.kumar 4790 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4791 
    args = getAllAliveItems_args()
4792 
    args.read(iprot)
4793 
    iprot.readMessageEnd()
4794 
    result = getAllAliveItems_result()
4795 
    result.success = self._handler.getAllAliveItems()
4796 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4797 
    result.write(oprot)
4798 
    oprot.writeMessageEnd()
4799 
    oprot.trans.flush()
4800 
 
6805 anupam.sin 4801 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4802 
    args = getInsuranceAmount_args()
4803 
    args.read(iprot)
4804 
    iprot.readMessageEnd()
4805 
    result = getInsuranceAmount_result()
6921 anupam.sin 4806 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4807 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4808 
    result.write(oprot)
4809 
    oprot.writeMessageEnd()
4810 
    oprot.trans.flush()
6531 vikram.rag 4811 
 
6805 anupam.sin 4812 
  def process_getInsurer(self, seqid, iprot, oprot):
4813 
    args = getInsurer_args()
4814 
    args.read(iprot)
4815 
    iprot.readMessageEnd()
4816 
    result = getInsurer_result()
4817 
    result.success = self._handler.getInsurer(args.insurerId)
4818 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4819 
    result.write(oprot)
4820 
    oprot.writeMessageEnd()
4821 
    oprot.trans.flush()
4822 
 
6838 vikram.rag 4823 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4824 
    args = getAllInsurers_args()
4825 
    args.read(iprot)
4826 
    iprot.readMessageEnd()
4827 
    result = getAllInsurers_result()
4828 
    result.success = self._handler.getAllInsurers()
4829 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4830 
    result.write(oprot)
4831 
    oprot.writeMessageEnd()
4832 
    oprot.trans.flush()
6805 anupam.sin 4833 
 
6962 rajveer 4834 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4835 
    args = updateInsuranceDeclaredAmount_args()
4836 
    args.read(iprot)
4837 
    iprot.readMessageEnd()
4838 
    result = updateInsuranceDeclaredAmount_result()
4839 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4840 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4841 
    result.write(oprot)
4842 
    oprot.writeMessageEnd()
4843 
    oprot.trans.flush()
6838 vikram.rag 4844 
 
7190 amar.kumar 4845 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4846 
    args = getFreebieForItem_args()
4847 
    args.read(iprot)
4848 
    iprot.readMessageEnd()
4849 
    result = getFreebieForItem_result()
4850 
    result.success = self._handler.getFreebieForItem(args.itemId)
4851 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4852 
    result.write(oprot)
4853 
    oprot.writeMessageEnd()
4854 
    oprot.trans.flush()
6962 rajveer 4855 
 
7190 amar.kumar 4856 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4857 
    args = addOrUpdateFreebieForItem_args()
4858 
    args.read(iprot)
4859 
    iprot.readMessageEnd()
4860 
    result = addOrUpdateFreebieForItem_result()
4861 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4862 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4863 
    result.write(oprot)
4864 
    oprot.writeMessageEnd()
4865 
    oprot.trans.flush()
4866 
 
7272 amit.gupta 4867 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4868 
    args = addOrUpdateBrandInfo_args()
4869 
    args.read(iprot)
4870 
    iprot.readMessageEnd()
4871 
    result = addOrUpdateBrandInfo_result()
4872 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4873 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4874 
    result.write(oprot)
4875 
    oprot.writeMessageEnd()
4876 
    oprot.trans.flush()
4877 
 
4878 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4879 
    args = getBrandInfo_args()
4880 
    args.read(iprot)
4881 
    iprot.readMessageEnd()
4882 
    result = getBrandInfo_result()
4883 
    result.success = self._handler.getBrandInfo()
4884 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4885 
    result.write(oprot)
4886 
    oprot.writeMessageEnd()
4887 
    oprot.trans.flush()
4888 
 
7256 rajveer 4889 
  def process_getStorePricing(self, seqid, iprot, oprot):
4890 
    args = getStorePricing_args()
4891 
    args.read(iprot)
4892 
    iprot.readMessageEnd()
4893 
    result = getStorePricing_result()
4894 
    result.success = self._handler.getStorePricing(args.itemId)
4895 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4896 
    result.write(oprot)
4897 
    oprot.writeMessageEnd()
4898 
    oprot.trans.flush()
7190 amar.kumar 4899 
 
7265 rajveer 4900 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4901 
    args = updateStorePricing_args()
4902 
    args.read(iprot)
4903 
    iprot.readMessageEnd()
4904 
    result = updateStorePricing_result()
4905 
    self._handler.updateStorePricing(args.sp)
4906 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4907 
    result.write(oprot)
4908 
    oprot.writeMessageEnd()
4909 
    oprot.trans.flush()
7256 rajveer 4910 
 
7281 kshitij.so 4911 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4912 
    args = getAllAmazonListedItems_args()
4913 
    args.read(iprot)
4914 
    iprot.readMessageEnd()
4915 
    result = getAllAmazonListedItems_result()
4916 
    result.success = self._handler.getAllAmazonListedItems()
4917 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4918 
    result.write(oprot)
4919 
    oprot.writeMessageEnd()
4920 
    oprot.trans.flush()
7265 rajveer 4921 
 
7281 kshitij.so 4922 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4923 
    args = getAmazonItemDetails_args()
4924 
    args.read(iprot)
4925 
    iprot.readMessageEnd()
4926 
    result = getAmazonItemDetails_result()
4927 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4928 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4929 
    result.write(oprot)
4930 
    oprot.writeMessageEnd()
4931 
    oprot.trans.flush()
4932 
 
4933 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4934 
    args = updateAmazonItemDetails_args()
4935 
    args.read(iprot)
4936 
    iprot.readMessageEnd()
4937 
    result = updateAmazonItemDetails_result()
4938 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride)
4939 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
4940 
    result.write(oprot)
4941 
    oprot.writeMessageEnd()
4942 
    oprot.trans.flush()
4943 
 
4944 
  def process_addAmazonItem(self, seqid, iprot, oprot):
4945 
    args = addAmazonItem_args()
4946 
    args.read(iprot)
4947 
    iprot.readMessageEnd()
4948 
    result = addAmazonItem_result()
4949 
    self._handler.addAmazonItem(args.amazonlisted)
4950 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
4951 
    result.write(oprot)
4952 
    oprot.writeMessageEnd()
4953 
    oprot.trans.flush()
4954 
 
7291 vikram.rag 4955 
  def process_getAsinItems(self, seqid, iprot, oprot):
4956 
    args = getAsinItems_args()
4957 
    args.read(iprot)
4958 
    iprot.readMessageEnd()
4959 
    result = getAsinItems_result()
4960 
    result.success = self._handler.getAsinItems()
4961 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
4962 
    result.write(oprot)
4963 
    oprot.writeMessageEnd()
4964 
    oprot.trans.flush()
7281 kshitij.so 4965 
 
7291 vikram.rag 4966 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
4967 
    args = getAllFbaListedItems_args()
4968 
    args.read(iprot)
4969 
    iprot.readMessageEnd()
4970 
    result = getAllFbaListedItems_result()
4971 
    result.success = self._handler.getAllFbaListedItems()
4972 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
4973 
    result.write(oprot)
4974 
    oprot.writeMessageEnd()
4975 
    oprot.trans.flush()
4976 
 
4977 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
4978 
    args = getAllNonFbaListedItems_args()
4979 
    args.read(iprot)
4980 
    iprot.readMessageEnd()
4981 
    result = getAllNonFbaListedItems_result()
4982 
    result.success = self._handler.getAllNonFbaListedItems()
4983 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
4984 
    result.write(oprot)
4985 
    oprot.writeMessageEnd()
4986 
    oprot.trans.flush()
4987 
 
4988 
 
5944 mandeep.dh 4989 
# HELPER FUNCTIONS AND STRUCTURES
4990 
 
4991 
class addItem_args:
4992 
  """
4993 
  Attributes:
4994 
   - item
4995 
  """
4996 
 
4997 
  thrift_spec = (
4998 
    None, # 0
4999 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5000 
  )
5001 
 
5002 
  def __init__(self, item=None,):
5003 
    self.item = item
5004 
 
5005 
  def read(self, iprot):
5006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5008 
      return
5009 
    iprot.readStructBegin()
5010 
    while True:
5011 
      (fname, ftype, fid) = iprot.readFieldBegin()
5012 
      if ftype == TType.STOP:
5013 
        break
5014 
      if fid == 1:
5015 
        if ftype == TType.STRUCT:
5016 
          self.item = Item()
5017 
          self.item.read(iprot)
5018 
        else:
5019 
          iprot.skip(ftype)
5020 
      else:
5021 
        iprot.skip(ftype)
5022 
      iprot.readFieldEnd()
5023 
    iprot.readStructEnd()
5024 
 
5025 
  def write(self, oprot):
5026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5028 
      return
5029 
    oprot.writeStructBegin('addItem_args')
5030 
    if self.item is not None:
5031 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5032 
      self.item.write(oprot)
5033 
      oprot.writeFieldEnd()
5034 
    oprot.writeFieldStop()
5035 
    oprot.writeStructEnd()
5036 
 
5037 
  def validate(self):
5038 
    return
5039 
 
5040 
 
5041 
  def __repr__(self):
5042 
    L = ['%s=%r' % (key, value)
5043 
      for key, value in self.__dict__.iteritems()]
5044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5045 
 
5046 
  def __eq__(self, other):
5047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5048 
 
5049 
  def __ne__(self, other):
5050 
    return not (self == other)
5051 
 
5052 
class addItem_result:
5053 
  """
5054 
  Attributes:
5055 
   - success
5056 
   - cex
5057 
  """
5058 
 
5059 
  thrift_spec = (
5060 
    (0, TType.I64, 'success', None, None, ), # 0
5061 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5062 
  )
5063 
 
5064 
  def __init__(self, success=None, cex=None,):
5065 
    self.success = success
5066 
    self.cex = cex
5067 
 
5068 
  def read(self, iprot):
5069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5071 
      return
5072 
    iprot.readStructBegin()
5073 
    while True:
5074 
      (fname, ftype, fid) = iprot.readFieldBegin()
5075 
      if ftype == TType.STOP:
5076 
        break
5077 
      if fid == 0:
5078 
        if ftype == TType.I64:
5079 
          self.success = iprot.readI64();
5080 
        else:
5081 
          iprot.skip(ftype)
5082 
      elif fid == 1:
5083 
        if ftype == TType.STRUCT:
5084 
          self.cex = CatalogServiceException()
5085 
          self.cex.read(iprot)
5086 
        else:
5087 
          iprot.skip(ftype)
5088 
      else:
5089 
        iprot.skip(ftype)
5090 
      iprot.readFieldEnd()
5091 
    iprot.readStructEnd()
5092 
 
5093 
  def write(self, oprot):
5094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5096 
      return
5097 
    oprot.writeStructBegin('addItem_result')
5098 
    if self.success is not None:
5099 
      oprot.writeFieldBegin('success', TType.I64, 0)
5100 
      oprot.writeI64(self.success)
5101 
      oprot.writeFieldEnd()
5102 
    if self.cex is not None:
5103 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5104 
      self.cex.write(oprot)
5105 
      oprot.writeFieldEnd()
5106 
    oprot.writeFieldStop()
5107 
    oprot.writeStructEnd()
5108 
 
5109 
  def validate(self):
5110 
    return
5111 
 
5112 
 
5113 
  def __repr__(self):
5114 
    L = ['%s=%r' % (key, value)
5115 
      for key, value in self.__dict__.iteritems()]
5116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5117 
 
5118 
  def __eq__(self, other):
5119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5120 
 
5121 
  def __ne__(self, other):
5122 
    return not (self == other)
5123 
 
5124 
class updateItem_args:
5125 
  """
5126 
  Attributes:
5127 
   - item
5128 
  """
5129 
 
5130 
  thrift_spec = (
5131 
    None, # 0
5132 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5133 
  )
5134 
 
5135 
  def __init__(self, item=None,):
5136 
    self.item = item
5137 
 
5138 
  def read(self, iprot):
5139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5141 
      return
5142 
    iprot.readStructBegin()
5143 
    while True:
5144 
      (fname, ftype, fid) = iprot.readFieldBegin()
5145 
      if ftype == TType.STOP:
5146 
        break
5147 
      if fid == 1:
5148 
        if ftype == TType.STRUCT:
5149 
          self.item = Item()
5150 
          self.item.read(iprot)
5151 
        else:
5152 
          iprot.skip(ftype)
5153 
      else:
5154 
        iprot.skip(ftype)
5155 
      iprot.readFieldEnd()
5156 
    iprot.readStructEnd()
5157 
 
5158 
  def write(self, oprot):
5159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5161 
      return
5162 
    oprot.writeStructBegin('updateItem_args')
5163 
    if self.item is not None:
5164 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5165 
      self.item.write(oprot)
5166 
      oprot.writeFieldEnd()
5167 
    oprot.writeFieldStop()
5168 
    oprot.writeStructEnd()
5169 
 
5170 
  def validate(self):
5171 
    return
5172 
 
5173 
 
5174 
  def __repr__(self):
5175 
    L = ['%s=%r' % (key, value)
5176 
      for key, value in self.__dict__.iteritems()]
5177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5178 
 
5179 
  def __eq__(self, other):
5180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5181 
 
5182 
  def __ne__(self, other):
5183 
    return not (self == other)
5184 
 
5185 
class updateItem_result:
5186 
  """
5187 
  Attributes:
5188 
   - success
5189 
   - cex
5190 
  """
5191 
 
5192 
  thrift_spec = (
5193 
    (0, TType.I64, 'success', None, None, ), # 0
5194 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5195 
  )
5196 
 
5197 
  def __init__(self, success=None, cex=None,):
5198 
    self.success = success
5199 
    self.cex = cex
5200 
 
5201 
  def read(self, iprot):
5202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5204 
      return
5205 
    iprot.readStructBegin()
5206 
    while True:
5207 
      (fname, ftype, fid) = iprot.readFieldBegin()
5208 
      if ftype == TType.STOP:
5209 
        break
5210 
      if fid == 0:
5211 
        if ftype == TType.I64:
5212 
          self.success = iprot.readI64();
5213 
        else:
5214 
          iprot.skip(ftype)
5215 
      elif fid == 1:
5216 
        if ftype == TType.STRUCT:
5217 
          self.cex = CatalogServiceException()
5218 
          self.cex.read(iprot)
5219 
        else:
5220 
          iprot.skip(ftype)
5221 
      else:
5222 
        iprot.skip(ftype)
5223 
      iprot.readFieldEnd()
5224 
    iprot.readStructEnd()
5225 
 
5226 
  def write(self, oprot):
5227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5229 
      return
5230 
    oprot.writeStructBegin('updateItem_result')
5231 
    if self.success is not None:
5232 
      oprot.writeFieldBegin('success', TType.I64, 0)
5233 
      oprot.writeI64(self.success)
5234 
      oprot.writeFieldEnd()
5235 
    if self.cex is not None:
5236 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5237 
      self.cex.write(oprot)
5238 
      oprot.writeFieldEnd()
5239 
    oprot.writeFieldStop()
5240 
    oprot.writeStructEnd()
5241 
 
5242 
  def validate(self):
5243 
    return
5244 
 
5245 
 
5246 
  def __repr__(self):
5247 
    L = ['%s=%r' % (key, value)
5248 
      for key, value in self.__dict__.iteritems()]
5249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5250 
 
5251 
  def __eq__(self, other):
5252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5253 
 
5254 
  def __ne__(self, other):
5255 
    return not (self == other)
5256 
 
5257 
class isActive_args:
5258 
  """
5259 
  Attributes:
5260 
   - itemId
5261 
  """
5262 
 
5263 
  thrift_spec = (
5264 
    None, # 0
5265 
    (1, TType.I64, 'itemId', None, None, ), # 1
5266 
  )
5267 
 
5268 
  def __init__(self, itemId=None,):
5269 
    self.itemId = itemId
5270 
 
5271 
  def read(self, iprot):
5272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5274 
      return
5275 
    iprot.readStructBegin()
5276 
    while True:
5277 
      (fname, ftype, fid) = iprot.readFieldBegin()
5278 
      if ftype == TType.STOP:
5279 
        break
5280 
      if fid == 1:
5281 
        if ftype == TType.I64:
5282 
          self.itemId = iprot.readI64();
5283 
        else:
5284 
          iprot.skip(ftype)
5285 
      else:
5286 
        iprot.skip(ftype)
5287 
      iprot.readFieldEnd()
5288 
    iprot.readStructEnd()
5289 
 
5290 
  def write(self, oprot):
5291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5293 
      return
5294 
    oprot.writeStructBegin('isActive_args')
5295 
    if self.itemId is not None:
5296 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5297 
      oprot.writeI64(self.itemId)
5298 
      oprot.writeFieldEnd()
5299 
    oprot.writeFieldStop()
5300 
    oprot.writeStructEnd()
5301 
 
5302 
  def validate(self):
5303 
    return
5304 
 
5305 
 
5306 
  def __repr__(self):
5307 
    L = ['%s=%r' % (key, value)
5308 
      for key, value in self.__dict__.iteritems()]
5309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5310 
 
5311 
  def __eq__(self, other):
5312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5313 
 
5314 
  def __ne__(self, other):
5315 
    return not (self == other)
5316 
 
5317 
class isActive_result:
5318 
  """
5319 
  Attributes:
5320 
   - success
5321 
   - isex
5322 
  """
5323 
 
5324 
  thrift_spec = (
5325 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5326 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5327 
  )
5328 
 
5329 
  def __init__(self, success=None, isex=None,):
5330 
    self.success = success
5331 
    self.isex = isex
5332 
 
5333 
  def read(self, iprot):
5334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5336 
      return
5337 
    iprot.readStructBegin()
5338 
    while True:
5339 
      (fname, ftype, fid) = iprot.readFieldBegin()
5340 
      if ftype == TType.STOP:
5341 
        break
5342 
      if fid == 0:
5343 
        if ftype == TType.STRUCT:
5344 
          self.success = ItemShippingInfo()
5345 
          self.success.read(iprot)
5346 
        else:
5347 
          iprot.skip(ftype)
5348 
      elif fid == 1:
5349 
        if ftype == TType.STRUCT:
5350 
          self.isex = CatalogServiceException()
5351 
          self.isex.read(iprot)
5352 
        else:
5353 
          iprot.skip(ftype)
5354 
      else:
5355 
        iprot.skip(ftype)
5356 
      iprot.readFieldEnd()
5357 
    iprot.readStructEnd()
5358 
 
5359 
  def write(self, oprot):
5360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5362 
      return
5363 
    oprot.writeStructBegin('isActive_result')
5364 
    if self.success is not None:
5365 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5366 
      self.success.write(oprot)
5367 
      oprot.writeFieldEnd()
5368 
    if self.isex is not None:
5369 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5370 
      self.isex.write(oprot)
5371 
      oprot.writeFieldEnd()
5372 
    oprot.writeFieldStop()
5373 
    oprot.writeStructEnd()
5374 
 
5375 
  def validate(self):
5376 
    return
5377 
 
5378 
 
5379 
  def __repr__(self):
5380 
    L = ['%s=%r' % (key, value)
5381 
      for key, value in self.__dict__.iteritems()]
5382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5383 
 
5384 
  def __eq__(self, other):
5385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5386 
 
5387 
  def __ne__(self, other):
5388 
    return not (self == other)
5389 
 
5390 
class getItemStatusDescription_args:
5391 
  """
5392 
  Attributes:
5393 
   - itemId
5394 
  """
5395 
 
5396 
  thrift_spec = (
5397 
    None, # 0
5398 
    (1, TType.I64, 'itemId', None, None, ), # 1
5399 
  )
5400 
 
5401 
  def __init__(self, itemId=None,):
5402 
    self.itemId = itemId
5403 
 
5404 
  def read(self, iprot):
5405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5407 
      return
5408 
    iprot.readStructBegin()
5409 
    while True:
5410 
      (fname, ftype, fid) = iprot.readFieldBegin()
5411 
      if ftype == TType.STOP:
5412 
        break
5413 
      if fid == 1:
5414 
        if ftype == TType.I64:
5415 
          self.itemId = iprot.readI64();
5416 
        else:
5417 
          iprot.skip(ftype)
5418 
      else:
5419 
        iprot.skip(ftype)
5420 
      iprot.readFieldEnd()
5421 
    iprot.readStructEnd()
5422 
 
5423 
  def write(self, oprot):
5424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5426 
      return
5427 
    oprot.writeStructBegin('getItemStatusDescription_args')
5428 
    if self.itemId is not None:
5429 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5430 
      oprot.writeI64(self.itemId)
5431 
      oprot.writeFieldEnd()
5432 
    oprot.writeFieldStop()
5433 
    oprot.writeStructEnd()
5434 
 
5435 
  def validate(self):
5436 
    return
5437 
 
5438 
 
5439 
  def __repr__(self):
5440 
    L = ['%s=%r' % (key, value)
5441 
      for key, value in self.__dict__.iteritems()]
5442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5443 
 
5444 
  def __eq__(self, other):
5445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5446 
 
5447 
  def __ne__(self, other):
5448 
    return not (self == other)
5449 
 
5450 
class getItemStatusDescription_result:
5451 
  """
5452 
  Attributes:
5453 
   - success
5454 
   - isex
5455 
  """
5456 
 
5457 
  thrift_spec = (
5458 
    (0, TType.STRING, 'success', None, None, ), # 0
5459 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5460 
  )
5461 
 
5462 
  def __init__(self, success=None, isex=None,):
5463 
    self.success = success
5464 
    self.isex = isex
5465 
 
5466 
  def read(self, iprot):
5467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5469 
      return
5470 
    iprot.readStructBegin()
5471 
    while True:
5472 
      (fname, ftype, fid) = iprot.readFieldBegin()
5473 
      if ftype == TType.STOP:
5474 
        break
5475 
      if fid == 0:
5476 
        if ftype == TType.STRING:
5477 
          self.success = iprot.readString();
5478 
        else:
5479 
          iprot.skip(ftype)
5480 
      elif fid == 1:
5481 
        if ftype == TType.STRUCT:
5482 
          self.isex = CatalogServiceException()
5483 
          self.isex.read(iprot)
5484 
        else:
5485 
          iprot.skip(ftype)
5486 
      else:
5487 
        iprot.skip(ftype)
5488 
      iprot.readFieldEnd()
5489 
    iprot.readStructEnd()
5490 
 
5491 
  def write(self, oprot):
5492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5494 
      return
5495 
    oprot.writeStructBegin('getItemStatusDescription_result')
5496 
    if self.success is not None:
5497 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5498 
      oprot.writeString(self.success)
5499 
      oprot.writeFieldEnd()
5500 
    if self.isex is not None:
5501 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5502 
      self.isex.write(oprot)
5503 
      oprot.writeFieldEnd()
5504 
    oprot.writeFieldStop()
5505 
    oprot.writeStructEnd()
5506 
 
5507 
  def validate(self):
5508 
    return
5509 
 
5510 
 
5511 
  def __repr__(self):
5512 
    L = ['%s=%r' % (key, value)
5513 
      for key, value in self.__dict__.iteritems()]
5514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5515 
 
5516 
  def __eq__(self, other):
5517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5518 
 
5519 
  def __ne__(self, other):
5520 
    return not (self == other)
5521 
 
5522 
class startItemOn_args:
5523 
  """
5524 
  Attributes:
5525 
   - item_id
5526 
   - timestamp
5527 
  """
5528 
 
5529 
  thrift_spec = (
5530 
    None, # 0
5531 
    (1, TType.I64, 'item_id', None, None, ), # 1
5532 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5533 
  )
5534 
 
5535 
  def __init__(self, item_id=None, timestamp=None,):
5536 
    self.item_id = item_id
5537 
    self.timestamp = timestamp
5538 
 
5539 
  def read(self, iprot):
5540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5542 
      return
5543 
    iprot.readStructBegin()
5544 
    while True:
5545 
      (fname, ftype, fid) = iprot.readFieldBegin()
5546 
      if ftype == TType.STOP:
5547 
        break
5548 
      if fid == 1:
5549 
        if ftype == TType.I64:
5550 
          self.item_id = iprot.readI64();
5551 
        else:
5552 
          iprot.skip(ftype)
5553 
      elif fid == 2:
5554 
        if ftype == TType.I64:
5555 
          self.timestamp = iprot.readI64();
5556 
        else:
5557 
          iprot.skip(ftype)
5558 
      else:
5559 
        iprot.skip(ftype)
5560 
      iprot.readFieldEnd()
5561 
    iprot.readStructEnd()
5562 
 
5563 
  def write(self, oprot):
5564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5566 
      return
5567 
    oprot.writeStructBegin('startItemOn_args')
5568 
    if self.item_id is not None:
5569 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5570 
      oprot.writeI64(self.item_id)
5571 
      oprot.writeFieldEnd()
5572 
    if self.timestamp is not None:
5573 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5574 
      oprot.writeI64(self.timestamp)
5575 
      oprot.writeFieldEnd()
5576 
    oprot.writeFieldStop()
5577 
    oprot.writeStructEnd()
5578 
 
5579 
  def validate(self):
5580 
    return
5581 
 
5582 
 
5583 
  def __repr__(self):
5584 
    L = ['%s=%r' % (key, value)
5585 
      for key, value in self.__dict__.iteritems()]
5586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5587 
 
5588 
  def __eq__(self, other):
5589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5590 
 
5591 
  def __ne__(self, other):
5592 
    return not (self == other)
5593 
 
5594 
class startItemOn_result:
5595 
  """
5596 
  Attributes:
5597 
   - cex
5598 
  """
5599 
 
5600 
  thrift_spec = (
5601 
    None, # 0
5602 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5603 
  )
5604 
 
5605 
  def __init__(self, cex=None,):
5606 
    self.cex = cex
5607 
 
5608 
  def read(self, iprot):
5609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5611 
      return
5612 
    iprot.readStructBegin()
5613 
    while True:
5614 
      (fname, ftype, fid) = iprot.readFieldBegin()
5615 
      if ftype == TType.STOP:
5616 
        break
5617 
      if fid == 1:
5618 
        if ftype == TType.STRUCT:
5619 
          self.cex = CatalogServiceException()
5620 
          self.cex.read(iprot)
5621 
        else:
5622 
          iprot.skip(ftype)
5623 
      else:
5624 
        iprot.skip(ftype)
5625 
      iprot.readFieldEnd()
5626 
    iprot.readStructEnd()
5627 
 
5628 
  def write(self, oprot):
5629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5631 
      return
5632 
    oprot.writeStructBegin('startItemOn_result')
5633 
    if self.cex is not None:
5634 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5635 
      self.cex.write(oprot)
5636 
      oprot.writeFieldEnd()
5637 
    oprot.writeFieldStop()
5638 
    oprot.writeStructEnd()
5639 
 
5640 
  def validate(self):
5641 
    return
5642 
 
5643 
 
5644 
  def __repr__(self):
5645 
    L = ['%s=%r' % (key, value)
5646 
      for key, value in self.__dict__.iteritems()]
5647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5648 
 
5649 
  def __eq__(self, other):
5650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5651 
 
5652 
  def __ne__(self, other):
5653 
    return not (self == other)
5654 
 
5655 
class retireItemOn_args:
5656 
  """
5657 
  Attributes:
5658 
   - item_id
5659 
   - timestamp
5660 
  """
5661 
 
5662 
  thrift_spec = (
5663 
    None, # 0
5664 
    (1, TType.I64, 'item_id', None, None, ), # 1
5665 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5666 
  )
5667 
 
5668 
  def __init__(self, item_id=None, timestamp=None,):
5669 
    self.item_id = item_id
5670 
    self.timestamp = timestamp
5671 
 
5672 
  def read(self, iprot):
5673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5675 
      return
5676 
    iprot.readStructBegin()
5677 
    while True:
5678 
      (fname, ftype, fid) = iprot.readFieldBegin()
5679 
      if ftype == TType.STOP:
5680 
        break
5681 
      if fid == 1:
5682 
        if ftype == TType.I64:
5683 
          self.item_id = iprot.readI64();
5684 
        else:
5685 
          iprot.skip(ftype)
5686 
      elif fid == 2:
5687 
        if ftype == TType.I64:
5688 
          self.timestamp = iprot.readI64();
5689 
        else:
5690 
          iprot.skip(ftype)
5691 
      else:
5692 
        iprot.skip(ftype)
5693 
      iprot.readFieldEnd()
5694 
    iprot.readStructEnd()
5695 
 
5696 
  def write(self, oprot):
5697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5699 
      return
5700 
    oprot.writeStructBegin('retireItemOn_args')
5701 
    if self.item_id is not None:
5702 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5703 
      oprot.writeI64(self.item_id)
5704 
      oprot.writeFieldEnd()
5705 
    if self.timestamp is not None:
5706 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5707 
      oprot.writeI64(self.timestamp)
5708 
      oprot.writeFieldEnd()
5709 
    oprot.writeFieldStop()
5710 
    oprot.writeStructEnd()
5711 
 
5712 
  def validate(self):
5713 
    return
5714 
 
5715 
 
5716 
  def __repr__(self):
5717 
    L = ['%s=%r' % (key, value)
5718 
      for key, value in self.__dict__.iteritems()]
5719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5720 
 
5721 
  def __eq__(self, other):
5722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5723 
 
5724 
  def __ne__(self, other):
5725 
    return not (self == other)
5726 
 
5727 
class retireItemOn_result:
5728 
  """
5729 
  Attributes:
5730 
   - cex
5731 
  """
5732 
 
5733 
  thrift_spec = (
5734 
    None, # 0
5735 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5736 
  )
5737 
 
5738 
  def __init__(self, cex=None,):
5739 
    self.cex = cex
5740 
 
5741 
  def read(self, iprot):
5742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5744 
      return
5745 
    iprot.readStructBegin()
5746 
    while True:
5747 
      (fname, ftype, fid) = iprot.readFieldBegin()
5748 
      if ftype == TType.STOP:
5749 
        break
5750 
      if fid == 1:
5751 
        if ftype == TType.STRUCT:
5752 
          self.cex = CatalogServiceException()
5753 
          self.cex.read(iprot)
5754 
        else:
5755 
          iprot.skip(ftype)
5756 
      else:
5757 
        iprot.skip(ftype)
5758 
      iprot.readFieldEnd()
5759 
    iprot.readStructEnd()
5760 
 
5761 
  def write(self, oprot):
5762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5764 
      return
5765 
    oprot.writeStructBegin('retireItemOn_result')
5766 
    if self.cex is not None:
5767 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5768 
      self.cex.write(oprot)
5769 
      oprot.writeFieldEnd()
5770 
    oprot.writeFieldStop()
5771 
    oprot.writeStructEnd()
5772 
 
5773 
  def validate(self):
5774 
    return
5775 
 
5776 
 
5777 
  def __repr__(self):
5778 
    L = ['%s=%r' % (key, value)
5779 
      for key, value in self.__dict__.iteritems()]
5780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5781 
 
5782 
  def __eq__(self, other):
5783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5784 
 
5785 
  def __ne__(self, other):
5786 
    return not (self == other)
5787 
 
5788 
class changeItemStatus_args:
5789 
  """
5790 
  Attributes:
5791 
   - item_id
5792 
   - timestamp
5793 
   - newstatus
5794 
  """
5795 
 
5796 
  thrift_spec = (
5797 
    None, # 0
5798 
    (1, TType.I64, 'item_id', None, None, ), # 1
5799 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5800 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5801 
  )
5802 
 
5803 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5804 
    self.item_id = item_id
5805 
    self.timestamp = timestamp
5806 
    self.newstatus = newstatus
5807 
 
5808 
  def read(self, iprot):
5809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5811 
      return
5812 
    iprot.readStructBegin()
5813 
    while True:
5814 
      (fname, ftype, fid) = iprot.readFieldBegin()
5815 
      if ftype == TType.STOP:
5816 
        break
5817 
      if fid == 1:
5818 
        if ftype == TType.I64:
5819 
          self.item_id = iprot.readI64();
5820 
        else:
5821 
          iprot.skip(ftype)
5822 
      elif fid == 2:
5823 
        if ftype == TType.I64:
5824 
          self.timestamp = iprot.readI64();
5825 
        else:
5826 
          iprot.skip(ftype)
5827 
      elif fid == 3:
5828 
        if ftype == TType.I32:
5829 
          self.newstatus = iprot.readI32();
5830 
        else:
5831 
          iprot.skip(ftype)
5832 
      else:
5833 
        iprot.skip(ftype)
5834 
      iprot.readFieldEnd()
5835 
    iprot.readStructEnd()
5836 
 
5837 
  def write(self, oprot):
5838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5840 
      return
5841 
    oprot.writeStructBegin('changeItemStatus_args')
5842 
    if self.item_id is not None:
5843 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5844 
      oprot.writeI64(self.item_id)
5845 
      oprot.writeFieldEnd()
5846 
    if self.timestamp is not None:
5847 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5848 
      oprot.writeI64(self.timestamp)
5849 
      oprot.writeFieldEnd()
5850 
    if self.newstatus is not None:
5851 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5852 
      oprot.writeI32(self.newstatus)
5853 
      oprot.writeFieldEnd()
5854 
    oprot.writeFieldStop()
5855 
    oprot.writeStructEnd()
5856 
 
5857 
  def validate(self):
5858 
    return
5859 
 
5860 
 
5861 
  def __repr__(self):
5862 
    L = ['%s=%r' % (key, value)
5863 
      for key, value in self.__dict__.iteritems()]
5864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5865 
 
5866 
  def __eq__(self, other):
5867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5868 
 
5869 
  def __ne__(self, other):
5870 
    return not (self == other)
5871 
 
5872 
class changeItemStatus_result:
5873 
  """
5874 
  Attributes:
5875 
   - cex
5876 
  """
5877 
 
5878 
  thrift_spec = (
5879 
    None, # 0
5880 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5881 
  )
5882 
 
5883 
  def __init__(self, cex=None,):
5884 
    self.cex = cex
5885 
 
5886 
  def read(self, iprot):
5887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5889 
      return
5890 
    iprot.readStructBegin()
5891 
    while True:
5892 
      (fname, ftype, fid) = iprot.readFieldBegin()
5893 
      if ftype == TType.STOP:
5894 
        break
5895 
      if fid == 1:
5896 
        if ftype == TType.STRUCT:
5897 
          self.cex = CatalogServiceException()
5898 
          self.cex.read(iprot)
5899 
        else:
5900 
          iprot.skip(ftype)
5901 
      else:
5902 
        iprot.skip(ftype)
5903 
      iprot.readFieldEnd()
5904 
    iprot.readStructEnd()
5905 
 
5906 
  def write(self, oprot):
5907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5909 
      return
5910 
    oprot.writeStructBegin('changeItemStatus_result')
5911 
    if self.cex is not None:
5912 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5913 
      self.cex.write(oprot)
5914 
      oprot.writeFieldEnd()
5915 
    oprot.writeFieldStop()
5916 
    oprot.writeStructEnd()
5917 
 
5918 
  def validate(self):
5919 
    return
5920 
 
5921 
 
5922 
  def __repr__(self):
5923 
    L = ['%s=%r' % (key, value)
5924 
      for key, value in self.__dict__.iteritems()]
5925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5926 
 
5927 
  def __eq__(self, other):
5928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5929 
 
5930 
  def __ne__(self, other):
5931 
    return not (self == other)
5932 
 
5933 
class getItem_args:
5934 
  """
5935 
  Attributes:
5936 
   - item_id
5937 
  """
5938 
 
5939 
  thrift_spec = (
5940 
    None, # 0
5941 
    (1, TType.I64, 'item_id', None, None, ), # 1
5942 
  )
5943 
 
5944 
  def __init__(self, item_id=None,):
5945 
    self.item_id = item_id
5946 
 
5947 
  def read(self, iprot):
5948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5950 
      return
5951 
    iprot.readStructBegin()
5952 
    while True:
5953 
      (fname, ftype, fid) = iprot.readFieldBegin()
5954 
      if ftype == TType.STOP:
5955 
        break
5956 
      if fid == 1:
5957 
        if ftype == TType.I64:
5958 
          self.item_id = iprot.readI64();
5959 
        else:
5960 
          iprot.skip(ftype)
5961 
      else:
5962 
        iprot.skip(ftype)
5963 
      iprot.readFieldEnd()
5964 
    iprot.readStructEnd()
5965 
 
5966 
  def write(self, oprot):
5967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5969 
      return
5970 
    oprot.writeStructBegin('getItem_args')
5971 
    if self.item_id is not None:
5972 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5973 
      oprot.writeI64(self.item_id)
5974 
      oprot.writeFieldEnd()
5975 
    oprot.writeFieldStop()
5976 
    oprot.writeStructEnd()
5977 
 
5978 
  def validate(self):
5979 
    return
5980 
 
5981 
 
5982 
  def __repr__(self):
5983 
    L = ['%s=%r' % (key, value)
5984 
      for key, value in self.__dict__.iteritems()]
5985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5986 
 
5987 
  def __eq__(self, other):
5988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5989 
 
5990 
  def __ne__(self, other):
5991 
    return not (self == other)
5992 
 
5993 
class getItem_result:
5994 
  """
5995 
  Attributes:
5996 
   - success
5997 
   - cex
5998 
  """
5999 
 
6000 
  thrift_spec = (
6001 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6002 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6003 
  )
6004 
 
6005 
  def __init__(self, success=None, cex=None,):
6006 
    self.success = success
6007 
    self.cex = cex
6008 
 
6009 
  def read(self, iprot):
6010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6012 
      return
6013 
    iprot.readStructBegin()
6014 
    while True:
6015 
      (fname, ftype, fid) = iprot.readFieldBegin()
6016 
      if ftype == TType.STOP:
6017 
        break
6018 
      if fid == 0:
6019 
        if ftype == TType.STRUCT:
6020 
          self.success = Item()
6021 
          self.success.read(iprot)
6022 
        else:
6023 
          iprot.skip(ftype)
6024 
      elif fid == 1:
6025 
        if ftype == TType.STRUCT:
6026 
          self.cex = CatalogServiceException()
6027 
          self.cex.read(iprot)
6028 
        else:
6029 
          iprot.skip(ftype)
6030 
      else:
6031 
        iprot.skip(ftype)
6032 
      iprot.readFieldEnd()
6033 
    iprot.readStructEnd()
6034 
 
6035 
  def write(self, oprot):
6036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6038 
      return
6039 
    oprot.writeStructBegin('getItem_result')
6040 
    if self.success is not None:
6041 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6042 
      self.success.write(oprot)
6043 
      oprot.writeFieldEnd()
6044 
    if self.cex is not None:
6045 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6046 
      self.cex.write(oprot)
6047 
      oprot.writeFieldEnd()
6048 
    oprot.writeFieldStop()
6049 
    oprot.writeStructEnd()
6050 
 
6051 
  def validate(self):
6052 
    return
6053 
 
6054 
 
6055 
  def __repr__(self):
6056 
    L = ['%s=%r' % (key, value)
6057 
      for key, value in self.__dict__.iteritems()]
6058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6059 
 
6060 
  def __eq__(self, other):
6061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6062 
 
6063 
  def __ne__(self, other):
6064 
    return not (self == other)
6065 
 
6066 
class getItemsByCatalogId_args:
6067 
  """
6068 
  Attributes:
6069 
   - catalog_item_id
6070 
  """
6071 
 
6072 
  thrift_spec = (
6073 
    None, # 0
6074 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6075 
  )
6076 
 
6077 
  def __init__(self, catalog_item_id=None,):
6078 
    self.catalog_item_id = catalog_item_id
6079 
 
6080 
  def read(self, iprot):
6081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6083 
      return
6084 
    iprot.readStructBegin()
6085 
    while True:
6086 
      (fname, ftype, fid) = iprot.readFieldBegin()
6087 
      if ftype == TType.STOP:
6088 
        break
6089 
      if fid == 1:
6090 
        if ftype == TType.I64:
6091 
          self.catalog_item_id = iprot.readI64();
6092 
        else:
6093 
          iprot.skip(ftype)
6094 
      else:
6095 
        iprot.skip(ftype)
6096 
      iprot.readFieldEnd()
6097 
    iprot.readStructEnd()
6098 
 
6099 
  def write(self, oprot):
6100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6102 
      return
6103 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6104 
    if self.catalog_item_id is not None:
6105 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6106 
      oprot.writeI64(self.catalog_item_id)
6107 
      oprot.writeFieldEnd()
6108 
    oprot.writeFieldStop()
6109 
    oprot.writeStructEnd()
6110 
 
6111 
  def validate(self):
6112 
    return
6113 
 
6114 
 
6115 
  def __repr__(self):
6116 
    L = ['%s=%r' % (key, value)
6117 
      for key, value in self.__dict__.iteritems()]
6118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6119 
 
6120 
  def __eq__(self, other):
6121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6122 
 
6123 
  def __ne__(self, other):
6124 
    return not (self == other)
6125 
 
6126 
class getItemsByCatalogId_result:
6127 
  """
6128 
  Attributes:
6129 
   - success
6130 
   - cex
6131 
  """
6132 
 
6133 
  thrift_spec = (
6134 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6135 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6136 
  )
6137 
 
6138 
  def __init__(self, success=None, cex=None,):
6139 
    self.success = success
6140 
    self.cex = cex
6141 
 
6142 
  def read(self, iprot):
6143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6145 
      return
6146 
    iprot.readStructBegin()
6147 
    while True:
6148 
      (fname, ftype, fid) = iprot.readFieldBegin()
6149 
      if ftype == TType.STOP:
6150 
        break
6151 
      if fid == 0:
6152 
        if ftype == TType.LIST:
6153 
          self.success = []
6154 
          (_etype19, _size16) = iprot.readListBegin()
6155 
          for _i20 in xrange(_size16):
6156 
            _elem21 = Item()
6157 
            _elem21.read(iprot)
6158 
            self.success.append(_elem21)
6159 
          iprot.readListEnd()
6160 
        else:
6161 
          iprot.skip(ftype)
6162 
      elif fid == 1:
6163 
        if ftype == TType.STRUCT:
6164 
          self.cex = CatalogServiceException()
6165 
          self.cex.read(iprot)
6166 
        else:
6167 
          iprot.skip(ftype)
6168 
      else:
6169 
        iprot.skip(ftype)
6170 
      iprot.readFieldEnd()
6171 
    iprot.readStructEnd()
6172 
 
6173 
  def write(self, oprot):
6174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6176 
      return
6177 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6178 
    if self.success is not None:
6179 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6180 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6181 
      for iter22 in self.success:
6182 
        iter22.write(oprot)
6183 
      oprot.writeListEnd()
6184 
      oprot.writeFieldEnd()
6185 
    if self.cex is not None:
6186 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6187 
      self.cex.write(oprot)
6188 
      oprot.writeFieldEnd()
6189 
    oprot.writeFieldStop()
6190 
    oprot.writeStructEnd()
6191 
 
6192 
  def validate(self):
6193 
    return
6194 
 
6195 
 
6196 
  def __repr__(self):
6197 
    L = ['%s=%r' % (key, value)
6198 
      for key, value in self.__dict__.iteritems()]
6199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6200 
 
6201 
  def __eq__(self, other):
6202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6203 
 
6204 
  def __ne__(self, other):
6205 
    return not (self == other)
6206 
 
6207 
class getValidItemsByCatalogId_args:
6208 
  """
6209 
  Attributes:
6210 
   - catalog_item_id
6211 
  """
6212 
 
6213 
  thrift_spec = (
6214 
    None, # 0
6215 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6216 
  )
6217 
 
6218 
  def __init__(self, catalog_item_id=None,):
6219 
    self.catalog_item_id = catalog_item_id
6220 
 
6221 
  def read(self, iprot):
6222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6224 
      return
6225 
    iprot.readStructBegin()
6226 
    while True:
6227 
      (fname, ftype, fid) = iprot.readFieldBegin()
6228 
      if ftype == TType.STOP:
6229 
        break
6230 
      if fid == 1:
6231 
        if ftype == TType.I64:
6232 
          self.catalog_item_id = iprot.readI64();
6233 
        else:
6234 
          iprot.skip(ftype)
6235 
      else:
6236 
        iprot.skip(ftype)
6237 
      iprot.readFieldEnd()
6238 
    iprot.readStructEnd()
6239 
 
6240 
  def write(self, oprot):
6241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6243 
      return
6244 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6245 
    if self.catalog_item_id is not None:
6246 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6247 
      oprot.writeI64(self.catalog_item_id)
6248 
      oprot.writeFieldEnd()
6249 
    oprot.writeFieldStop()
6250 
    oprot.writeStructEnd()
6251 
 
6252 
  def validate(self):
6253 
    return
6254 
 
6255 
 
6256 
  def __repr__(self):
6257 
    L = ['%s=%r' % (key, value)
6258 
      for key, value in self.__dict__.iteritems()]
6259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6260 
 
6261 
  def __eq__(self, other):
6262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6263 
 
6264 
  def __ne__(self, other):
6265 
    return not (self == other)
6266 
 
6267 
class getValidItemsByCatalogId_result:
6268 
  """
6269 
  Attributes:
6270 
   - success
6271 
   - cex
6272 
  """
6273 
 
6274 
  thrift_spec = (
6275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6276 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6277 
  )
6278 
 
6279 
  def __init__(self, success=None, cex=None,):
6280 
    self.success = success
6281 
    self.cex = cex
6282 
 
6283 
  def read(self, iprot):
6284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6286 
      return
6287 
    iprot.readStructBegin()
6288 
    while True:
6289 
      (fname, ftype, fid) = iprot.readFieldBegin()
6290 
      if ftype == TType.STOP:
6291 
        break
6292 
      if fid == 0:
6293 
        if ftype == TType.LIST:
6294 
          self.success = []
6295 
          (_etype26, _size23) = iprot.readListBegin()
6296 
          for _i27 in xrange(_size23):
6297 
            _elem28 = Item()
6298 
            _elem28.read(iprot)
6299 
            self.success.append(_elem28)
6300 
          iprot.readListEnd()
6301 
        else:
6302 
          iprot.skip(ftype)
6303 
      elif fid == 1:
6304 
        if ftype == TType.STRUCT:
6305 
          self.cex = CatalogServiceException()
6306 
          self.cex.read(iprot)
6307 
        else:
6308 
          iprot.skip(ftype)
6309 
      else:
6310 
        iprot.skip(ftype)
6311 
      iprot.readFieldEnd()
6312 
    iprot.readStructEnd()
6313 
 
6314 
  def write(self, oprot):
6315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6317 
      return
6318 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6319 
    if self.success is not None:
6320 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6321 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6322 
      for iter29 in self.success:
6323 
        iter29.write(oprot)
6324 
      oprot.writeListEnd()
6325 
      oprot.writeFieldEnd()
6326 
    if self.cex is not None:
6327 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6328 
      self.cex.write(oprot)
6329 
      oprot.writeFieldEnd()
6330 
    oprot.writeFieldStop()
6331 
    oprot.writeStructEnd()
6332 
 
6333 
  def validate(self):
6334 
    return
6335 
 
6336 
 
6337 
  def __repr__(self):
6338 
    L = ['%s=%r' % (key, value)
6339 
      for key, value in self.__dict__.iteritems()]
6340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6341 
 
6342 
  def __eq__(self, other):
6343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6344 
 
6345 
  def __ne__(self, other):
6346 
    return not (self == other)
6347 
 
6348 
class getAllItems_args:
6349 
  """
6350 
  Attributes:
6351 
   - isActive
6352 
  """
6353 
 
6354 
  thrift_spec = (
6355 
    None, # 0
6356 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6357 
  )
6358 
 
6359 
  def __init__(self, isActive=None,):
6360 
    self.isActive = isActive
6361 
 
6362 
  def read(self, iprot):
6363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6365 
      return
6366 
    iprot.readStructBegin()
6367 
    while True:
6368 
      (fname, ftype, fid) = iprot.readFieldBegin()
6369 
      if ftype == TType.STOP:
6370 
        break
6371 
      if fid == 1:
6372 
        if ftype == TType.BOOL:
6373 
          self.isActive = iprot.readBool();
6374 
        else:
6375 
          iprot.skip(ftype)
6376 
      else:
6377 
        iprot.skip(ftype)
6378 
      iprot.readFieldEnd()
6379 
    iprot.readStructEnd()
6380 
 
6381 
  def write(self, oprot):
6382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6384 
      return
6385 
    oprot.writeStructBegin('getAllItems_args')
6386 
    if self.isActive is not None:
6387 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6388 
      oprot.writeBool(self.isActive)
6389 
      oprot.writeFieldEnd()
6390 
    oprot.writeFieldStop()
6391 
    oprot.writeStructEnd()
6392 
 
6393 
  def validate(self):
6394 
    return
6395 
 
6396 
 
6397 
  def __repr__(self):
6398 
    L = ['%s=%r' % (key, value)
6399 
      for key, value in self.__dict__.iteritems()]
6400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6401 
 
6402 
  def __eq__(self, other):
6403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6404 
 
6405 
  def __ne__(self, other):
6406 
    return not (self == other)
6407 
 
6408 
class getAllItems_result:
6409 
  """
6410 
  Attributes:
6411 
   - success
6412 
   - cex
6413 
  """
6414 
 
6415 
  thrift_spec = (
6416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6417 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6418 
  )
6419 
 
6420 
  def __init__(self, success=None, cex=None,):
6421 
    self.success = success
6422 
    self.cex = cex
6423 
 
6424 
  def read(self, iprot):
6425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6427 
      return
6428 
    iprot.readStructBegin()
6429 
    while True:
6430 
      (fname, ftype, fid) = iprot.readFieldBegin()
6431 
      if ftype == TType.STOP:
6432 
        break
6433 
      if fid == 0:
6434 
        if ftype == TType.LIST:
6435 
          self.success = []
6436 
          (_etype33, _size30) = iprot.readListBegin()
6437 
          for _i34 in xrange(_size30):
6438 
            _elem35 = Item()
6439 
            _elem35.read(iprot)
6440 
            self.success.append(_elem35)
6441 
          iprot.readListEnd()
6442 
        else:
6443 
          iprot.skip(ftype)
6444 
      elif fid == 1:
6445 
        if ftype == TType.STRUCT:
6446 
          self.cex = CatalogServiceException()
6447 
          self.cex.read(iprot)
6448 
        else:
6449 
          iprot.skip(ftype)
6450 
      else:
6451 
        iprot.skip(ftype)
6452 
      iprot.readFieldEnd()
6453 
    iprot.readStructEnd()
6454 
 
6455 
  def write(self, oprot):
6456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6458 
      return
6459 
    oprot.writeStructBegin('getAllItems_result')
6460 
    if self.success is not None:
6461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6463 
      for iter36 in self.success:
6464 
        iter36.write(oprot)
6465 
      oprot.writeListEnd()
6466 
      oprot.writeFieldEnd()
6467 
    if self.cex is not None:
6468 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6469 
      self.cex.write(oprot)
6470 
      oprot.writeFieldEnd()
6471 
    oprot.writeFieldStop()
6472 
    oprot.writeStructEnd()
6473 
 
6474 
  def validate(self):
6475 
    return
6476 
 
6477 
 
6478 
  def __repr__(self):
6479 
    L = ['%s=%r' % (key, value)
6480 
      for key, value in self.__dict__.iteritems()]
6481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6482 
 
6483 
  def __eq__(self, other):
6484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6485 
 
6486 
  def __ne__(self, other):
6487 
    return not (self == other)
6488 
 
6489 
class getAllItemsByStatus_args:
6490 
  """
6491 
  Attributes:
6492 
   - itemStatus
6493 
  """
6494 
 
6495 
  thrift_spec = (
6496 
    None, # 0
6497 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6498 
  )
6499 
 
6500 
  def __init__(self, itemStatus=None,):
6501 
    self.itemStatus = itemStatus
6502 
 
6503 
  def read(self, iprot):
6504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6506 
      return
6507 
    iprot.readStructBegin()
6508 
    while True:
6509 
      (fname, ftype, fid) = iprot.readFieldBegin()
6510 
      if ftype == TType.STOP:
6511 
        break
6512 
      if fid == 1:
6513 
        if ftype == TType.I32:
6514 
          self.itemStatus = iprot.readI32();
6515 
        else:
6516 
          iprot.skip(ftype)
6517 
      else:
6518 
        iprot.skip(ftype)
6519 
      iprot.readFieldEnd()
6520 
    iprot.readStructEnd()
6521 
 
6522 
  def write(self, oprot):
6523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6525 
      return
6526 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6527 
    if self.itemStatus is not None:
6528 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6529 
      oprot.writeI32(self.itemStatus)
6530 
      oprot.writeFieldEnd()
6531 
    oprot.writeFieldStop()
6532 
    oprot.writeStructEnd()
6533 
 
6534 
  def validate(self):
6535 
    return
6536 
 
6537 
 
6538 
  def __repr__(self):
6539 
    L = ['%s=%r' % (key, value)
6540 
      for key, value in self.__dict__.iteritems()]
6541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6542 
 
6543 
  def __eq__(self, other):
6544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6545 
 
6546 
  def __ne__(self, other):
6547 
    return not (self == other)
6548 
 
6549 
class getAllItemsByStatus_result:
6550 
  """
6551 
  Attributes:
6552 
   - success
6553 
   - cex
6554 
  """
6555 
 
6556 
  thrift_spec = (
6557 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6558 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6559 
  )
6560 
 
6561 
  def __init__(self, success=None, cex=None,):
6562 
    self.success = success
6563 
    self.cex = cex
6564 
 
6565 
  def read(self, iprot):
6566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6568 
      return
6569 
    iprot.readStructBegin()
6570 
    while True:
6571 
      (fname, ftype, fid) = iprot.readFieldBegin()
6572 
      if ftype == TType.STOP:
6573 
        break
6574 
      if fid == 0:
6575 
        if ftype == TType.LIST:
6576 
          self.success = []
6577 
          (_etype40, _size37) = iprot.readListBegin()
6578 
          for _i41 in xrange(_size37):
6579 
            _elem42 = Item()
6580 
            _elem42.read(iprot)
6581 
            self.success.append(_elem42)
6582 
          iprot.readListEnd()
6583 
        else:
6584 
          iprot.skip(ftype)
6585 
      elif fid == 1:
6586 
        if ftype == TType.STRUCT:
6587 
          self.cex = CatalogServiceException()
6588 
          self.cex.read(iprot)
6589 
        else:
6590 
          iprot.skip(ftype)
6591 
      else:
6592 
        iprot.skip(ftype)
6593 
      iprot.readFieldEnd()
6594 
    iprot.readStructEnd()
6595 
 
6596 
  def write(self, oprot):
6597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6599 
      return
6600 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6601 
    if self.success is not None:
6602 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6603 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6604 
      for iter43 in self.success:
6605 
        iter43.write(oprot)
6606 
      oprot.writeListEnd()
6607 
      oprot.writeFieldEnd()
6608 
    if self.cex is not None:
6609 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6610 
      self.cex.write(oprot)
6611 
      oprot.writeFieldEnd()
6612 
    oprot.writeFieldStop()
6613 
    oprot.writeStructEnd()
6614 
 
6615 
  def validate(self):
6616 
    return
6617 
 
6618 
 
6619 
  def __repr__(self):
6620 
    L = ['%s=%r' % (key, value)
6621 
      for key, value in self.__dict__.iteritems()]
6622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6623 
 
6624 
  def __eq__(self, other):
6625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6626 
 
6627 
  def __ne__(self, other):
6628 
    return not (self == other)
6629 
 
6630 
class markItemAsContentComplete_args:
6631 
  """
6632 
  Attributes:
6633 
   - entityId
6634 
   - category
6635 
   - brand
6636 
   - modelName
6637 
   - modelNumber
6638 
  """
6639 
 
6640 
  thrift_spec = (
6641 
    None, # 0
6642 
    (1, TType.I64, 'entityId', None, None, ), # 1
6643 
    (2, TType.I64, 'category', None, None, ), # 2
6644 
    (3, TType.STRING, 'brand', None, None, ), # 3
6645 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6646 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6647 
  )
6648 
 
6649 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6650 
    self.entityId = entityId
6651 
    self.category = category
6652 
    self.brand = brand
6653 
    self.modelName = modelName
6654 
    self.modelNumber = modelNumber
6655 
 
6656 
  def read(self, iprot):
6657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6659 
      return
6660 
    iprot.readStructBegin()
6661 
    while True:
6662 
      (fname, ftype, fid) = iprot.readFieldBegin()
6663 
      if ftype == TType.STOP:
6664 
        break
6665 
      if fid == 1:
6666 
        if ftype == TType.I64:
6667 
          self.entityId = iprot.readI64();
6668 
        else:
6669 
          iprot.skip(ftype)
6670 
      elif fid == 2:
6671 
        if ftype == TType.I64:
6672 
          self.category = iprot.readI64();
6673 
        else:
6674 
          iprot.skip(ftype)
6675 
      elif fid == 3:
6676 
        if ftype == TType.STRING:
6677 
          self.brand = iprot.readString();
6678 
        else:
6679 
          iprot.skip(ftype)
6680 
      elif fid == 4:
6681 
        if ftype == TType.STRING:
6682 
          self.modelName = iprot.readString();
6683 
        else:
6684 
          iprot.skip(ftype)
6685 
      elif fid == 5:
6686 
        if ftype == TType.STRING:
6687 
          self.modelNumber = iprot.readString();
6688 
        else:
6689 
          iprot.skip(ftype)
6690 
      else:
6691 
        iprot.skip(ftype)
6692 
      iprot.readFieldEnd()
6693 
    iprot.readStructEnd()
6694 
 
6695 
  def write(self, oprot):
6696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6698 
      return
6699 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6700 
    if self.entityId is not None:
6701 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6702 
      oprot.writeI64(self.entityId)
6703 
      oprot.writeFieldEnd()
6704 
    if self.category is not None:
6705 
      oprot.writeFieldBegin('category', TType.I64, 2)
6706 
      oprot.writeI64(self.category)
6707 
      oprot.writeFieldEnd()
6708 
    if self.brand is not None:
6709 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6710 
      oprot.writeString(self.brand)
6711 
      oprot.writeFieldEnd()
6712 
    if self.modelName is not None:
6713 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6714 
      oprot.writeString(self.modelName)
6715 
      oprot.writeFieldEnd()
6716 
    if self.modelNumber is not None:
6717 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6718 
      oprot.writeString(self.modelNumber)
6719 
      oprot.writeFieldEnd()
6720 
    oprot.writeFieldStop()
6721 
    oprot.writeStructEnd()
6722 
 
6723 
  def validate(self):
6724 
    return
6725 
 
6726 
 
6727 
  def __repr__(self):
6728 
    L = ['%s=%r' % (key, value)
6729 
      for key, value in self.__dict__.iteritems()]
6730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6731 
 
6732 
  def __eq__(self, other):
6733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6734 
 
6735 
  def __ne__(self, other):
6736 
    return not (self == other)
6737 
 
6738 
class markItemAsContentComplete_result:
6739 
  """
6740 
  Attributes:
6741 
   - success
6742 
   - cex
6743 
  """
6744 
 
6745 
  thrift_spec = (
6746 
    (0, TType.BOOL, 'success', None, None, ), # 0
6747 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6748 
  )
6749 
 
6750 
  def __init__(self, success=None, cex=None,):
6751 
    self.success = success
6752 
    self.cex = cex
6753 
 
6754 
  def read(self, iprot):
6755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6757 
      return
6758 
    iprot.readStructBegin()
6759 
    while True:
6760 
      (fname, ftype, fid) = iprot.readFieldBegin()
6761 
      if ftype == TType.STOP:
6762 
        break
6763 
      if fid == 0:
6764 
        if ftype == TType.BOOL:
6765 
          self.success = iprot.readBool();
6766 
        else:
6767 
          iprot.skip(ftype)
6768 
      elif fid == 1:
6769 
        if ftype == TType.STRUCT:
6770 
          self.cex = CatalogServiceException()
6771 
          self.cex.read(iprot)
6772 
        else:
6773 
          iprot.skip(ftype)
6774 
      else:
6775 
        iprot.skip(ftype)
6776 
      iprot.readFieldEnd()
6777 
    iprot.readStructEnd()
6778 
 
6779 
  def write(self, oprot):
6780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6782 
      return
6783 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6784 
    if self.success is not None:
6785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6786 
      oprot.writeBool(self.success)
6787 
      oprot.writeFieldEnd()
6788 
    if self.cex is not None:
6789 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6790 
      self.cex.write(oprot)
6791 
      oprot.writeFieldEnd()
6792 
    oprot.writeFieldStop()
6793 
    oprot.writeStructEnd()
6794 
 
6795 
  def validate(self):
6796 
    return
6797 
 
6798 
 
6799 
  def __repr__(self):
6800 
    L = ['%s=%r' % (key, value)
6801 
      for key, value in self.__dict__.iteritems()]
6802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6803 
 
6804 
  def __eq__(self, other):
6805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6806 
 
6807 
  def __ne__(self, other):
6808 
    return not (self == other)
6809 
 
6810 
class getAllItemsInRange_args:
6811 
  """
6812 
  Attributes:
6813 
   - offset
6814 
   - limit
6815 
  """
6816 
 
6817 
  thrift_spec = (
6818 
    None, # 0
6819 
    (1, TType.I64, 'offset', None, None, ), # 1
6820 
    (2, TType.I64, 'limit', None, None, ), # 2
6821 
  )
6822 
 
6823 
  def __init__(self, offset=None, limit=None,):
6824 
    self.offset = offset
6825 
    self.limit = limit
6826 
 
6827 
  def read(self, iprot):
6828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6830 
      return
6831 
    iprot.readStructBegin()
6832 
    while True:
6833 
      (fname, ftype, fid) = iprot.readFieldBegin()
6834 
      if ftype == TType.STOP:
6835 
        break
6836 
      if fid == 1:
6837 
        if ftype == TType.I64:
6838 
          self.offset = iprot.readI64();
6839 
        else:
6840 
          iprot.skip(ftype)
6841 
      elif fid == 2:
6842 
        if ftype == TType.I64:
6843 
          self.limit = iprot.readI64();
6844 
        else:
6845 
          iprot.skip(ftype)
6846 
      else:
6847 
        iprot.skip(ftype)
6848 
      iprot.readFieldEnd()
6849 
    iprot.readStructEnd()
6850 
 
6851 
  def write(self, oprot):
6852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6854 
      return
6855 
    oprot.writeStructBegin('getAllItemsInRange_args')
6856 
    if self.offset is not None:
6857 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6858 
      oprot.writeI64(self.offset)
6859 
      oprot.writeFieldEnd()
6860 
    if self.limit is not None:
6861 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6862 
      oprot.writeI64(self.limit)
6863 
      oprot.writeFieldEnd()
6864 
    oprot.writeFieldStop()
6865 
    oprot.writeStructEnd()
6866 
 
6867 
  def validate(self):
6868 
    return
6869 
 
6870 
 
6871 
  def __repr__(self):
6872 
    L = ['%s=%r' % (key, value)
6873 
      for key, value in self.__dict__.iteritems()]
6874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6875 
 
6876 
  def __eq__(self, other):
6877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6878 
 
6879 
  def __ne__(self, other):
6880 
    return not (self == other)
6881 
 
6882 
class getAllItemsInRange_result:
6883 
  """
6884 
  Attributes:
6885 
   - success
6886 
   - cex
6887 
  """
6888 
 
6889 
  thrift_spec = (
6890 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6891 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6892 
  )
6893 
 
6894 
  def __init__(self, success=None, cex=None,):
6895 
    self.success = success
6896 
    self.cex = cex
6897 
 
6898 
  def read(self, iprot):
6899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6901 
      return
6902 
    iprot.readStructBegin()
6903 
    while True:
6904 
      (fname, ftype, fid) = iprot.readFieldBegin()
6905 
      if ftype == TType.STOP:
6906 
        break
6907 
      if fid == 0:
6908 
        if ftype == TType.LIST:
6909 
          self.success = []
6910 
          (_etype47, _size44) = iprot.readListBegin()
6911 
          for _i48 in xrange(_size44):
6912 
            _elem49 = Item()
6913 
            _elem49.read(iprot)
6914 
            self.success.append(_elem49)
6915 
          iprot.readListEnd()
6916 
        else:
6917 
          iprot.skip(ftype)
6918 
      elif fid == 1:
6919 
        if ftype == TType.STRUCT:
6920 
          self.cex = CatalogServiceException()
6921 
          self.cex.read(iprot)
6922 
        else:
6923 
          iprot.skip(ftype)
6924 
      else:
6925 
        iprot.skip(ftype)
6926 
      iprot.readFieldEnd()
6927 
    iprot.readStructEnd()
6928 
 
6929 
  def write(self, oprot):
6930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6932 
      return
6933 
    oprot.writeStructBegin('getAllItemsInRange_result')
6934 
    if self.success is not None:
6935 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6936 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6937 
      for iter50 in self.success:
6938 
        iter50.write(oprot)
6939 
      oprot.writeListEnd()
6940 
      oprot.writeFieldEnd()
6941 
    if self.cex is not None:
6942 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6943 
      self.cex.write(oprot)
6944 
      oprot.writeFieldEnd()
6945 
    oprot.writeFieldStop()
6946 
    oprot.writeStructEnd()
6947 
 
6948 
  def validate(self):
6949 
    return
6950 
 
6951 
 
6952 
  def __repr__(self):
6953 
    L = ['%s=%r' % (key, value)
6954 
      for key, value in self.__dict__.iteritems()]
6955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6956 
 
6957 
  def __eq__(self, other):
6958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6959 
 
6960 
  def __ne__(self, other):
6961 
    return not (self == other)
6962 
 
6963 
class getAllItemsByStatusInRange_args:
6964 
  """
6965 
  Attributes:
6966 
   - itemStatus
6967 
   - offset
6968 
   - limit
6969 
  """
6970 
 
6971 
  thrift_spec = (
6972 
    None, # 0
6973 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6974 
    (2, TType.I64, 'offset', None, None, ), # 2
6975 
    (3, TType.I64, 'limit', None, None, ), # 3
6976 
  )
6977 
 
6978 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
6979 
    self.itemStatus = itemStatus
6980 
    self.offset = offset
6981 
    self.limit = limit
6982 
 
6983 
  def read(self, iprot):
6984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6986 
      return
6987 
    iprot.readStructBegin()
6988 
    while True:
6989 
      (fname, ftype, fid) = iprot.readFieldBegin()
6990 
      if ftype == TType.STOP:
6991 
        break
6992 
      if fid == 1:
6993 
        if ftype == TType.I32:
6994 
          self.itemStatus = iprot.readI32();
6995 
        else:
6996 
          iprot.skip(ftype)
6997 
      elif fid == 2:
6998 
        if ftype == TType.I64:
6999 
          self.offset = iprot.readI64();
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      elif fid == 3:
7003 
        if ftype == TType.I64:
7004 
          self.limit = iprot.readI64();
7005 
        else:
7006 
          iprot.skip(ftype)
7007 
      else:
7008 
        iprot.skip(ftype)
7009 
      iprot.readFieldEnd()
7010 
    iprot.readStructEnd()
7011 
 
7012 
  def write(self, oprot):
7013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7015 
      return
7016 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7017 
    if self.itemStatus is not None:
7018 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7019 
      oprot.writeI32(self.itemStatus)
7020 
      oprot.writeFieldEnd()
7021 
    if self.offset is not None:
7022 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7023 
      oprot.writeI64(self.offset)
7024 
      oprot.writeFieldEnd()
7025 
    if self.limit is not None:
7026 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7027 
      oprot.writeI64(self.limit)
7028 
      oprot.writeFieldEnd()
7029 
    oprot.writeFieldStop()
7030 
    oprot.writeStructEnd()
7031 
 
7032 
  def validate(self):
7033 
    return
7034 
 
7035 
 
7036 
  def __repr__(self):
7037 
    L = ['%s=%r' % (key, value)
7038 
      for key, value in self.__dict__.iteritems()]
7039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7040 
 
7041 
  def __eq__(self, other):
7042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7043 
 
7044 
  def __ne__(self, other):
7045 
    return not (self == other)
7046 
 
7047 
class getAllItemsByStatusInRange_result:
7048 
  """
7049 
  Attributes:
7050 
   - success
7051 
   - cex
7052 
  """
7053 
 
7054 
  thrift_spec = (
7055 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7056 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7057 
  )
7058 
 
7059 
  def __init__(self, success=None, cex=None,):
7060 
    self.success = success
7061 
    self.cex = cex
7062 
 
7063 
  def read(self, iprot):
7064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7066 
      return
7067 
    iprot.readStructBegin()
7068 
    while True:
7069 
      (fname, ftype, fid) = iprot.readFieldBegin()
7070 
      if ftype == TType.STOP:
7071 
        break
7072 
      if fid == 0:
7073 
        if ftype == TType.LIST:
7074 
          self.success = []
7075 
          (_etype54, _size51) = iprot.readListBegin()
7076 
          for _i55 in xrange(_size51):
7077 
            _elem56 = Item()
7078 
            _elem56.read(iprot)
7079 
            self.success.append(_elem56)
7080 
          iprot.readListEnd()
7081 
        else:
7082 
          iprot.skip(ftype)
7083 
      elif fid == 1:
7084 
        if ftype == TType.STRUCT:
7085 
          self.cex = CatalogServiceException()
7086 
          self.cex.read(iprot)
7087 
        else:
7088 
          iprot.skip(ftype)
7089 
      else:
7090 
        iprot.skip(ftype)
7091 
      iprot.readFieldEnd()
7092 
    iprot.readStructEnd()
7093 
 
7094 
  def write(self, oprot):
7095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7097 
      return
7098 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7099 
    if self.success is not None:
7100 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7101 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7102 
      for iter57 in self.success:
7103 
        iter57.write(oprot)
7104 
      oprot.writeListEnd()
7105 
      oprot.writeFieldEnd()
7106 
    if self.cex is not None:
7107 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7108 
      self.cex.write(oprot)
7109 
      oprot.writeFieldEnd()
7110 
    oprot.writeFieldStop()
7111 
    oprot.writeStructEnd()
7112 
 
7113 
  def validate(self):
7114 
    return
7115 
 
7116 
 
7117 
  def __repr__(self):
7118 
    L = ['%s=%r' % (key, value)
7119 
      for key, value in self.__dict__.iteritems()]
7120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7121 
 
7122 
  def __eq__(self, other):
7123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7124 
 
7125 
  def __ne__(self, other):
7126 
    return not (self == other)
7127 
 
7128 
class getItemCountByStatus_args:
7129 
  """
7130 
  Attributes:
7131 
   - useStatus
7132 
   - itemStatus
7133 
  """
7134 
 
7135 
  thrift_spec = (
7136 
    None, # 0
7137 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7138 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7139 
  )
7140 
 
7141 
  def __init__(self, useStatus=None, itemStatus=None,):
7142 
    self.useStatus = useStatus
7143 
    self.itemStatus = itemStatus
7144 
 
7145 
  def read(self, iprot):
7146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7148 
      return
7149 
    iprot.readStructBegin()
7150 
    while True:
7151 
      (fname, ftype, fid) = iprot.readFieldBegin()
7152 
      if ftype == TType.STOP:
7153 
        break
7154 
      if fid == 1:
7155 
        if ftype == TType.BOOL:
7156 
          self.useStatus = iprot.readBool();
7157 
        else:
7158 
          iprot.skip(ftype)
7159 
      elif fid == 2:
7160 
        if ftype == TType.I32:
7161 
          self.itemStatus = iprot.readI32();
7162 
        else:
7163 
          iprot.skip(ftype)
7164 
      else:
7165 
        iprot.skip(ftype)
7166 
      iprot.readFieldEnd()
7167 
    iprot.readStructEnd()
7168 
 
7169 
  def write(self, oprot):
7170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7172 
      return
7173 
    oprot.writeStructBegin('getItemCountByStatus_args')
7174 
    if self.useStatus is not None:
7175 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7176 
      oprot.writeBool(self.useStatus)
7177 
      oprot.writeFieldEnd()
7178 
    if self.itemStatus is not None:
7179 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7180 
      oprot.writeI32(self.itemStatus)
7181 
      oprot.writeFieldEnd()
7182 
    oprot.writeFieldStop()
7183 
    oprot.writeStructEnd()
7184 
 
7185 
  def validate(self):
7186 
    return
7187 
 
7188 
 
7189 
  def __repr__(self):
7190 
    L = ['%s=%r' % (key, value)
7191 
      for key, value in self.__dict__.iteritems()]
7192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7193 
 
7194 
  def __eq__(self, other):
7195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7196 
 
7197 
  def __ne__(self, other):
7198 
    return not (self == other)
7199 
 
7200 
class getItemCountByStatus_result:
7201 
  """
7202 
  Attributes:
7203 
   - success
7204 
  """
7205 
 
7206 
  thrift_spec = (
7207 
    (0, TType.I32, 'success', None, None, ), # 0
7208 
  )
7209 
 
7210 
  def __init__(self, success=None,):
7211 
    self.success = success
7212 
 
7213 
  def read(self, iprot):
7214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7216 
      return
7217 
    iprot.readStructBegin()
7218 
    while True:
7219 
      (fname, ftype, fid) = iprot.readFieldBegin()
7220 
      if ftype == TType.STOP:
7221 
        break
7222 
      if fid == 0:
7223 
        if ftype == TType.I32:
7224 
          self.success = iprot.readI32();
7225 
        else:
7226 
          iprot.skip(ftype)
7227 
      else:
7228 
        iprot.skip(ftype)
7229 
      iprot.readFieldEnd()
7230 
    iprot.readStructEnd()
7231 
 
7232 
  def write(self, oprot):
7233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7235 
      return
7236 
    oprot.writeStructBegin('getItemCountByStatus_result')
7237 
    if self.success is not None:
7238 
      oprot.writeFieldBegin('success', TType.I32, 0)
7239 
      oprot.writeI32(self.success)
7240 
      oprot.writeFieldEnd()
7241 
    oprot.writeFieldStop()
7242 
    oprot.writeStructEnd()
7243 
 
7244 
  def validate(self):
7245 
    return
7246 
 
7247 
 
7248 
  def __repr__(self):
7249 
    L = ['%s=%r' % (key, value)
7250 
      for key, value in self.__dict__.iteritems()]
7251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7252 
 
7253 
  def __eq__(self, other):
7254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7255 
 
7256 
  def __ne__(self, other):
7257 
    return not (self == other)
7258 
 
7259 
class getBestSellers_args:
7260 
 
7261 
  thrift_spec = (
7262 
  )
7263 
 
7264 
  def read(self, iprot):
7265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7267 
      return
7268 
    iprot.readStructBegin()
7269 
    while True:
7270 
      (fname, ftype, fid) = iprot.readFieldBegin()
7271 
      if ftype == TType.STOP:
7272 
        break
7273 
      else:
7274 
        iprot.skip(ftype)
7275 
      iprot.readFieldEnd()
7276 
    iprot.readStructEnd()
7277 
 
7278 
  def write(self, oprot):
7279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7281 
      return
7282 
    oprot.writeStructBegin('getBestSellers_args')
7283 
    oprot.writeFieldStop()
7284 
    oprot.writeStructEnd()
7285 
 
7286 
  def validate(self):
7287 
    return
7288 
 
7289 
 
7290 
  def __repr__(self):
7291 
    L = ['%s=%r' % (key, value)
7292 
      for key, value in self.__dict__.iteritems()]
7293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7294 
 
7295 
  def __eq__(self, other):
7296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7297 
 
7298 
  def __ne__(self, other):
7299 
    return not (self == other)
7300 
 
7301 
class getBestSellers_result:
7302 
  """
7303 
  Attributes:
7304 
   - success
7305 
   - isex
7306 
  """
7307 
 
7308 
  thrift_spec = (
7309 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7310 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7311 
  )
7312 
 
7313 
  def __init__(self, success=None, isex=None,):
7314 
    self.success = success
7315 
    self.isex = isex
7316 
 
7317 
  def read(self, iprot):
7318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7320 
      return
7321 
    iprot.readStructBegin()
7322 
    while True:
7323 
      (fname, ftype, fid) = iprot.readFieldBegin()
7324 
      if ftype == TType.STOP:
7325 
        break
7326 
      if fid == 0:
7327 
        if ftype == TType.LIST:
7328 
          self.success = []
7329 
          (_etype61, _size58) = iprot.readListBegin()
7330 
          for _i62 in xrange(_size58):
7331 
            _elem63 = Item()
7332 
            _elem63.read(iprot)
7333 
            self.success.append(_elem63)
7334 
          iprot.readListEnd()
7335 
        else:
7336 
          iprot.skip(ftype)
7337 
      elif fid == 1:
7338 
        if ftype == TType.STRUCT:
7339 
          self.isex = CatalogServiceException()
7340 
          self.isex.read(iprot)
7341 
        else:
7342 
          iprot.skip(ftype)
7343 
      else:
7344 
        iprot.skip(ftype)
7345 
      iprot.readFieldEnd()
7346 
    iprot.readStructEnd()
7347 
 
7348 
  def write(self, oprot):
7349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7351 
      return
7352 
    oprot.writeStructBegin('getBestSellers_result')
7353 
    if self.success is not None:
7354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7356 
      for iter64 in self.success:
7357 
        iter64.write(oprot)
7358 
      oprot.writeListEnd()
7359 
      oprot.writeFieldEnd()
7360 
    if self.isex is not None:
7361 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7362 
      self.isex.write(oprot)
7363 
      oprot.writeFieldEnd()
7364 
    oprot.writeFieldStop()
7365 
    oprot.writeStructEnd()
7366 
 
7367 
  def validate(self):
7368 
    return
7369 
 
7370 
 
7371 
  def __repr__(self):
7372 
    L = ['%s=%r' % (key, value)
7373 
      for key, value in self.__dict__.iteritems()]
7374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7375 
 
7376 
  def __eq__(self, other):
7377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7378 
 
7379 
  def __ne__(self, other):
7380 
    return not (self == other)
7381 
 
7382 
class getBestSellersCatalogIds_args:
7383 
  """
7384 
  Attributes:
7385 
   - beginIndex
7386 
   - totalItems
7387 
   - brand
7388 
   - category
7389 
  """
7390 
 
7391 
  thrift_spec = (
7392 
    None, # 0
7393 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7394 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7395 
    (3, TType.STRING, 'brand', None, None, ), # 3
7396 
    (4, TType.I64, 'category', None, None, ), # 4
7397 
  )
7398 
 
7399 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7400 
    self.beginIndex = beginIndex
7401 
    self.totalItems = totalItems
7402 
    self.brand = brand
7403 
    self.category = category
7404 
 
7405 
  def read(self, iprot):
7406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7408 
      return
7409 
    iprot.readStructBegin()
7410 
    while True:
7411 
      (fname, ftype, fid) = iprot.readFieldBegin()
7412 
      if ftype == TType.STOP:
7413 
        break
7414 
      if fid == 1:
7415 
        if ftype == TType.I64:
7416 
          self.beginIndex = iprot.readI64();
7417 
        else:
7418 
          iprot.skip(ftype)
7419 
      elif fid == 2:
7420 
        if ftype == TType.I64:
7421 
          self.totalItems = iprot.readI64();
7422 
        else:
7423 
          iprot.skip(ftype)
7424 
      elif fid == 3:
7425 
        if ftype == TType.STRING:
7426 
          self.brand = iprot.readString();
7427 
        else:
7428 
          iprot.skip(ftype)
7429 
      elif fid == 4:
7430 
        if ftype == TType.I64:
7431 
          self.category = iprot.readI64();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7444 
    if self.beginIndex is not None:
7445 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7446 
      oprot.writeI64(self.beginIndex)
7447 
      oprot.writeFieldEnd()
7448 
    if self.totalItems is not None:
7449 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7450 
      oprot.writeI64(self.totalItems)
7451 
      oprot.writeFieldEnd()
7452 
    if self.brand is not None:
7453 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7454 
      oprot.writeString(self.brand)
7455 
      oprot.writeFieldEnd()
7456 
    if self.category is not None:
7457 
      oprot.writeFieldBegin('category', TType.I64, 4)
7458 
      oprot.writeI64(self.category)
7459 
      oprot.writeFieldEnd()
7460 
    oprot.writeFieldStop()
7461 
    oprot.writeStructEnd()
7462 
 
7463 
  def validate(self):
7464 
    return
7465 
 
7466 
 
7467 
  def __repr__(self):
7468 
    L = ['%s=%r' % (key, value)
7469 
      for key, value in self.__dict__.iteritems()]
7470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7471 
 
7472 
  def __eq__(self, other):
7473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7474 
 
7475 
  def __ne__(self, other):
7476 
    return not (self == other)
7477 
 
7478 
class getBestSellersCatalogIds_result:
7479 
  """
7480 
  Attributes:
7481 
   - success
7482 
   - cex
7483 
  """
7484 
 
7485 
  thrift_spec = (
7486 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7487 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7488 
  )
7489 
 
7490 
  def __init__(self, success=None, cex=None,):
7491 
    self.success = success
7492 
    self.cex = cex
7493 
 
7494 
  def read(self, iprot):
7495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7497 
      return
7498 
    iprot.readStructBegin()
7499 
    while True:
7500 
      (fname, ftype, fid) = iprot.readFieldBegin()
7501 
      if ftype == TType.STOP:
7502 
        break
7503 
      if fid == 0:
7504 
        if ftype == TType.LIST:
7505 
          self.success = []
7506 
          (_etype68, _size65) = iprot.readListBegin()
7507 
          for _i69 in xrange(_size65):
7508 
            _elem70 = iprot.readI64();
7509 
            self.success.append(_elem70)
7510 
          iprot.readListEnd()
7511 
        else:
7512 
          iprot.skip(ftype)
7513 
      elif fid == 1:
7514 
        if ftype == TType.STRUCT:
7515 
          self.cex = CatalogServiceException()
7516 
          self.cex.read(iprot)
7517 
        else:
7518 
          iprot.skip(ftype)
7519 
      else:
7520 
        iprot.skip(ftype)
7521 
      iprot.readFieldEnd()
7522 
    iprot.readStructEnd()
7523 
 
7524 
  def write(self, oprot):
7525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7527 
      return
7528 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7529 
    if self.success is not None:
7530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7531 
      oprot.writeListBegin(TType.I64, len(self.success))
7532 
      for iter71 in self.success:
7533 
        oprot.writeI64(iter71)
7534 
      oprot.writeListEnd()
7535 
      oprot.writeFieldEnd()
7536 
    if self.cex is not None:
7537 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7538 
      self.cex.write(oprot)
7539 
      oprot.writeFieldEnd()
7540 
    oprot.writeFieldStop()
7541 
    oprot.writeStructEnd()
7542 
 
7543 
  def validate(self):
7544 
    return
7545 
 
7546 
 
7547 
  def __repr__(self):
7548 
    L = ['%s=%r' % (key, value)
7549 
      for key, value in self.__dict__.iteritems()]
7550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7551 
 
7552 
  def __eq__(self, other):
7553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7554 
 
7555 
  def __ne__(self, other):
7556 
    return not (self == other)
7557 
 
7558 
class getBestSellersCount_args:
7559 
 
7560 
  thrift_spec = (
7561 
  )
7562 
 
7563 
  def read(self, iprot):
7564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7566 
      return
7567 
    iprot.readStructBegin()
7568 
    while True:
7569 
      (fname, ftype, fid) = iprot.readFieldBegin()
7570 
      if ftype == TType.STOP:
7571 
        break
7572 
      else:
7573 
        iprot.skip(ftype)
7574 
      iprot.readFieldEnd()
7575 
    iprot.readStructEnd()
7576 
 
7577 
  def write(self, oprot):
7578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7580 
      return
7581 
    oprot.writeStructBegin('getBestSellersCount_args')
7582 
    oprot.writeFieldStop()
7583 
    oprot.writeStructEnd()
7584 
 
7585 
  def validate(self):
7586 
    return
7587 
 
7588 
 
7589 
  def __repr__(self):
7590 
    L = ['%s=%r' % (key, value)
7591 
      for key, value in self.__dict__.iteritems()]
7592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7593 
 
7594 
  def __eq__(self, other):
7595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7596 
 
7597 
  def __ne__(self, other):
7598 
    return not (self == other)
7599 
 
7600 
class getBestSellersCount_result:
7601 
  """
7602 
  Attributes:
7603 
   - success
7604 
   - cex
7605 
  """
7606 
 
7607 
  thrift_spec = (
7608 
    (0, TType.I64, 'success', None, None, ), # 0
7609 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7610 
  )
7611 
 
7612 
  def __init__(self, success=None, cex=None,):
7613 
    self.success = success
7614 
    self.cex = cex
7615 
 
7616 
  def read(self, iprot):
7617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7619 
      return
7620 
    iprot.readStructBegin()
7621 
    while True:
7622 
      (fname, ftype, fid) = iprot.readFieldBegin()
7623 
      if ftype == TType.STOP:
7624 
        break
7625 
      if fid == 0:
7626 
        if ftype == TType.I64:
7627 
          self.success = iprot.readI64();
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      elif fid == 1:
7631 
        if ftype == TType.STRUCT:
7632 
          self.cex = CatalogServiceException()
7633 
          self.cex.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('getBestSellersCount_result')
7646 
    if self.success is not None:
7647 
      oprot.writeFieldBegin('success', TType.I64, 0)
7648 
      oprot.writeI64(self.success)
7649 
      oprot.writeFieldEnd()
7650 
    if self.cex is not None:
7651 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7652 
      self.cex.write(oprot)
7653 
      oprot.writeFieldEnd()
7654 
    oprot.writeFieldStop()
7655 
    oprot.writeStructEnd()
7656 
 
7657 
  def validate(self):
7658 
    return
7659 
 
7660 
 
7661 
  def __repr__(self):
7662 
    L = ['%s=%r' % (key, value)
7663 
      for key, value in self.__dict__.iteritems()]
7664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7665 
 
7666 
  def __eq__(self, other):
7667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7668 
 
7669 
  def __ne__(self, other):
7670 
    return not (self == other)
7671 
 
7672 
class getBestDeals_args:
7673 
 
7674 
  thrift_spec = (
7675 
  )
7676 
 
7677 
  def read(self, iprot):
7678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7680 
      return
7681 
    iprot.readStructBegin()
7682 
    while True:
7683 
      (fname, ftype, fid) = iprot.readFieldBegin()
7684 
      if ftype == TType.STOP:
7685 
        break
7686 
      else:
7687 
        iprot.skip(ftype)
7688 
      iprot.readFieldEnd()
7689 
    iprot.readStructEnd()
7690 
 
7691 
  def write(self, oprot):
7692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7694 
      return
7695 
    oprot.writeStructBegin('getBestDeals_args')
7696 
    oprot.writeFieldStop()
7697 
    oprot.writeStructEnd()
7698 
 
7699 
  def validate(self):
7700 
    return
7701 
 
7702 
 
7703 
  def __repr__(self):
7704 
    L = ['%s=%r' % (key, value)
7705 
      for key, value in self.__dict__.iteritems()]
7706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7707 
 
7708 
  def __eq__(self, other):
7709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7710 
 
7711 
  def __ne__(self, other):
7712 
    return not (self == other)
7713 
 
7714 
class getBestDeals_result:
7715 
  """
7716 
  Attributes:
7717 
   - success
7718 
   - isex
7719 
  """
7720 
 
7721 
  thrift_spec = (
7722 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7723 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7724 
  )
7725 
 
7726 
  def __init__(self, success=None, isex=None,):
7727 
    self.success = success
7728 
    self.isex = isex
7729 
 
7730 
  def read(self, iprot):
7731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7733 
      return
7734 
    iprot.readStructBegin()
7735 
    while True:
7736 
      (fname, ftype, fid) = iprot.readFieldBegin()
7737 
      if ftype == TType.STOP:
7738 
        break
7739 
      if fid == 0:
7740 
        if ftype == TType.LIST:
7741 
          self.success = []
7742 
          (_etype75, _size72) = iprot.readListBegin()
7743 
          for _i76 in xrange(_size72):
7744 
            _elem77 = Item()
7745 
            _elem77.read(iprot)
7746 
            self.success.append(_elem77)
7747 
          iprot.readListEnd()
7748 
        else:
7749 
          iprot.skip(ftype)
7750 
      elif fid == 1:
7751 
        if ftype == TType.STRUCT:
7752 
          self.isex = CatalogServiceException()
7753 
          self.isex.read(iprot)
7754 
        else:
7755 
          iprot.skip(ftype)
7756 
      else:
7757 
        iprot.skip(ftype)
7758 
      iprot.readFieldEnd()
7759 
    iprot.readStructEnd()
7760 
 
7761 
  def write(self, oprot):
7762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7764 
      return
7765 
    oprot.writeStructBegin('getBestDeals_result')
7766 
    if self.success is not None:
7767 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7768 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7769 
      for iter78 in self.success:
7770 
        iter78.write(oprot)
7771 
      oprot.writeListEnd()
7772 
      oprot.writeFieldEnd()
7773 
    if self.isex is not None:
7774 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7775 
      self.isex.write(oprot)
7776 
      oprot.writeFieldEnd()
7777 
    oprot.writeFieldStop()
7778 
    oprot.writeStructEnd()
7779 
 
7780 
  def validate(self):
7781 
    return
7782 
 
7783 
 
7784 
  def __repr__(self):
7785 
    L = ['%s=%r' % (key, value)
7786 
      for key, value in self.__dict__.iteritems()]
7787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7788 
 
7789 
  def __eq__(self, other):
7790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7791 
 
7792 
  def __ne__(self, other):
7793 
    return not (self == other)
7794 
 
7795 
class getBestDealsCatalogIds_args:
7796 
  """
7797 
  Attributes:
7798 
   - beginIndex
7799 
   - totalItems
7800 
   - brand
7801 
   - category
7802 
  """
7803 
 
7804 
  thrift_spec = (
7805 
    None, # 0
7806 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7807 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7808 
    (3, TType.STRING, 'brand', None, None, ), # 3
7809 
    (4, TType.I64, 'category', None, None, ), # 4
7810 
  )
7811 
 
7812 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7813 
    self.beginIndex = beginIndex
7814 
    self.totalItems = totalItems
7815 
    self.brand = brand
7816 
    self.category = category
7817 
 
7818 
  def read(self, iprot):
7819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7821 
      return
7822 
    iprot.readStructBegin()
7823 
    while True:
7824 
      (fname, ftype, fid) = iprot.readFieldBegin()
7825 
      if ftype == TType.STOP:
7826 
        break
7827 
      if fid == 1:
7828 
        if ftype == TType.I64:
7829 
          self.beginIndex = iprot.readI64();
7830 
        else:
7831 
          iprot.skip(ftype)
7832 
      elif fid == 2:
7833 
        if ftype == TType.I64:
7834 
          self.totalItems = iprot.readI64();
7835 
        else:
7836 
          iprot.skip(ftype)
7837 
      elif fid == 3:
7838 
        if ftype == TType.STRING:
7839 
          self.brand = iprot.readString();
7840 
        else:
7841 
          iprot.skip(ftype)
7842 
      elif fid == 4:
7843 
        if ftype == TType.I64:
7844 
          self.category = iprot.readI64();
7845 
        else:
7846 
          iprot.skip(ftype)
7847 
      else:
7848 
        iprot.skip(ftype)
7849 
      iprot.readFieldEnd()
7850 
    iprot.readStructEnd()
7851 
 
7852 
  def write(self, oprot):
7853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7855 
      return
7856 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7857 
    if self.beginIndex is not None:
7858 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7859 
      oprot.writeI64(self.beginIndex)
7860 
      oprot.writeFieldEnd()
7861 
    if self.totalItems is not None:
7862 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7863 
      oprot.writeI64(self.totalItems)
7864 
      oprot.writeFieldEnd()
7865 
    if self.brand is not None:
7866 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7867 
      oprot.writeString(self.brand)
7868 
      oprot.writeFieldEnd()
7869 
    if self.category is not None:
7870 
      oprot.writeFieldBegin('category', TType.I64, 4)
7871 
      oprot.writeI64(self.category)
7872 
      oprot.writeFieldEnd()
7873 
    oprot.writeFieldStop()
7874 
    oprot.writeStructEnd()
7875 
 
7876 
  def validate(self):
7877 
    return
7878 
 
7879 
 
7880 
  def __repr__(self):
7881 
    L = ['%s=%r' % (key, value)
7882 
      for key, value in self.__dict__.iteritems()]
7883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7884 
 
7885 
  def __eq__(self, other):
7886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7887 
 
7888 
  def __ne__(self, other):
7889 
    return not (self == other)
7890 
 
7891 
class getBestDealsCatalogIds_result:
7892 
  """
7893 
  Attributes:
7894 
   - success
7895 
   - cex
7896 
  """
7897 
 
7898 
  thrift_spec = (
7899 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7900 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7901 
  )
7902 
 
7903 
  def __init__(self, success=None, cex=None,):
7904 
    self.success = success
7905 
    self.cex = cex
7906 
 
7907 
  def read(self, iprot):
7908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7910 
      return
7911 
    iprot.readStructBegin()
7912 
    while True:
7913 
      (fname, ftype, fid) = iprot.readFieldBegin()
7914 
      if ftype == TType.STOP:
7915 
        break
7916 
      if fid == 0:
7917 
        if ftype == TType.LIST:
7918 
          self.success = []
7919 
          (_etype82, _size79) = iprot.readListBegin()
7920 
          for _i83 in xrange(_size79):
7921 
            _elem84 = iprot.readI64();
7922 
            self.success.append(_elem84)
7923 
          iprot.readListEnd()
7924 
        else:
7925 
          iprot.skip(ftype)
7926 
      elif fid == 1:
7927 
        if ftype == TType.STRUCT:
7928 
          self.cex = CatalogServiceException()
7929 
          self.cex.read(iprot)
7930 
        else:
7931 
          iprot.skip(ftype)
7932 
      else:
7933 
        iprot.skip(ftype)
7934 
      iprot.readFieldEnd()
7935 
    iprot.readStructEnd()
7936 
 
7937 
  def write(self, oprot):
7938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7940 
      return
7941 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
7942 
    if self.success is not None:
7943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7944 
      oprot.writeListBegin(TType.I64, len(self.success))
7945 
      for iter85 in self.success:
7946 
        oprot.writeI64(iter85)
7947 
      oprot.writeListEnd()
7948 
      oprot.writeFieldEnd()
7949 
    if self.cex is not None:
7950 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7951 
      self.cex.write(oprot)
7952 
      oprot.writeFieldEnd()
7953 
    oprot.writeFieldStop()
7954 
    oprot.writeStructEnd()
7955 
 
7956 
  def validate(self):
7957 
    return
7958 
 
7959 
 
7960 
  def __repr__(self):
7961 
    L = ['%s=%r' % (key, value)
7962 
      for key, value in self.__dict__.iteritems()]
7963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7964 
 
7965 
  def __eq__(self, other):
7966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7967 
 
7968 
  def __ne__(self, other):
7969 
    return not (self == other)
7970 
 
7971 
class getBestDealsCount_args:
7972 
 
7973 
  thrift_spec = (
7974 
  )
7975 
 
7976 
  def read(self, iprot):
7977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7979 
      return
7980 
    iprot.readStructBegin()
7981 
    while True:
7982 
      (fname, ftype, fid) = iprot.readFieldBegin()
7983 
      if ftype == TType.STOP:
7984 
        break
7985 
      else:
7986 
        iprot.skip(ftype)
7987 
      iprot.readFieldEnd()
7988 
    iprot.readStructEnd()
7989 
 
7990 
  def write(self, oprot):
7991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7993 
      return
7994 
    oprot.writeStructBegin('getBestDealsCount_args')
7995 
    oprot.writeFieldStop()
7996 
    oprot.writeStructEnd()
7997 
 
7998 
  def validate(self):
7999 
    return
8000 
 
8001 
 
8002 
  def __repr__(self):
8003 
    L = ['%s=%r' % (key, value)
8004 
      for key, value in self.__dict__.iteritems()]
8005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8006 
 
8007 
  def __eq__(self, other):
8008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8009 
 
8010 
  def __ne__(self, other):
8011 
    return not (self == other)
8012 
 
8013 
class getBestDealsCount_result:
8014 
  """
8015 
  Attributes:
8016 
   - success
8017 
   - cex
8018 
  """
8019 
 
8020 
  thrift_spec = (
8021 
    (0, TType.I64, 'success', None, None, ), # 0
8022 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8023 
  )
8024 
 
8025 
  def __init__(self, success=None, cex=None,):
8026 
    self.success = success
8027 
    self.cex = cex
8028 
 
8029 
  def read(self, iprot):
8030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8032 
      return
8033 
    iprot.readStructBegin()
8034 
    while True:
8035 
      (fname, ftype, fid) = iprot.readFieldBegin()
8036 
      if ftype == TType.STOP:
8037 
        break
8038 
      if fid == 0:
8039 
        if ftype == TType.I64:
8040 
          self.success = iprot.readI64();
8041 
        else:
8042 
          iprot.skip(ftype)
8043 
      elif fid == 1:
8044 
        if ftype == TType.STRUCT:
8045 
          self.cex = CatalogServiceException()
8046 
          self.cex.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('getBestDealsCount_result')
8059 
    if self.success is not None:
8060 
      oprot.writeFieldBegin('success', TType.I64, 0)
8061 
      oprot.writeI64(self.success)
8062 
      oprot.writeFieldEnd()
8063 
    if self.cex is not None:
8064 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8065 
      self.cex.write(oprot)
8066 
      oprot.writeFieldEnd()
8067 
    oprot.writeFieldStop()
8068 
    oprot.writeStructEnd()
8069 
 
8070 
  def validate(self):
8071 
    return
8072 
 
8073 
 
8074 
  def __repr__(self):
8075 
    L = ['%s=%r' % (key, value)
8076 
      for key, value in self.__dict__.iteritems()]
8077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8078 
 
8079 
  def __eq__(self, other):
8080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8081 
 
8082 
  def __ne__(self, other):
8083 
    return not (self == other)
8084 
 
8085 
class getComingSoon_args:
8086 
 
8087 
  thrift_spec = (
8088 
  )
8089 
 
8090 
  def read(self, iprot):
8091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8093 
      return
8094 
    iprot.readStructBegin()
8095 
    while True:
8096 
      (fname, ftype, fid) = iprot.readFieldBegin()
8097 
      if ftype == TType.STOP:
8098 
        break
8099 
      else:
8100 
        iprot.skip(ftype)
8101 
      iprot.readFieldEnd()
8102 
    iprot.readStructEnd()
8103 
 
8104 
  def write(self, oprot):
8105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8107 
      return
8108 
    oprot.writeStructBegin('getComingSoon_args')
8109 
    oprot.writeFieldStop()
8110 
    oprot.writeStructEnd()
8111 
 
8112 
  def validate(self):
8113 
    return
8114 
 
8115 
 
8116 
  def __repr__(self):
8117 
    L = ['%s=%r' % (key, value)
8118 
      for key, value in self.__dict__.iteritems()]
8119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8120 
 
8121 
  def __eq__(self, other):
8122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8123 
 
8124 
  def __ne__(self, other):
8125 
    return not (self == other)
8126 
 
8127 
class getComingSoon_result:
8128 
  """
8129 
  Attributes:
8130 
   - success
8131 
   - isex
8132 
  """
8133 
 
8134 
  thrift_spec = (
8135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8136 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8137 
  )
8138 
 
8139 
  def __init__(self, success=None, isex=None,):
8140 
    self.success = success
8141 
    self.isex = isex
8142 
 
8143 
  def read(self, iprot):
8144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8146 
      return
8147 
    iprot.readStructBegin()
8148 
    while True:
8149 
      (fname, ftype, fid) = iprot.readFieldBegin()
8150 
      if ftype == TType.STOP:
8151 
        break
8152 
      if fid == 0:
8153 
        if ftype == TType.LIST:
8154 
          self.success = []
8155 
          (_etype89, _size86) = iprot.readListBegin()
8156 
          for _i90 in xrange(_size86):
8157 
            _elem91 = Item()
8158 
            _elem91.read(iprot)
8159 
            self.success.append(_elem91)
8160 
          iprot.readListEnd()
8161 
        else:
8162 
          iprot.skip(ftype)
8163 
      elif fid == 1:
8164 
        if ftype == TType.STRUCT:
8165 
          self.isex = CatalogServiceException()
8166 
          self.isex.read(iprot)
8167 
        else:
8168 
          iprot.skip(ftype)
8169 
      else:
8170 
        iprot.skip(ftype)
8171 
      iprot.readFieldEnd()
8172 
    iprot.readStructEnd()
8173 
 
8174 
  def write(self, oprot):
8175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8177 
      return
8178 
    oprot.writeStructBegin('getComingSoon_result')
8179 
    if self.success is not None:
8180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 
      for iter92 in self.success:
8183 
        iter92.write(oprot)
8184 
      oprot.writeListEnd()
8185 
      oprot.writeFieldEnd()
8186 
    if self.isex is not None:
8187 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8188 
      self.isex.write(oprot)
8189 
      oprot.writeFieldEnd()
8190 
    oprot.writeFieldStop()
8191 
    oprot.writeStructEnd()
8192 
 
8193 
  def validate(self):
8194 
    return
8195 
 
8196 
 
8197 
  def __repr__(self):
8198 
    L = ['%s=%r' % (key, value)
8199 
      for key, value in self.__dict__.iteritems()]
8200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8201 
 
8202 
  def __eq__(self, other):
8203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8204 
 
8205 
  def __ne__(self, other):
8206 
    return not (self == other)
8207 
 
8208 
class getComingSoonCatalogIds_args:
8209 
  """
8210 
  Attributes:
8211 
   - beginIndex
8212 
   - totalItems
8213 
   - brand
8214 
   - category
8215 
  """
8216 
 
8217 
  thrift_spec = (
8218 
    None, # 0
8219 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8220 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8221 
    (3, TType.STRING, 'brand', None, None, ), # 3
8222 
    (4, TType.I64, 'category', None, None, ), # 4
8223 
  )
8224 
 
8225 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8226 
    self.beginIndex = beginIndex
8227 
    self.totalItems = totalItems
8228 
    self.brand = brand
8229 
    self.category = category
8230 
 
8231 
  def read(self, iprot):
8232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8234 
      return
8235 
    iprot.readStructBegin()
8236 
    while True:
8237 
      (fname, ftype, fid) = iprot.readFieldBegin()
8238 
      if ftype == TType.STOP:
8239 
        break
8240 
      if fid == 1:
8241 
        if ftype == TType.I64:
8242 
          self.beginIndex = iprot.readI64();
8243 
        else:
8244 
          iprot.skip(ftype)
8245 
      elif fid == 2:
8246 
        if ftype == TType.I64:
8247 
          self.totalItems = iprot.readI64();
8248 
        else:
8249 
          iprot.skip(ftype)
8250 
      elif fid == 3:
8251 
        if ftype == TType.STRING:
8252 
          self.brand = iprot.readString();
8253 
        else:
8254 
          iprot.skip(ftype)
8255 
      elif fid == 4:
8256 
        if ftype == TType.I64:
8257 
          self.category = iprot.readI64();
8258 
        else:
8259 
          iprot.skip(ftype)
8260 
      else:
8261 
        iprot.skip(ftype)
8262 
      iprot.readFieldEnd()
8263 
    iprot.readStructEnd()
8264 
 
8265 
  def write(self, oprot):
8266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8268 
      return
8269 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8270 
    if self.beginIndex is not None:
8271 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8272 
      oprot.writeI64(self.beginIndex)
8273 
      oprot.writeFieldEnd()
8274 
    if self.totalItems is not None:
8275 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8276 
      oprot.writeI64(self.totalItems)
8277 
      oprot.writeFieldEnd()
8278 
    if self.brand is not None:
8279 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8280 
      oprot.writeString(self.brand)
8281 
      oprot.writeFieldEnd()
8282 
    if self.category is not None:
8283 
      oprot.writeFieldBegin('category', TType.I64, 4)
8284 
      oprot.writeI64(self.category)
8285 
      oprot.writeFieldEnd()
8286 
    oprot.writeFieldStop()
8287 
    oprot.writeStructEnd()
8288 
 
8289 
  def validate(self):
8290 
    return
8291 
 
8292 
 
8293 
  def __repr__(self):
8294 
    L = ['%s=%r' % (key, value)
8295 
      for key, value in self.__dict__.iteritems()]
8296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8297 
 
8298 
  def __eq__(self, other):
8299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8300 
 
8301 
  def __ne__(self, other):
8302 
    return not (self == other)
8303 
 
8304 
class getComingSoonCatalogIds_result:
8305 
  """
8306 
  Attributes:
8307 
   - success
8308 
   - cex
8309 
  """
8310 
 
8311 
  thrift_spec = (
8312 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8313 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8314 
  )
8315 
 
8316 
  def __init__(self, success=None, cex=None,):
8317 
    self.success = success
8318 
    self.cex = cex
8319 
 
8320 
  def read(self, iprot):
8321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8323 
      return
8324 
    iprot.readStructBegin()
8325 
    while True:
8326 
      (fname, ftype, fid) = iprot.readFieldBegin()
8327 
      if ftype == TType.STOP:
8328 
        break
8329 
      if fid == 0:
8330 
        if ftype == TType.LIST:
8331 
          self.success = []
8332 
          (_etype96, _size93) = iprot.readListBegin()
8333 
          for _i97 in xrange(_size93):
8334 
            _elem98 = iprot.readI64();
8335 
            self.success.append(_elem98)
8336 
          iprot.readListEnd()
8337 
        else:
8338 
          iprot.skip(ftype)
8339 
      elif fid == 1:
8340 
        if ftype == TType.STRUCT:
8341 
          self.cex = CatalogServiceException()
8342 
          self.cex.read(iprot)
8343 
        else:
8344 
          iprot.skip(ftype)
8345 
      else:
8346 
        iprot.skip(ftype)
8347 
      iprot.readFieldEnd()
8348 
    iprot.readStructEnd()
8349 
 
8350 
  def write(self, oprot):
8351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8353 
      return
8354 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8355 
    if self.success is not None:
8356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8357 
      oprot.writeListBegin(TType.I64, len(self.success))
8358 
      for iter99 in self.success:
8359 
        oprot.writeI64(iter99)
8360 
      oprot.writeListEnd()
8361 
      oprot.writeFieldEnd()
8362 
    if self.cex is not None:
8363 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8364 
      self.cex.write(oprot)
8365 
      oprot.writeFieldEnd()
8366 
    oprot.writeFieldStop()
8367 
    oprot.writeStructEnd()
8368 
 
8369 
  def validate(self):
8370 
    return
8371 
 
8372 
 
8373 
  def __repr__(self):
8374 
    L = ['%s=%r' % (key, value)
8375 
      for key, value in self.__dict__.iteritems()]
8376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8377 
 
8378 
  def __eq__(self, other):
8379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8380 
 
8381 
  def __ne__(self, other):
8382 
    return not (self == other)
8383 
 
8384 
class getComingSoonCount_args:
8385 
 
8386 
  thrift_spec = (
8387 
  )
8388 
 
8389 
  def read(self, iprot):
8390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8392 
      return
8393 
    iprot.readStructBegin()
8394 
    while True:
8395 
      (fname, ftype, fid) = iprot.readFieldBegin()
8396 
      if ftype == TType.STOP:
8397 
        break
8398 
      else:
8399 
        iprot.skip(ftype)
8400 
      iprot.readFieldEnd()
8401 
    iprot.readStructEnd()
8402 
 
8403 
  def write(self, oprot):
8404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8406 
      return
8407 
    oprot.writeStructBegin('getComingSoonCount_args')
8408 
    oprot.writeFieldStop()
8409 
    oprot.writeStructEnd()
8410 
 
8411 
  def validate(self):
8412 
    return
8413 
 
8414 
 
8415 
  def __repr__(self):
8416 
    L = ['%s=%r' % (key, value)
8417 
      for key, value in self.__dict__.iteritems()]
8418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8419 
 
8420 
  def __eq__(self, other):
8421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8422 
 
8423 
  def __ne__(self, other):
8424 
    return not (self == other)
8425 
 
8426 
class getComingSoonCount_result:
8427 
  """
8428 
  Attributes:
8429 
   - success
8430 
   - cex
8431 
  """
8432 
 
8433 
  thrift_spec = (
8434 
    (0, TType.I64, 'success', None, None, ), # 0
8435 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8436 
  )
8437 
 
8438 
  def __init__(self, success=None, cex=None,):
8439 
    self.success = success
8440 
    self.cex = cex
8441 
 
8442 
  def read(self, iprot):
8443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8445 
      return
8446 
    iprot.readStructBegin()
8447 
    while True:
8448 
      (fname, ftype, fid) = iprot.readFieldBegin()
8449 
      if ftype == TType.STOP:
8450 
        break
8451 
      if fid == 0:
8452 
        if ftype == TType.I64:
8453 
          self.success = iprot.readI64();
8454 
        else:
8455 
          iprot.skip(ftype)
8456 
      elif fid == 1:
8457 
        if ftype == TType.STRUCT:
8458 
          self.cex = CatalogServiceException()
8459 
          self.cex.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('getComingSoonCount_result')
8472 
    if self.success is not None:
8473 
      oprot.writeFieldBegin('success', TType.I64, 0)
8474 
      oprot.writeI64(self.success)
8475 
      oprot.writeFieldEnd()
8476 
    if self.cex is not None:
8477 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8478 
      self.cex.write(oprot)
8479 
      oprot.writeFieldEnd()
8480 
    oprot.writeFieldStop()
8481 
    oprot.writeStructEnd()
8482 
 
8483 
  def validate(self):
8484 
    return
8485 
 
8486 
 
8487 
  def __repr__(self):
8488 
    L = ['%s=%r' % (key, value)
8489 
      for key, value in self.__dict__.iteritems()]
8490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8491 
 
8492 
  def __eq__(self, other):
8493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8494 
 
8495 
  def __ne__(self, other):
8496 
    return not (self == other)
8497 
 
8498 
class getLatestArrivals_args:
8499 
 
8500 
  thrift_spec = (
8501 
  )
8502 
 
8503 
  def read(self, iprot):
8504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8506 
      return
8507 
    iprot.readStructBegin()
8508 
    while True:
8509 
      (fname, ftype, fid) = iprot.readFieldBegin()
8510 
      if ftype == TType.STOP:
8511 
        break
8512 
      else:
8513 
        iprot.skip(ftype)
8514 
      iprot.readFieldEnd()
8515 
    iprot.readStructEnd()
8516 
 
8517 
  def write(self, oprot):
8518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8520 
      return
8521 
    oprot.writeStructBegin('getLatestArrivals_args')
8522 
    oprot.writeFieldStop()
8523 
    oprot.writeStructEnd()
8524 
 
8525 
  def validate(self):
8526 
    return
8527 
 
8528 
 
8529 
  def __repr__(self):
8530 
    L = ['%s=%r' % (key, value)
8531 
      for key, value in self.__dict__.iteritems()]
8532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8533 
 
8534 
  def __eq__(self, other):
8535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8536 
 
8537 
  def __ne__(self, other):
8538 
    return not (self == other)
8539 
 
8540 
class getLatestArrivals_result:
8541 
  """
8542 
  Attributes:
8543 
   - success
8544 
   - isex
8545 
  """
8546 
 
8547 
  thrift_spec = (
8548 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8549 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8550 
  )
8551 
 
8552 
  def __init__(self, success=None, isex=None,):
8553 
    self.success = success
8554 
    self.isex = isex
8555 
 
8556 
  def read(self, iprot):
8557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8559 
      return
8560 
    iprot.readStructBegin()
8561 
    while True:
8562 
      (fname, ftype, fid) = iprot.readFieldBegin()
8563 
      if ftype == TType.STOP:
8564 
        break
8565 
      if fid == 0:
8566 
        if ftype == TType.LIST:
8567 
          self.success = []
8568 
          (_etype103, _size100) = iprot.readListBegin()
8569 
          for _i104 in xrange(_size100):
8570 
            _elem105 = Item()
8571 
            _elem105.read(iprot)
8572 
            self.success.append(_elem105)
8573 
          iprot.readListEnd()
8574 
        else:
8575 
          iprot.skip(ftype)
8576 
      elif fid == 1:
8577 
        if ftype == TType.STRUCT:
8578 
          self.isex = CatalogServiceException()
8579 
          self.isex.read(iprot)
8580 
        else:
8581 
          iprot.skip(ftype)
8582 
      else:
8583 
        iprot.skip(ftype)
8584 
      iprot.readFieldEnd()
8585 
    iprot.readStructEnd()
8586 
 
8587 
  def write(self, oprot):
8588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8590 
      return
8591 
    oprot.writeStructBegin('getLatestArrivals_result')
8592 
    if self.success is not None:
8593 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8594 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8595 
      for iter106 in self.success:
8596 
        iter106.write(oprot)
8597 
      oprot.writeListEnd()
8598 
      oprot.writeFieldEnd()
8599 
    if self.isex is not None:
8600 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8601 
      self.isex.write(oprot)
8602 
      oprot.writeFieldEnd()
8603 
    oprot.writeFieldStop()
8604 
    oprot.writeStructEnd()
8605 
 
8606 
  def validate(self):
8607 
    return
8608 
 
8609 
 
8610 
  def __repr__(self):
8611 
    L = ['%s=%r' % (key, value)
8612 
      for key, value in self.__dict__.iteritems()]
8613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8614 
 
8615 
  def __eq__(self, other):
8616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8617 
 
8618 
  def __ne__(self, other):
8619 
    return not (self == other)
8620 
 
8621 
class getLatestArrivalsCatalogIds_args:
8622 
  """
8623 
  Attributes:
8624 
   - beginIndex
8625 
   - totalItems
8626 
   - brand
8627 
   - categories
8628 
  """
8629 
 
8630 
  thrift_spec = (
8631 
    None, # 0
8632 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8633 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8634 
    (3, TType.STRING, 'brand', None, None, ), # 3
8635 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8636 
  )
8637 
 
8638 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8639 
    self.beginIndex = beginIndex
8640 
    self.totalItems = totalItems
8641 
    self.brand = brand
8642 
    self.categories = categories
8643 
 
8644 
  def read(self, iprot):
8645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8647 
      return
8648 
    iprot.readStructBegin()
8649 
    while True:
8650 
      (fname, ftype, fid) = iprot.readFieldBegin()
8651 
      if ftype == TType.STOP:
8652 
        break
8653 
      if fid == 1:
8654 
        if ftype == TType.I64:
8655 
          self.beginIndex = iprot.readI64();
8656 
        else:
8657 
          iprot.skip(ftype)
8658 
      elif fid == 2:
8659 
        if ftype == TType.I64:
8660 
          self.totalItems = iprot.readI64();
8661 
        else:
8662 
          iprot.skip(ftype)
8663 
      elif fid == 3:
8664 
        if ftype == TType.STRING:
8665 
          self.brand = iprot.readString();
8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      elif fid == 4:
8669 
        if ftype == TType.LIST:
8670 
          self.categories = []
8671 
          (_etype110, _size107) = iprot.readListBegin()
8672 
          for _i111 in xrange(_size107):
8673 
            _elem112 = iprot.readI64();
8674 
            self.categories.append(_elem112)
8675 
          iprot.readListEnd()
8676 
        else:
8677 
          iprot.skip(ftype)
8678 
      else:
8679 
        iprot.skip(ftype)
8680 
      iprot.readFieldEnd()
8681 
    iprot.readStructEnd()
8682 
 
8683 
  def write(self, oprot):
8684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8686 
      return
8687 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8688 
    if self.beginIndex is not None:
8689 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8690 
      oprot.writeI64(self.beginIndex)
8691 
      oprot.writeFieldEnd()
8692 
    if self.totalItems is not None:
8693 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8694 
      oprot.writeI64(self.totalItems)
8695 
      oprot.writeFieldEnd()
8696 
    if self.brand is not None:
8697 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8698 
      oprot.writeString(self.brand)
8699 
      oprot.writeFieldEnd()
8700 
    if self.categories is not None:
8701 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8702 
      oprot.writeListBegin(TType.I64, len(self.categories))
8703 
      for iter113 in self.categories:
8704 
        oprot.writeI64(iter113)
8705 
      oprot.writeListEnd()
8706 
      oprot.writeFieldEnd()
8707 
    oprot.writeFieldStop()
8708 
    oprot.writeStructEnd()
8709 
 
8710 
  def validate(self):
8711 
    return
8712 
 
8713 
 
8714 
  def __repr__(self):
8715 
    L = ['%s=%r' % (key, value)
8716 
      for key, value in self.__dict__.iteritems()]
8717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8718 
 
8719 
  def __eq__(self, other):
8720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8721 
 
8722 
  def __ne__(self, other):
8723 
    return not (self == other)
8724 
 
8725 
class getLatestArrivalsCatalogIds_result:
8726 
  """
8727 
  Attributes:
8728 
   - success
8729 
   - cex
8730 
  """
8731 
 
8732 
  thrift_spec = (
8733 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8734 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8735 
  )
8736 
 
8737 
  def __init__(self, success=None, cex=None,):
8738 
    self.success = success
8739 
    self.cex = cex
8740 
 
8741 
  def read(self, iprot):
8742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8744 
      return
8745 
    iprot.readStructBegin()
8746 
    while True:
8747 
      (fname, ftype, fid) = iprot.readFieldBegin()
8748 
      if ftype == TType.STOP:
8749 
        break
8750 
      if fid == 0:
8751 
        if ftype == TType.LIST:
8752 
          self.success = []
8753 
          (_etype117, _size114) = iprot.readListBegin()
8754 
          for _i118 in xrange(_size114):
8755 
            _elem119 = iprot.readI64();
8756 
            self.success.append(_elem119)
8757 
          iprot.readListEnd()
8758 
        else:
8759 
          iprot.skip(ftype)
8760 
      elif fid == 1:
8761 
        if ftype == TType.STRUCT:
8762 
          self.cex = CatalogServiceException()
8763 
          self.cex.read(iprot)
8764 
        else:
8765 
          iprot.skip(ftype)
8766 
      else:
8767 
        iprot.skip(ftype)
8768 
      iprot.readFieldEnd()
8769 
    iprot.readStructEnd()
8770 
 
8771 
  def write(self, oprot):
8772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8774 
      return
8775 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8776 
    if self.success is not None:
8777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8778 
      oprot.writeListBegin(TType.I64, len(self.success))
8779 
      for iter120 in self.success:
8780 
        oprot.writeI64(iter120)
8781 
      oprot.writeListEnd()
8782 
      oprot.writeFieldEnd()
8783 
    if self.cex is not None:
8784 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8785 
      self.cex.write(oprot)
8786 
      oprot.writeFieldEnd()
8787 
    oprot.writeFieldStop()
8788 
    oprot.writeStructEnd()
8789 
 
8790 
  def validate(self):
8791 
    return
8792 
 
8793 
 
8794 
  def __repr__(self):
8795 
    L = ['%s=%r' % (key, value)
8796 
      for key, value in self.__dict__.iteritems()]
8797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8798 
 
8799 
  def __eq__(self, other):
8800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8801 
 
8802 
  def __ne__(self, other):
8803 
    return not (self == other)
8804 
 
8805 
class getLatestArrivalsCount_args:
8806 
 
8807 
  thrift_spec = (
8808 
  )
8809 
 
8810 
  def read(self, iprot):
8811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8813 
      return
8814 
    iprot.readStructBegin()
8815 
    while True:
8816 
      (fname, ftype, fid) = iprot.readFieldBegin()
8817 
      if ftype == TType.STOP:
8818 
        break
8819 
      else:
8820 
        iprot.skip(ftype)
8821 
      iprot.readFieldEnd()
8822 
    iprot.readStructEnd()
8823 
 
8824 
  def write(self, oprot):
8825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8827 
      return
8828 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8829 
    oprot.writeFieldStop()
8830 
    oprot.writeStructEnd()
8831 
 
8832 
  def validate(self):
8833 
    return
8834 
 
8835 
 
8836 
  def __repr__(self):
8837 
    L = ['%s=%r' % (key, value)
8838 
      for key, value in self.__dict__.iteritems()]
8839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8840 
 
8841 
  def __eq__(self, other):
8842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8843 
 
8844 
  def __ne__(self, other):
8845 
    return not (self == other)
8846 
 
8847 
class getLatestArrivalsCount_result:
8848 
  """
8849 
  Attributes:
8850 
   - success
8851 
   - cex
8852 
  """
8853 
 
8854 
  thrift_spec = (
8855 
    (0, TType.I64, 'success', None, None, ), # 0
8856 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8857 
  )
8858 
 
8859 
  def __init__(self, success=None, cex=None,):
8860 
    self.success = success
8861 
    self.cex = cex
8862 
 
8863 
  def read(self, iprot):
8864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8866 
      return
8867 
    iprot.readStructBegin()
8868 
    while True:
8869 
      (fname, ftype, fid) = iprot.readFieldBegin()
8870 
      if ftype == TType.STOP:
8871 
        break
8872 
      if fid == 0:
8873 
        if ftype == TType.I64:
8874 
          self.success = iprot.readI64();
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      elif fid == 1:
8878 
        if ftype == TType.STRUCT:
8879 
          self.cex = CatalogServiceException()
8880 
          self.cex.read(iprot)
8881 
        else:
8882 
          iprot.skip(ftype)
8883 
      else:
8884 
        iprot.skip(ftype)
8885 
      iprot.readFieldEnd()
8886 
    iprot.readStructEnd()
8887 
 
8888 
  def write(self, oprot):
8889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8891 
      return
8892 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8893 
    if self.success is not None:
8894 
      oprot.writeFieldBegin('success', TType.I64, 0)
8895 
      oprot.writeI64(self.success)
8896 
      oprot.writeFieldEnd()
8897 
    if self.cex is not None:
8898 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8899 
      self.cex.write(oprot)
8900 
      oprot.writeFieldEnd()
8901 
    oprot.writeFieldStop()
8902 
    oprot.writeStructEnd()
8903 
 
8904 
  def validate(self):
8905 
    return
8906 
 
8907 
 
8908 
  def __repr__(self):
8909 
    L = ['%s=%r' % (key, value)
8910 
      for key, value in self.__dict__.iteritems()]
8911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8912 
 
8913 
  def __eq__(self, other):
8914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8915 
 
8916 
  def __ne__(self, other):
8917 
    return not (self == other)
8918 
 
8919 
class generateNewEntityID_args:
8920 
 
8921 
  thrift_spec = (
8922 
  )
8923 
 
8924 
  def read(self, iprot):
8925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8927 
      return
8928 
    iprot.readStructBegin()
8929 
    while True:
8930 
      (fname, ftype, fid) = iprot.readFieldBegin()
8931 
      if ftype == TType.STOP:
8932 
        break
8933 
      else:
8934 
        iprot.skip(ftype)
8935 
      iprot.readFieldEnd()
8936 
    iprot.readStructEnd()
8937 
 
8938 
  def write(self, oprot):
8939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8941 
      return
8942 
    oprot.writeStructBegin('generateNewEntityID_args')
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 generateNewEntityID_result:
8962 
  """
8963 
  Attributes:
8964 
   - success
8965 
  """
8966 
 
8967 
  thrift_spec = (
8968 
    (0, TType.I64, '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.I64:
8985 
          self.success = iprot.readI64();
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('generateNewEntityID_result')
8998 
    if self.success is not None:
8999 
      oprot.writeFieldBegin('success', TType.I64, 0)
9000 
      oprot.writeI64(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 addCategory_args:
9021 
  """
9022 
  Attributes:
9023 
   - category
9024 
  """
9025 
 
9026 
  thrift_spec = (
9027 
    None, # 0
9028 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9029 
  )
9030 
 
9031 
  def __init__(self, category=None,):
9032 
    self.category = category
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.STRUCT:
9045 
          self.category = Category()
9046 
          self.category.read(iprot)
9047 
        else:
9048 
          iprot.skip(ftype)
9049 
      else:
9050 
        iprot.skip(ftype)
9051 
      iprot.readFieldEnd()
9052 
    iprot.readStructEnd()
9053 
 
9054 
  def write(self, oprot):
9055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9057 
      return
9058 
    oprot.writeStructBegin('addCategory_args')
9059 
    if self.category is not None:
9060 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9061 
      self.category.write(oprot)
9062 
      oprot.writeFieldEnd()
9063 
    oprot.writeFieldStop()
9064 
    oprot.writeStructEnd()
9065 
 
9066 
  def validate(self):
9067 
    return
9068 
 
9069 
 
9070 
  def __repr__(self):
9071 
    L = ['%s=%r' % (key, value)
9072 
      for key, value in self.__dict__.iteritems()]
9073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9074 
 
9075 
  def __eq__(self, other):
9076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9077 
 
9078 
  def __ne__(self, other):
9079 
    return not (self == other)
9080 
 
9081 
class addCategory_result:
9082 
  """
9083 
  Attributes:
9084 
   - success
9085 
  """
9086 
 
9087 
  thrift_spec = (
9088 
    (0, TType.BOOL, 'success', None, None, ), # 0
9089 
  )
9090 
 
9091 
  def __init__(self, success=None,):
9092 
    self.success = success
9093 
 
9094 
  def read(self, iprot):
9095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9097 
      return
9098 
    iprot.readStructBegin()
9099 
    while True:
9100 
      (fname, ftype, fid) = iprot.readFieldBegin()
9101 
      if ftype == TType.STOP:
9102 
        break
9103 
      if fid == 0:
9104 
        if ftype == TType.BOOL:
9105 
          self.success = iprot.readBool();
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('addCategory_result')
9118 
    if self.success is not None:
9119 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9120 
      oprot.writeBool(self.success)
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 getCategory_args:
9141 
  """
9142 
  Attributes:
9143 
   - id
9144 
  """
9145 
 
9146 
  thrift_spec = (
9147 
    None, # 0
9148 
    (1, TType.I64, 'id', None, None, ), # 1
9149 
  )
9150 
 
9151 
  def __init__(self, id=None,):
9152 
    self.id = id
9153 
 
9154 
  def read(self, iprot):
9155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9157 
      return
9158 
    iprot.readStructBegin()
9159 
    while True:
9160 
      (fname, ftype, fid) = iprot.readFieldBegin()
9161 
      if ftype == TType.STOP:
9162 
        break
9163 
      if fid == 1:
9164 
        if ftype == TType.I64:
9165 
          self.id = iprot.readI64();
9166 
        else:
9167 
          iprot.skip(ftype)
9168 
      else:
9169 
        iprot.skip(ftype)
9170 
      iprot.readFieldEnd()
9171 
    iprot.readStructEnd()
9172 
 
9173 
  def write(self, oprot):
9174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9176 
      return
9177 
    oprot.writeStructBegin('getCategory_args')
9178 
    if self.id is not None:
9179 
      oprot.writeFieldBegin('id', TType.I64, 1)
9180 
      oprot.writeI64(self.id)
9181 
      oprot.writeFieldEnd()
9182 
    oprot.writeFieldStop()
9183 
    oprot.writeStructEnd()
9184 
 
9185 
  def validate(self):
9186 
    return
9187 
 
9188 
 
9189 
  def __repr__(self):
9190 
    L = ['%s=%r' % (key, value)
9191 
      for key, value in self.__dict__.iteritems()]
9192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9193 
 
9194 
  def __eq__(self, other):
9195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9196 
 
9197 
  def __ne__(self, other):
9198 
    return not (self == other)
9199 
 
9200 
class getCategory_result:
9201 
  """
9202 
  Attributes:
9203 
   - success
9204 
  """
9205 
 
9206 
  thrift_spec = (
9207 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9208 
  )
9209 
 
9210 
  def __init__(self, success=None,):
9211 
    self.success = success
9212 
 
9213 
  def read(self, iprot):
9214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9216 
      return
9217 
    iprot.readStructBegin()
9218 
    while True:
9219 
      (fname, ftype, fid) = iprot.readFieldBegin()
9220 
      if ftype == TType.STOP:
9221 
        break
9222 
      if fid == 0:
9223 
        if ftype == TType.STRUCT:
9224 
          self.success = Category()
9225 
          self.success.read(iprot)
9226 
        else:
9227 
          iprot.skip(ftype)
9228 
      else:
9229 
        iprot.skip(ftype)
9230 
      iprot.readFieldEnd()
9231 
    iprot.readStructEnd()
9232 
 
9233 
  def write(self, oprot):
9234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9236 
      return
9237 
    oprot.writeStructBegin('getCategory_result')
9238 
    if self.success is not None:
9239 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9240 
      self.success.write(oprot)
9241 
      oprot.writeFieldEnd()
9242 
    oprot.writeFieldStop()
9243 
    oprot.writeStructEnd()
9244 
 
9245 
  def validate(self):
9246 
    return
9247 
 
9248 
 
9249 
  def __repr__(self):
9250 
    L = ['%s=%r' % (key, value)
9251 
      for key, value in self.__dict__.iteritems()]
9252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9253 
 
9254 
  def __eq__(self, other):
9255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9256 
 
9257 
  def __ne__(self, other):
9258 
    return not (self == other)
9259 
 
9260 
class getAllCategories_args:
9261 
 
9262 
  thrift_spec = (
9263 
  )
9264 
 
9265 
  def read(self, iprot):
9266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9268 
      return
9269 
    iprot.readStructBegin()
9270 
    while True:
9271 
      (fname, ftype, fid) = iprot.readFieldBegin()
9272 
      if ftype == TType.STOP:
9273 
        break
9274 
      else:
9275 
        iprot.skip(ftype)
9276 
      iprot.readFieldEnd()
9277 
    iprot.readStructEnd()
9278 
 
9279 
  def write(self, oprot):
9280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9282 
      return
9283 
    oprot.writeStructBegin('getAllCategories_args')
9284 
    oprot.writeFieldStop()
9285 
    oprot.writeStructEnd()
9286 
 
9287 
  def validate(self):
9288 
    return
9289 
 
9290 
 
9291 
  def __repr__(self):
9292 
    L = ['%s=%r' % (key, value)
9293 
      for key, value in self.__dict__.iteritems()]
9294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9295 
 
9296 
  def __eq__(self, other):
9297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9298 
 
9299 
  def __ne__(self, other):
9300 
    return not (self == other)
9301 
 
9302 
class getAllCategories_result:
9303 
  """
9304 
  Attributes:
9305 
   - success
9306 
  """
9307 
 
9308 
  thrift_spec = (
9309 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9310 
  )
9311 
 
9312 
  def __init__(self, success=None,):
9313 
    self.success = success
9314 
 
9315 
  def read(self, iprot):
9316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9318 
      return
9319 
    iprot.readStructBegin()
9320 
    while True:
9321 
      (fname, ftype, fid) = iprot.readFieldBegin()
9322 
      if ftype == TType.STOP:
9323 
        break
9324 
      if fid == 0:
9325 
        if ftype == TType.LIST:
9326 
          self.success = []
9327 
          (_etype124, _size121) = iprot.readListBegin()
9328 
          for _i125 in xrange(_size121):
9329 
            _elem126 = Category()
9330 
            _elem126.read(iprot)
9331 
            self.success.append(_elem126)
9332 
          iprot.readListEnd()
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      else:
9336 
        iprot.skip(ftype)
9337 
      iprot.readFieldEnd()
9338 
    iprot.readStructEnd()
9339 
 
9340 
  def write(self, oprot):
9341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9343 
      return
9344 
    oprot.writeStructBegin('getAllCategories_result')
9345 
    if self.success is not None:
9346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9347 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9348 
      for iter127 in self.success:
9349 
        iter127.write(oprot)
9350 
      oprot.writeListEnd()
9351 
      oprot.writeFieldEnd()
9352 
    oprot.writeFieldStop()
9353 
    oprot.writeStructEnd()
9354 
 
9355 
  def validate(self):
9356 
    return
9357 
 
9358 
 
9359 
  def __repr__(self):
9360 
    L = ['%s=%r' % (key, value)
9361 
      for key, value in self.__dict__.iteritems()]
9362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9363 
 
9364 
  def __eq__(self, other):
9365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9366 
 
9367 
  def __ne__(self, other):
9368 
    return not (self == other)
9369 
 
9370 
class getAllSimilarItems_args:
9371 
  """
9372 
  Attributes:
9373 
   - itemId
9374 
  """
9375 
 
9376 
  thrift_spec = (
9377 
    None, # 0
9378 
    (1, TType.I64, 'itemId', None, None, ), # 1
9379 
  )
9380 
 
9381 
  def __init__(self, itemId=None,):
9382 
    self.itemId = itemId
9383 
 
9384 
  def read(self, iprot):
9385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9387 
      return
9388 
    iprot.readStructBegin()
9389 
    while True:
9390 
      (fname, ftype, fid) = iprot.readFieldBegin()
9391 
      if ftype == TType.STOP:
9392 
        break
9393 
      if fid == 1:
9394 
        if ftype == TType.I64:
9395 
          self.itemId = iprot.readI64();
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      else:
9399 
        iprot.skip(ftype)
9400 
      iprot.readFieldEnd()
9401 
    iprot.readStructEnd()
9402 
 
9403 
  def write(self, oprot):
9404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9406 
      return
9407 
    oprot.writeStructBegin('getAllSimilarItems_args')
9408 
    if self.itemId is not None:
9409 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9410 
      oprot.writeI64(self.itemId)
9411 
      oprot.writeFieldEnd()
9412 
    oprot.writeFieldStop()
9413 
    oprot.writeStructEnd()
9414 
 
9415 
  def validate(self):
9416 
    return
9417 
 
9418 
 
9419 
  def __repr__(self):
9420 
    L = ['%s=%r' % (key, value)
9421 
      for key, value in self.__dict__.iteritems()]
9422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9423 
 
9424 
  def __eq__(self, other):
9425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9426 
 
9427 
  def __ne__(self, other):
9428 
    return not (self == other)
9429 
 
9430 
class getAllSimilarItems_result:
9431 
  """
9432 
  Attributes:
9433 
   - success
9434 
  """
9435 
 
9436 
  thrift_spec = (
9437 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9438 
  )
9439 
 
9440 
  def __init__(self, success=None,):
9441 
    self.success = success
9442 
 
9443 
  def read(self, iprot):
9444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9446 
      return
9447 
    iprot.readStructBegin()
9448 
    while True:
9449 
      (fname, ftype, fid) = iprot.readFieldBegin()
9450 
      if ftype == TType.STOP:
9451 
        break
9452 
      if fid == 0:
9453 
        if ftype == TType.LIST:
9454 
          self.success = []
9455 
          (_etype131, _size128) = iprot.readListBegin()
9456 
          for _i132 in xrange(_size128):
9457 
            _elem133 = Item()
9458 
            _elem133.read(iprot)
9459 
            self.success.append(_elem133)
9460 
          iprot.readListEnd()
9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      else:
9464 
        iprot.skip(ftype)
9465 
      iprot.readFieldEnd()
9466 
    iprot.readStructEnd()
9467 
 
9468 
  def write(self, oprot):
9469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9471 
      return
9472 
    oprot.writeStructBegin('getAllSimilarItems_result')
9473 
    if self.success is not None:
9474 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9475 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9476 
      for iter134 in self.success:
9477 
        iter134.write(oprot)
9478 
      oprot.writeListEnd()
9479 
      oprot.writeFieldEnd()
9480 
    oprot.writeFieldStop()
9481 
    oprot.writeStructEnd()
9482 
 
9483 
  def validate(self):
9484 
    return
9485 
 
9486 
 
9487 
  def __repr__(self):
9488 
    L = ['%s=%r' % (key, value)
9489 
      for key, value in self.__dict__.iteritems()]
9490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9491 
 
9492 
  def __eq__(self, other):
9493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9494 
 
9495 
  def __ne__(self, other):
9496 
    return not (self == other)
9497 
 
9498 
class addSimilarItem_args:
9499 
  """
9500 
  Attributes:
9501 
   - itemId
9502 
   - catalogItemId
9503 
  """
9504 
 
9505 
  thrift_spec = (
9506 
    None, # 0
9507 
    (1, TType.I64, 'itemId', None, None, ), # 1
9508 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9509 
  )
9510 
 
9511 
  def __init__(self, itemId=None, catalogItemId=None,):
9512 
    self.itemId = itemId
9513 
    self.catalogItemId = catalogItemId
9514 
 
9515 
  def read(self, iprot):
9516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9518 
      return
9519 
    iprot.readStructBegin()
9520 
    while True:
9521 
      (fname, ftype, fid) = iprot.readFieldBegin()
9522 
      if ftype == TType.STOP:
9523 
        break
9524 
      if fid == 1:
9525 
        if ftype == TType.I64:
9526 
          self.itemId = iprot.readI64();
9527 
        else:
9528 
          iprot.skip(ftype)
9529 
      elif fid == 2:
9530 
        if ftype == TType.I64:
9531 
          self.catalogItemId = iprot.readI64();
9532 
        else:
9533 
          iprot.skip(ftype)
9534 
      else:
9535 
        iprot.skip(ftype)
9536 
      iprot.readFieldEnd()
9537 
    iprot.readStructEnd()
9538 
 
9539 
  def write(self, oprot):
9540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9542 
      return
9543 
    oprot.writeStructBegin('addSimilarItem_args')
9544 
    if self.itemId is not None:
9545 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9546 
      oprot.writeI64(self.itemId)
9547 
      oprot.writeFieldEnd()
9548 
    if self.catalogItemId is not None:
9549 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9550 
      oprot.writeI64(self.catalogItemId)
9551 
      oprot.writeFieldEnd()
9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
9555 
  def validate(self):
9556 
    return
9557 
 
9558 
 
9559 
  def __repr__(self):
9560 
    L = ['%s=%r' % (key, value)
9561 
      for key, value in self.__dict__.iteritems()]
9562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9563 
 
9564 
  def __eq__(self, other):
9565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9566 
 
9567 
  def __ne__(self, other):
9568 
    return not (self == other)
9569 
 
9570 
class addSimilarItem_result:
9571 
  """
9572 
  Attributes:
9573 
   - success
9574 
   - cex
9575 
  """
9576 
 
9577 
  thrift_spec = (
9578 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9579 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9580 
  )
9581 
 
9582 
  def __init__(self, success=None, cex=None,):
9583 
    self.success = success
9584 
    self.cex = cex
9585 
 
9586 
  def read(self, iprot):
9587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9589 
      return
9590 
    iprot.readStructBegin()
9591 
    while True:
9592 
      (fname, ftype, fid) = iprot.readFieldBegin()
9593 
      if ftype == TType.STOP:
9594 
        break
9595 
      if fid == 0:
9596 
        if ftype == TType.STRUCT:
9597 
          self.success = Item()
9598 
          self.success.read(iprot)
9599 
        else:
9600 
          iprot.skip(ftype)
9601 
      elif fid == 1:
9602 
        if ftype == TType.STRUCT:
9603 
          self.cex = CatalogServiceException()
9604 
          self.cex.read(iprot)
9605 
        else:
9606 
          iprot.skip(ftype)
9607 
      else:
9608 
        iprot.skip(ftype)
9609 
      iprot.readFieldEnd()
9610 
    iprot.readStructEnd()
9611 
 
9612 
  def write(self, oprot):
9613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9615 
      return
9616 
    oprot.writeStructBegin('addSimilarItem_result')
9617 
    if self.success is not None:
9618 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9619 
      self.success.write(oprot)
9620 
      oprot.writeFieldEnd()
9621 
    if self.cex is not None:
9622 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9623 
      self.cex.write(oprot)
9624 
      oprot.writeFieldEnd()
9625 
    oprot.writeFieldStop()
9626 
    oprot.writeStructEnd()
9627 
 
9628 
  def validate(self):
9629 
    return
9630 
 
9631 
 
9632 
  def __repr__(self):
9633 
    L = ['%s=%r' % (key, value)
9634 
      for key, value in self.__dict__.iteritems()]
9635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9636 
 
9637 
  def __eq__(self, other):
9638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9639 
 
9640 
  def __ne__(self, other):
9641 
    return not (self == other)
9642 
 
6512 kshitij.so 9643 
class addTag_args:
9644 
  """
9645 
  Attributes:
9646 
   - displayName
9647 
   - itemId
9648 
  """
9649 
 
9650 
  thrift_spec = (
9651 
    None, # 0
9652 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9653 
    (2, TType.I64, 'itemId', None, None, ), # 2
9654 
  )
9655 
 
9656 
  def __init__(self, displayName=None, itemId=None,):
9657 
    self.displayName = displayName
9658 
    self.itemId = itemId
9659 
 
9660 
  def read(self, iprot):
9661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9663 
      return
9664 
    iprot.readStructBegin()
9665 
    while True:
9666 
      (fname, ftype, fid) = iprot.readFieldBegin()
9667 
      if ftype == TType.STOP:
9668 
        break
9669 
      if fid == 1:
9670 
        if ftype == TType.STRING:
9671 
          self.displayName = iprot.readString();
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      elif fid == 2:
9675 
        if ftype == TType.I64:
9676 
          self.itemId = iprot.readI64();
9677 
        else:
9678 
          iprot.skip(ftype)
9679 
      else:
9680 
        iprot.skip(ftype)
9681 
      iprot.readFieldEnd()
9682 
    iprot.readStructEnd()
9683 
 
9684 
  def write(self, oprot):
9685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9687 
      return
9688 
    oprot.writeStructBegin('addTag_args')
9689 
    if self.displayName is not None:
9690 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9691 
      oprot.writeString(self.displayName)
9692 
      oprot.writeFieldEnd()
9693 
    if self.itemId is not None:
9694 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9695 
      oprot.writeI64(self.itemId)
9696 
      oprot.writeFieldEnd()
9697 
    oprot.writeFieldStop()
9698 
    oprot.writeStructEnd()
9699 
 
9700 
  def validate(self):
9701 
    return
9702 
 
9703 
 
9704 
  def __repr__(self):
9705 
    L = ['%s=%r' % (key, value)
9706 
      for key, value in self.__dict__.iteritems()]
9707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9708 
 
9709 
  def __eq__(self, other):
9710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9711 
 
9712 
  def __ne__(self, other):
9713 
    return not (self == other)
9714 
 
9715 
class addTag_result:
9716 
  """
9717 
  Attributes:
9718 
   - success
9719 
  """
9720 
 
9721 
  thrift_spec = (
9722 
    (0, TType.BOOL, 'success', None, None, ), # 0
9723 
  )
9724 
 
9725 
  def __init__(self, success=None,):
9726 
    self.success = success
9727 
 
9728 
  def read(self, iprot):
9729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9731 
      return
9732 
    iprot.readStructBegin()
9733 
    while True:
9734 
      (fname, ftype, fid) = iprot.readFieldBegin()
9735 
      if ftype == TType.STOP:
9736 
        break
9737 
      if fid == 0:
9738 
        if ftype == TType.BOOL:
9739 
          self.success = iprot.readBool();
9740 
        else:
9741 
          iprot.skip(ftype)
9742 
      else:
9743 
        iprot.skip(ftype)
9744 
      iprot.readFieldEnd()
9745 
    iprot.readStructEnd()
9746 
 
9747 
  def write(self, oprot):
9748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9750 
      return
9751 
    oprot.writeStructBegin('addTag_result')
9752 
    if self.success is not None:
9753 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9754 
      oprot.writeBool(self.success)
9755 
      oprot.writeFieldEnd()
9756 
    oprot.writeFieldStop()
9757 
    oprot.writeStructEnd()
9758 
 
9759 
  def validate(self):
9760 
    return
9761 
 
9762 
 
9763 
  def __repr__(self):
9764 
    L = ['%s=%r' % (key, value)
9765 
      for key, value in self.__dict__.iteritems()]
9766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9767 
 
9768 
  def __eq__(self, other):
9769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9770 
 
9771 
  def __ne__(self, other):
9772 
    return not (self == other)
9773 
 
9774 
class deleteEntityTag_args:
9775 
  """
9776 
  Attributes:
9777 
   - displayName
9778 
   - itemId
9779 
  """
9780 
 
9781 
  thrift_spec = (
9782 
    None, # 0
9783 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9784 
    (2, TType.I64, 'itemId', None, None, ), # 2
9785 
  )
9786 
 
9787 
  def __init__(self, displayName=None, itemId=None,):
9788 
    self.displayName = displayName
9789 
    self.itemId = itemId
9790 
 
9791 
  def read(self, iprot):
9792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9794 
      return
9795 
    iprot.readStructBegin()
9796 
    while True:
9797 
      (fname, ftype, fid) = iprot.readFieldBegin()
9798 
      if ftype == TType.STOP:
9799 
        break
9800 
      if fid == 1:
9801 
        if ftype == TType.STRING:
9802 
          self.displayName = iprot.readString();
9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      elif fid == 2:
9806 
        if ftype == TType.I64:
9807 
          self.itemId = iprot.readI64();
9808 
        else:
9809 
          iprot.skip(ftype)
9810 
      else:
9811 
        iprot.skip(ftype)
9812 
      iprot.readFieldEnd()
9813 
    iprot.readStructEnd()
9814 
 
9815 
  def write(self, oprot):
9816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9818 
      return
9819 
    oprot.writeStructBegin('deleteEntityTag_args')
9820 
    if self.displayName is not None:
9821 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9822 
      oprot.writeString(self.displayName)
9823 
      oprot.writeFieldEnd()
9824 
    if self.itemId is not None:
9825 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9826 
      oprot.writeI64(self.itemId)
9827 
      oprot.writeFieldEnd()
9828 
    oprot.writeFieldStop()
9829 
    oprot.writeStructEnd()
9830 
 
9831 
  def validate(self):
9832 
    return
9833 
 
9834 
 
9835 
  def __repr__(self):
9836 
    L = ['%s=%r' % (key, value)
9837 
      for key, value in self.__dict__.iteritems()]
9838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9839 
 
9840 
  def __eq__(self, other):
9841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9842 
 
9843 
  def __ne__(self, other):
9844 
    return not (self == other)
9845 
 
9846 
class deleteEntityTag_result:
9847 
  """
9848 
  Attributes:
9849 
   - success
9850 
  """
9851 
 
9852 
  thrift_spec = (
9853 
    (0, TType.BOOL, 'success', None, None, ), # 0
9854 
  )
9855 
 
9856 
  def __init__(self, success=None,):
9857 
    self.success = success
9858 
 
9859 
  def read(self, iprot):
9860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9862 
      return
9863 
    iprot.readStructBegin()
9864 
    while True:
9865 
      (fname, ftype, fid) = iprot.readFieldBegin()
9866 
      if ftype == TType.STOP:
9867 
        break
9868 
      if fid == 0:
9869 
        if ftype == TType.BOOL:
9870 
          self.success = iprot.readBool();
9871 
        else:
9872 
          iprot.skip(ftype)
9873 
      else:
9874 
        iprot.skip(ftype)
9875 
      iprot.readFieldEnd()
9876 
    iprot.readStructEnd()
9877 
 
9878 
  def write(self, oprot):
9879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9881 
      return
9882 
    oprot.writeStructBegin('deleteEntityTag_result')
9883 
    if self.success is not None:
9884 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9885 
      oprot.writeBool(self.success)
9886 
      oprot.writeFieldEnd()
9887 
    oprot.writeFieldStop()
9888 
    oprot.writeStructEnd()
9889 
 
9890 
  def validate(self):
9891 
    return
9892 
 
9893 
 
9894 
  def __repr__(self):
9895 
    L = ['%s=%r' % (key, value)
9896 
      for key, value in self.__dict__.iteritems()]
9897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9898 
 
9899 
  def __eq__(self, other):
9900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9901 
 
9902 
  def __ne__(self, other):
9903 
    return not (self == other)
9904 
 
9905 
class deleteTag_args:
9906 
  """
9907 
  Attributes:
9908 
   - displayName
9909 
  """
9910 
 
9911 
  thrift_spec = (
9912 
    None, # 0
9913 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9914 
  )
9915 
 
9916 
  def __init__(self, displayName=None,):
9917 
    self.displayName = displayName
9918 
 
9919 
  def read(self, iprot):
9920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9922 
      return
9923 
    iprot.readStructBegin()
9924 
    while True:
9925 
      (fname, ftype, fid) = iprot.readFieldBegin()
9926 
      if ftype == TType.STOP:
9927 
        break
9928 
      if fid == 1:
9929 
        if ftype == TType.STRING:
9930 
          self.displayName = iprot.readString();
9931 
        else:
9932 
          iprot.skip(ftype)
9933 
      else:
9934 
        iprot.skip(ftype)
9935 
      iprot.readFieldEnd()
9936 
    iprot.readStructEnd()
9937 
 
9938 
  def write(self, oprot):
9939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9941 
      return
9942 
    oprot.writeStructBegin('deleteTag_args')
9943 
    if self.displayName is not None:
9944 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9945 
      oprot.writeString(self.displayName)
9946 
      oprot.writeFieldEnd()
9947 
    oprot.writeFieldStop()
9948 
    oprot.writeStructEnd()
9949 
 
9950 
  def validate(self):
9951 
    return
9952 
 
9953 
 
9954 
  def __repr__(self):
9955 
    L = ['%s=%r' % (key, value)
9956 
      for key, value in self.__dict__.iteritems()]
9957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9958 
 
9959 
  def __eq__(self, other):
9960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9961 
 
9962 
  def __ne__(self, other):
9963 
    return not (self == other)
9964 
 
9965 
class deleteTag_result:
9966 
  """
9967 
  Attributes:
9968 
   - success
9969 
  """
9970 
 
9971 
  thrift_spec = (
9972 
    (0, TType.BOOL, 'success', None, None, ), # 0
9973 
  )
9974 
 
9975 
  def __init__(self, success=None,):
9976 
    self.success = success
9977 
 
9978 
  def read(self, iprot):
9979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9981 
      return
9982 
    iprot.readStructBegin()
9983 
    while True:
9984 
      (fname, ftype, fid) = iprot.readFieldBegin()
9985 
      if ftype == TType.STOP:
9986 
        break
9987 
      if fid == 0:
9988 
        if ftype == TType.BOOL:
9989 
          self.success = iprot.readBool();
9990 
        else:
9991 
          iprot.skip(ftype)
9992 
      else:
9993 
        iprot.skip(ftype)
9994 
      iprot.readFieldEnd()
9995 
    iprot.readStructEnd()
9996 
 
9997 
  def write(self, oprot):
9998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10000 
      return
10001 
    oprot.writeStructBegin('deleteTag_result')
10002 
    if self.success is not None:
10003 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10004 
      oprot.writeBool(self.success)
10005 
      oprot.writeFieldEnd()
10006 
    oprot.writeFieldStop()
10007 
    oprot.writeStructEnd()
10008 
 
10009 
  def validate(self):
10010 
    return
10011 
 
10012 
 
10013 
  def __repr__(self):
10014 
    L = ['%s=%r' % (key, value)
10015 
      for key, value in self.__dict__.iteritems()]
10016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10017 
 
10018 
  def __eq__(self, other):
10019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10020 
 
10021 
  def __ne__(self, other):
10022 
    return not (self == other)
10023 
 
10024 
class getAllTags_args:
10025 
 
10026 
  thrift_spec = (
10027 
  )
10028 
 
10029 
  def read(self, iprot):
10030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10032 
      return
10033 
    iprot.readStructBegin()
10034 
    while True:
10035 
      (fname, ftype, fid) = iprot.readFieldBegin()
10036 
      if ftype == TType.STOP:
10037 
        break
10038 
      else:
10039 
        iprot.skip(ftype)
10040 
      iprot.readFieldEnd()
10041 
    iprot.readStructEnd()
10042 
 
10043 
  def write(self, oprot):
10044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10046 
      return
10047 
    oprot.writeStructBegin('getAllTags_args')
10048 
    oprot.writeFieldStop()
10049 
    oprot.writeStructEnd()
10050 
 
10051 
  def validate(self):
10052 
    return
10053 
 
10054 
 
10055 
  def __repr__(self):
10056 
    L = ['%s=%r' % (key, value)
10057 
      for key, value in self.__dict__.iteritems()]
10058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10059 
 
10060 
  def __eq__(self, other):
10061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10062 
 
10063 
  def __ne__(self, other):
10064 
    return not (self == other)
10065 
 
10066 
class getAllTags_result:
10067 
  """
10068 
  Attributes:
10069 
   - success
10070 
  """
10071 
 
10072 
  thrift_spec = (
10073 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10074 
  )
10075 
 
10076 
  def __init__(self, success=None,):
10077 
    self.success = success
10078 
 
10079 
  def read(self, iprot):
10080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10082 
      return
10083 
    iprot.readStructBegin()
10084 
    while True:
10085 
      (fname, ftype, fid) = iprot.readFieldBegin()
10086 
      if ftype == TType.STOP:
10087 
        break
10088 
      if fid == 0:
10089 
        if ftype == TType.LIST:
10090 
          self.success = []
10091 
          (_etype138, _size135) = iprot.readListBegin()
10092 
          for _i139 in xrange(_size135):
10093 
            _elem140 = iprot.readString();
10094 
            self.success.append(_elem140)
10095 
          iprot.readListEnd()
10096 
        else:
10097 
          iprot.skip(ftype)
10098 
      else:
10099 
        iprot.skip(ftype)
10100 
      iprot.readFieldEnd()
10101 
    iprot.readStructEnd()
10102 
 
10103 
  def write(self, oprot):
10104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10106 
      return
10107 
    oprot.writeStructBegin('getAllTags_result')
10108 
    if self.success is not None:
10109 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10110 
      oprot.writeListBegin(TType.STRING, len(self.success))
10111 
      for iter141 in self.success:
10112 
        oprot.writeString(iter141)
10113 
      oprot.writeListEnd()
10114 
      oprot.writeFieldEnd()
10115 
    oprot.writeFieldStop()
10116 
    oprot.writeStructEnd()
10117 
 
10118 
  def validate(self):
10119 
    return
10120 
 
10121 
 
10122 
  def __repr__(self):
10123 
    L = ['%s=%r' % (key, value)
10124 
      for key, value in self.__dict__.iteritems()]
10125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10126 
 
10127 
  def __eq__(self, other):
10128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10129 
 
10130 
  def __ne__(self, other):
10131 
    return not (self == other)
10132 
 
10133 
class getAllEntitiesByTagName_args:
10134 
  """
10135 
  Attributes:
10136 
   - displayName
10137 
  """
10138 
 
10139 
  thrift_spec = (
10140 
    None, # 0
10141 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10142 
  )
10143 
 
10144 
  def __init__(self, displayName=None,):
10145 
    self.displayName = displayName
10146 
 
10147 
  def read(self, iprot):
10148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10150 
      return
10151 
    iprot.readStructBegin()
10152 
    while True:
10153 
      (fname, ftype, fid) = iprot.readFieldBegin()
10154 
      if ftype == TType.STOP:
10155 
        break
10156 
      if fid == 1:
10157 
        if ftype == TType.STRING:
10158 
          self.displayName = iprot.readString();
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      else:
10162 
        iprot.skip(ftype)
10163 
      iprot.readFieldEnd()
10164 
    iprot.readStructEnd()
10165 
 
10166 
  def write(self, oprot):
10167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10169 
      return
10170 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10171 
    if self.displayName is not None:
10172 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10173 
      oprot.writeString(self.displayName)
10174 
      oprot.writeFieldEnd()
10175 
    oprot.writeFieldStop()
10176 
    oprot.writeStructEnd()
10177 
 
10178 
  def validate(self):
10179 
    return
10180 
 
10181 
 
10182 
  def __repr__(self):
10183 
    L = ['%s=%r' % (key, value)
10184 
      for key, value in self.__dict__.iteritems()]
10185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10186 
 
10187 
  def __eq__(self, other):
10188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10189 
 
10190 
  def __ne__(self, other):
10191 
    return not (self == other)
10192 
 
10193 
class getAllEntitiesByTagName_result:
10194 
  """
10195 
  Attributes:
10196 
   - success
10197 
  """
10198 
 
10199 
  thrift_spec = (
10200 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10201 
  )
10202 
 
10203 
  def __init__(self, success=None,):
10204 
    self.success = success
10205 
 
10206 
  def read(self, iprot):
10207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10209 
      return
10210 
    iprot.readStructBegin()
10211 
    while True:
10212 
      (fname, ftype, fid) = iprot.readFieldBegin()
10213 
      if ftype == TType.STOP:
10214 
        break
10215 
      if fid == 0:
10216 
        if ftype == TType.LIST:
10217 
          self.success = []
10218 
          (_etype145, _size142) = iprot.readListBegin()
10219 
          for _i146 in xrange(_size142):
10220 
            _elem147 = iprot.readI64();
10221 
            self.success.append(_elem147)
10222 
          iprot.readListEnd()
10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      else:
10226 
        iprot.skip(ftype)
10227 
      iprot.readFieldEnd()
10228 
    iprot.readStructEnd()
10229 
 
10230 
  def write(self, oprot):
10231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10233 
      return
10234 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10235 
    if self.success is not None:
10236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10237 
      oprot.writeListBegin(TType.I64, len(self.success))
10238 
      for iter148 in self.success:
10239 
        oprot.writeI64(iter148)
10240 
      oprot.writeListEnd()
10241 
      oprot.writeFieldEnd()
10242 
    oprot.writeFieldStop()
10243 
    oprot.writeStructEnd()
10244 
 
10245 
  def validate(self):
10246 
    return
10247 
 
10248 
 
10249 
  def __repr__(self):
10250 
    L = ['%s=%r' % (key, value)
10251 
      for key, value in self.__dict__.iteritems()]
10252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10253 
 
10254 
  def __eq__(self, other):
10255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10256 
 
10257 
  def __ne__(self, other):
10258 
    return not (self == other)
10259 
 
6845 amit.gupta 10260 
class getAllEntityTags_args:
10261 
 
10262 
  thrift_spec = (
10263 
  )
10264 
 
10265 
  def read(self, iprot):
10266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10268 
      return
10269 
    iprot.readStructBegin()
10270 
    while True:
10271 
      (fname, ftype, fid) = iprot.readFieldBegin()
10272 
      if ftype == TType.STOP:
10273 
        break
10274 
      else:
10275 
        iprot.skip(ftype)
10276 
      iprot.readFieldEnd()
10277 
    iprot.readStructEnd()
10278 
 
10279 
  def write(self, oprot):
10280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10282 
      return
10283 
    oprot.writeStructBegin('getAllEntityTags_args')
10284 
    oprot.writeFieldStop()
10285 
    oprot.writeStructEnd()
10286 
 
10287 
  def validate(self):
10288 
    return
10289 
 
10290 
 
10291 
  def __repr__(self):
10292 
    L = ['%s=%r' % (key, value)
10293 
      for key, value in self.__dict__.iteritems()]
10294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10295 
 
10296 
  def __eq__(self, other):
10297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10298 
 
10299 
  def __ne__(self, other):
10300 
    return not (self == other)
10301 
 
10302 
class getAllEntityTags_result:
10303 
  """
10304 
  Attributes:
10305 
   - success
10306 
  """
10307 
 
10308 
  thrift_spec = (
10309 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10310 
  )
10311 
 
10312 
  def __init__(self, success=None,):
10313 
    self.success = success
10314 
 
10315 
  def read(self, iprot):
10316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10318 
      return
10319 
    iprot.readStructBegin()
10320 
    while True:
10321 
      (fname, ftype, fid) = iprot.readFieldBegin()
10322 
      if ftype == TType.STOP:
10323 
        break
10324 
      if fid == 0:
10325 
        if ftype == TType.MAP:
10326 
          self.success = {}
10327 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10328 
          for _i153 in xrange(_size149):
10329 
            _key154 = iprot.readI64();
10330 
            _val155 = []
10331 
            (_etype159, _size156) = iprot.readListBegin()
10332 
            for _i160 in xrange(_size156):
10333 
              _elem161 = iprot.readString();
10334 
              _val155.append(_elem161)
10335 
            iprot.readListEnd()
10336 
            self.success[_key154] = _val155
10337 
          iprot.readMapEnd()
10338 
        else:
10339 
          iprot.skip(ftype)
10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
10349 
    oprot.writeStructBegin('getAllEntityTags_result')
10350 
    if self.success is not None:
10351 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10352 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10353 
      for kiter162,viter163 in self.success.items():
10354 
        oprot.writeI64(kiter162)
10355 
        oprot.writeListBegin(TType.STRING, len(viter163))
10356 
        for iter164 in viter163:
10357 
          oprot.writeString(iter164)
10358 
        oprot.writeListEnd()
10359 
      oprot.writeMapEnd()
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 
 
6850 kshitij.so 10379 
class addBanner_args:
10380 
  """
10381 
  Attributes:
10382 
   - bannerName
10383 
   - imageName
10384 
   - link
10385 
   - priority
10386 
   - isActive
10387 
   - hasMap
10388 
  """
10389 
 
10390 
  thrift_spec = (
10391 
    None, # 0
10392 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10393 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10394 
    (3, TType.STRING, 'link', None, None, ), # 3
10395 
    (4, TType.I64, 'priority', None, None, ), # 4
10396 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10397 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10398 
  )
10399 
 
10400 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10401 
    self.bannerName = bannerName
10402 
    self.imageName = imageName
10403 
    self.link = link
10404 
    self.priority = priority
10405 
    self.isActive = isActive
10406 
    self.hasMap = hasMap
10407 
 
10408 
  def read(self, iprot):
10409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10411 
      return
10412 
    iprot.readStructBegin()
10413 
    while True:
10414 
      (fname, ftype, fid) = iprot.readFieldBegin()
10415 
      if ftype == TType.STOP:
10416 
        break
10417 
      if fid == 1:
10418 
        if ftype == TType.STRING:
10419 
          self.bannerName = iprot.readString();
10420 
        else:
10421 
          iprot.skip(ftype)
10422 
      elif fid == 2:
10423 
        if ftype == TType.STRING:
10424 
          self.imageName = iprot.readString();
10425 
        else:
10426 
          iprot.skip(ftype)
10427 
      elif fid == 3:
10428 
        if ftype == TType.STRING:
10429 
          self.link = iprot.readString();
10430 
        else:
10431 
          iprot.skip(ftype)
10432 
      elif fid == 4:
10433 
        if ftype == TType.I64:
10434 
          self.priority = iprot.readI64();
10435 
        else:
10436 
          iprot.skip(ftype)
10437 
      elif fid == 5:
10438 
        if ftype == TType.BOOL:
10439 
          self.isActive = iprot.readBool();
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      elif fid == 6:
10443 
        if ftype == TType.BOOL:
10444 
          self.hasMap = iprot.readBool();
10445 
        else:
10446 
          iprot.skip(ftype)
10447 
      else:
10448 
        iprot.skip(ftype)
10449 
      iprot.readFieldEnd()
10450 
    iprot.readStructEnd()
10451 
 
10452 
  def write(self, oprot):
10453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10455 
      return
10456 
    oprot.writeStructBegin('addBanner_args')
10457 
    if self.bannerName is not None:
10458 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10459 
      oprot.writeString(self.bannerName)
10460 
      oprot.writeFieldEnd()
10461 
    if self.imageName is not None:
10462 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10463 
      oprot.writeString(self.imageName)
10464 
      oprot.writeFieldEnd()
10465 
    if self.link is not None:
10466 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10467 
      oprot.writeString(self.link)
10468 
      oprot.writeFieldEnd()
10469 
    if self.priority is not None:
10470 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10471 
      oprot.writeI64(self.priority)
10472 
      oprot.writeFieldEnd()
10473 
    if self.isActive is not None:
10474 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10475 
      oprot.writeBool(self.isActive)
10476 
      oprot.writeFieldEnd()
10477 
    if self.hasMap is not None:
10478 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10479 
      oprot.writeBool(self.hasMap)
10480 
      oprot.writeFieldEnd()
10481 
    oprot.writeFieldStop()
10482 
    oprot.writeStructEnd()
10483 
 
10484 
  def validate(self):
10485 
    return
10486 
 
10487 
 
10488 
  def __repr__(self):
10489 
    L = ['%s=%r' % (key, value)
10490 
      for key, value in self.__dict__.iteritems()]
10491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10492 
 
10493 
  def __eq__(self, other):
10494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10495 
 
10496 
  def __ne__(self, other):
10497 
    return not (self == other)
10498 
 
10499 
class addBanner_result:
10500 
  """
10501 
  Attributes:
10502 
   - success
10503 
  """
10504 
 
10505 
  thrift_spec = (
10506 
    (0, TType.BOOL, 'success', None, None, ), # 0
10507 
  )
10508 
 
10509 
  def __init__(self, success=None,):
10510 
    self.success = success
10511 
 
10512 
  def read(self, iprot):
10513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10515 
      return
10516 
    iprot.readStructBegin()
10517 
    while True:
10518 
      (fname, ftype, fid) = iprot.readFieldBegin()
10519 
      if ftype == TType.STOP:
10520 
        break
10521 
      if fid == 0:
10522 
        if ftype == TType.BOOL:
10523 
          self.success = iprot.readBool();
10524 
        else:
10525 
          iprot.skip(ftype)
10526 
      else:
10527 
        iprot.skip(ftype)
10528 
      iprot.readFieldEnd()
10529 
    iprot.readStructEnd()
10530 
 
10531 
  def write(self, oprot):
10532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10534 
      return
10535 
    oprot.writeStructBegin('addBanner_result')
10536 
    if self.success is not None:
10537 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10538 
      oprot.writeBool(self.success)
10539 
      oprot.writeFieldEnd()
10540 
    oprot.writeFieldStop()
10541 
    oprot.writeStructEnd()
10542 
 
10543 
  def validate(self):
10544 
    return
10545 
 
10546 
 
10547 
  def __repr__(self):
10548 
    L = ['%s=%r' % (key, value)
10549 
      for key, value in self.__dict__.iteritems()]
10550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10551 
 
10552 
  def __eq__(self, other):
10553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10554 
 
10555 
  def __ne__(self, other):
10556 
    return not (self == other)
10557 
 
10558 
class getAllBanners_args:
10559 
 
10560 
  thrift_spec = (
10561 
  )
10562 
 
10563 
  def read(self, iprot):
10564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10566 
      return
10567 
    iprot.readStructBegin()
10568 
    while True:
10569 
      (fname, ftype, fid) = iprot.readFieldBegin()
10570 
      if ftype == TType.STOP:
10571 
        break
10572 
      else:
10573 
        iprot.skip(ftype)
10574 
      iprot.readFieldEnd()
10575 
    iprot.readStructEnd()
10576 
 
10577 
  def write(self, oprot):
10578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10580 
      return
10581 
    oprot.writeStructBegin('getAllBanners_args')
10582 
    oprot.writeFieldStop()
10583 
    oprot.writeStructEnd()
10584 
 
10585 
  def validate(self):
10586 
    return
10587 
 
10588 
 
10589 
  def __repr__(self):
10590 
    L = ['%s=%r' % (key, value)
10591 
      for key, value in self.__dict__.iteritems()]
10592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10593 
 
10594 
  def __eq__(self, other):
10595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10596 
 
10597 
  def __ne__(self, other):
10598 
    return not (self == other)
10599 
 
10600 
class getAllBanners_result:
10601 
  """
10602 
  Attributes:
10603 
   - success
10604 
  """
10605 
 
10606 
  thrift_spec = (
10607 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10608 
  )
10609 
 
10610 
  def __init__(self, success=None,):
10611 
    self.success = success
10612 
 
10613 
  def read(self, iprot):
10614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10616 
      return
10617 
    iprot.readStructBegin()
10618 
    while True:
10619 
      (fname, ftype, fid) = iprot.readFieldBegin()
10620 
      if ftype == TType.STOP:
10621 
        break
10622 
      if fid == 0:
10623 
        if ftype == TType.LIST:
10624 
          self.success = []
10625 
          (_etype168, _size165) = iprot.readListBegin()
10626 
          for _i169 in xrange(_size165):
10627 
            _elem170 = iprot.readString();
10628 
            self.success.append(_elem170)
10629 
          iprot.readListEnd()
10630 
        else:
10631 
          iprot.skip(ftype)
10632 
      else:
10633 
        iprot.skip(ftype)
10634 
      iprot.readFieldEnd()
10635 
    iprot.readStructEnd()
10636 
 
10637 
  def write(self, oprot):
10638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10640 
      return
10641 
    oprot.writeStructBegin('getAllBanners_result')
10642 
    if self.success is not None:
10643 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10644 
      oprot.writeListBegin(TType.STRING, len(self.success))
10645 
      for iter171 in self.success:
10646 
        oprot.writeString(iter171)
10647 
      oprot.writeListEnd()
10648 
      oprot.writeFieldEnd()
10649 
    oprot.writeFieldStop()
10650 
    oprot.writeStructEnd()
10651 
 
10652 
  def validate(self):
10653 
    return
10654 
 
10655 
 
10656 
  def __repr__(self):
10657 
    L = ['%s=%r' % (key, value)
10658 
      for key, value in self.__dict__.iteritems()]
10659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10660 
 
10661 
  def __eq__(self, other):
10662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10663 
 
10664 
  def __ne__(self, other):
10665 
    return not (self == other)
10666 
 
10667 
class deleteBanner_args:
10668 
  """
10669 
  Attributes:
10670 
   - bannerName
10671 
  """
10672 
 
10673 
  thrift_spec = (
10674 
    None, # 0
10675 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10676 
  )
10677 
 
10678 
  def __init__(self, bannerName=None,):
10679 
    self.bannerName = bannerName
10680 
 
10681 
  def read(self, iprot):
10682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10684 
      return
10685 
    iprot.readStructBegin()
10686 
    while True:
10687 
      (fname, ftype, fid) = iprot.readFieldBegin()
10688 
      if ftype == TType.STOP:
10689 
        break
10690 
      if fid == 1:
10691 
        if ftype == TType.STRING:
10692 
          self.bannerName = iprot.readString();
10693 
        else:
10694 
          iprot.skip(ftype)
10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('deleteBanner_args')
10705 
    if self.bannerName is not None:
10706 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10707 
      oprot.writeString(self.bannerName)
10708 
      oprot.writeFieldEnd()
10709 
    oprot.writeFieldStop()
10710 
    oprot.writeStructEnd()
10711 
 
10712 
  def validate(self):
10713 
    return
10714 
 
10715 
 
10716 
  def __repr__(self):
10717 
    L = ['%s=%r' % (key, value)
10718 
      for key, value in self.__dict__.iteritems()]
10719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10720 
 
10721 
  def __eq__(self, other):
10722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10723 
 
10724 
  def __ne__(self, other):
10725 
    return not (self == other)
10726 
 
10727 
class deleteBanner_result:
10728 
  """
10729 
  Attributes:
10730 
   - success
10731 
  """
10732 
 
10733 
  thrift_spec = (
10734 
    (0, TType.BOOL, 'success', None, None, ), # 0
10735 
  )
10736 
 
10737 
  def __init__(self, success=None,):
10738 
    self.success = success
10739 
 
10740 
  def read(self, iprot):
10741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10743 
      return
10744 
    iprot.readStructBegin()
10745 
    while True:
10746 
      (fname, ftype, fid) = iprot.readFieldBegin()
10747 
      if ftype == TType.STOP:
10748 
        break
10749 
      if fid == 0:
10750 
        if ftype == TType.BOOL:
10751 
          self.success = iprot.readBool();
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('deleteBanner_result')
10764 
    if self.success is not None:
10765 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10766 
      oprot.writeBool(self.success)
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 getBannerDetails_args:
10787 
  """
10788 
  Attributes:
10789 
   - bannerName
10790 
  """
10791 
 
10792 
  thrift_spec = (
10793 
    None, # 0
10794 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10795 
  )
10796 
 
10797 
  def __init__(self, bannerName=None,):
10798 
    self.bannerName = bannerName
10799 
 
10800 
  def read(self, iprot):
10801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10803 
      return
10804 
    iprot.readStructBegin()
10805 
    while True:
10806 
      (fname, ftype, fid) = iprot.readFieldBegin()
10807 
      if ftype == TType.STOP:
10808 
        break
10809 
      if fid == 1:
10810 
        if ftype == TType.STRING:
10811 
          self.bannerName = iprot.readString();
10812 
        else:
10813 
          iprot.skip(ftype)
10814 
      else:
10815 
        iprot.skip(ftype)
10816 
      iprot.readFieldEnd()
10817 
    iprot.readStructEnd()
10818 
 
10819 
  def write(self, oprot):
10820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10822 
      return
10823 
    oprot.writeStructBegin('getBannerDetails_args')
10824 
    if self.bannerName is not None:
10825 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10826 
      oprot.writeString(self.bannerName)
10827 
      oprot.writeFieldEnd()
10828 
    oprot.writeFieldStop()
10829 
    oprot.writeStructEnd()
10830 
 
10831 
  def validate(self):
10832 
    return
10833 
 
10834 
 
10835 
  def __repr__(self):
10836 
    L = ['%s=%r' % (key, value)
10837 
      for key, value in self.__dict__.iteritems()]
10838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10839 
 
10840 
  def __eq__(self, other):
10841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10842 
 
10843 
  def __ne__(self, other):
10844 
    return not (self == other)
10845 
 
10846 
class getBannerDetails_result:
10847 
  """
10848 
  Attributes:
10849 
   - success
10850 
  """
10851 
 
10852 
  thrift_spec = (
10853 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10854 
  )
10855 
 
10856 
  def __init__(self, success=None,):
10857 
    self.success = success
10858 
 
10859 
  def read(self, iprot):
10860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10862 
      return
10863 
    iprot.readStructBegin()
10864 
    while True:
10865 
      (fname, ftype, fid) = iprot.readFieldBegin()
10866 
      if ftype == TType.STOP:
10867 
        break
10868 
      if fid == 0:
10869 
        if ftype == TType.STRUCT:
10870 
          self.success = Banner()
10871 
          self.success.read(iprot)
10872 
        else:
10873 
          iprot.skip(ftype)
10874 
      else:
10875 
        iprot.skip(ftype)
10876 
      iprot.readFieldEnd()
10877 
    iprot.readStructEnd()
10878 
 
10879 
  def write(self, oprot):
10880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10882 
      return
10883 
    oprot.writeStructBegin('getBannerDetails_result')
10884 
    if self.success is not None:
10885 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10886 
      self.success.write(oprot)
10887 
      oprot.writeFieldEnd()
10888 
    oprot.writeFieldStop()
10889 
    oprot.writeStructEnd()
10890 
 
10891 
  def validate(self):
10892 
    return
10893 
 
10894 
 
10895 
  def __repr__(self):
10896 
    L = ['%s=%r' % (key, value)
10897 
      for key, value in self.__dict__.iteritems()]
10898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10899 
 
10900 
  def __eq__(self, other):
10901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10902 
 
10903 
  def __ne__(self, other):
10904 
    return not (self == other)
10905 
 
10906 
class getActiveBanners_args:
10907 
 
10908 
  thrift_spec = (
10909 
  )
10910 
 
10911 
  def read(self, iprot):
10912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10914 
      return
10915 
    iprot.readStructBegin()
10916 
    while True:
10917 
      (fname, ftype, fid) = iprot.readFieldBegin()
10918 
      if ftype == TType.STOP:
10919 
        break
10920 
      else:
10921 
        iprot.skip(ftype)
10922 
      iprot.readFieldEnd()
10923 
    iprot.readStructEnd()
10924 
 
10925 
  def write(self, oprot):
10926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10928 
      return
10929 
    oprot.writeStructBegin('getActiveBanners_args')
10930 
    oprot.writeFieldStop()
10931 
    oprot.writeStructEnd()
10932 
 
10933 
  def validate(self):
10934 
    return
10935 
 
10936 
 
10937 
  def __repr__(self):
10938 
    L = ['%s=%r' % (key, value)
10939 
      for key, value in self.__dict__.iteritems()]
10940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10941 
 
10942 
  def __eq__(self, other):
10943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10944 
 
10945 
  def __ne__(self, other):
10946 
    return not (self == other)
10947 
 
10948 
class getActiveBanners_result:
10949 
  """
10950 
  Attributes:
10951 
   - success
10952 
  """
10953 
 
10954 
  thrift_spec = (
10955 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
10956 
  )
10957 
 
10958 
  def __init__(self, success=None,):
10959 
    self.success = success
10960 
 
10961 
  def read(self, iprot):
10962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10964 
      return
10965 
    iprot.readStructBegin()
10966 
    while True:
10967 
      (fname, ftype, fid) = iprot.readFieldBegin()
10968 
      if ftype == TType.STOP:
10969 
        break
10970 
      if fid == 0:
10971 
        if ftype == TType.LIST:
10972 
          self.success = []
10973 
          (_etype175, _size172) = iprot.readListBegin()
10974 
          for _i176 in xrange(_size172):
10975 
            _elem177 = Banner()
10976 
            _elem177.read(iprot)
10977 
            self.success.append(_elem177)
10978 
          iprot.readListEnd()
10979 
        else:
10980 
          iprot.skip(ftype)
10981 
      else:
10982 
        iprot.skip(ftype)
10983 
      iprot.readFieldEnd()
10984 
    iprot.readStructEnd()
10985 
 
10986 
  def write(self, oprot):
10987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10989 
      return
10990 
    oprot.writeStructBegin('getActiveBanners_result')
10991 
    if self.success is not None:
10992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10993 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10994 
      for iter178 in self.success:
10995 
        iter178.write(oprot)
10996 
      oprot.writeListEnd()
10997 
      oprot.writeFieldEnd()
10998 
    oprot.writeFieldStop()
10999 
    oprot.writeStructEnd()
11000 
 
11001 
  def validate(self):
11002 
    return
11003 
 
11004 
 
11005 
  def __repr__(self):
11006 
    L = ['%s=%r' % (key, value)
11007 
      for key, value in self.__dict__.iteritems()]
11008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11009 
 
11010 
  def __eq__(self, other):
11011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11012 
 
11013 
  def __ne__(self, other):
11014 
    return not (self == other)
11015 
 
6849 kshitij.so 11016 
class addBannerMap_args:
11017 
  """
11018 
  Attributes:
11019 
   - bannerName
11020 
   - mapLink
11021 
   - coordinates
11022 
  """
11023 
 
11024 
  thrift_spec = (
11025 
    None, # 0
11026 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11027 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11028 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11029 
  )
11030 
 
11031 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11032 
    self.bannerName = bannerName
11033 
    self.mapLink = mapLink
11034 
    self.coordinates = coordinates
11035 
 
11036 
  def read(self, iprot):
11037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11039 
      return
11040 
    iprot.readStructBegin()
11041 
    while True:
11042 
      (fname, ftype, fid) = iprot.readFieldBegin()
11043 
      if ftype == TType.STOP:
11044 
        break
11045 
      if fid == 1:
11046 
        if ftype == TType.STRING:
11047 
          self.bannerName = iprot.readString();
11048 
        else:
11049 
          iprot.skip(ftype)
11050 
      elif fid == 2:
11051 
        if ftype == TType.STRING:
11052 
          self.mapLink = iprot.readString();
11053 
        else:
11054 
          iprot.skip(ftype)
11055 
      elif fid == 3:
11056 
        if ftype == TType.STRING:
11057 
          self.coordinates = iprot.readString();
11058 
        else:
11059 
          iprot.skip(ftype)
11060 
      else:
11061 
        iprot.skip(ftype)
11062 
      iprot.readFieldEnd()
11063 
    iprot.readStructEnd()
11064 
 
11065 
  def write(self, oprot):
11066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11068 
      return
11069 
    oprot.writeStructBegin('addBannerMap_args')
11070 
    if self.bannerName is not None:
11071 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11072 
      oprot.writeString(self.bannerName)
11073 
      oprot.writeFieldEnd()
11074 
    if self.mapLink is not None:
11075 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11076 
      oprot.writeString(self.mapLink)
11077 
      oprot.writeFieldEnd()
11078 
    if self.coordinates is not None:
11079 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11080 
      oprot.writeString(self.coordinates)
11081 
      oprot.writeFieldEnd()
11082 
    oprot.writeFieldStop()
11083 
    oprot.writeStructEnd()
11084 
 
11085 
  def validate(self):
11086 
    return
11087 
 
11088 
 
11089 
  def __repr__(self):
11090 
    L = ['%s=%r' % (key, value)
11091 
      for key, value in self.__dict__.iteritems()]
11092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11093 
 
11094 
  def __eq__(self, other):
11095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11096 
 
11097 
  def __ne__(self, other):
11098 
    return not (self == other)
11099 
 
11100 
class addBannerMap_result:
11101 
  """
11102 
  Attributes:
11103 
   - success
11104 
  """
11105 
 
11106 
  thrift_spec = (
11107 
    (0, TType.BOOL, 'success', None, None, ), # 0
11108 
  )
11109 
 
11110 
  def __init__(self, success=None,):
11111 
    self.success = success
11112 
 
11113 
  def read(self, iprot):
11114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11116 
      return
11117 
    iprot.readStructBegin()
11118 
    while True:
11119 
      (fname, ftype, fid) = iprot.readFieldBegin()
11120 
      if ftype == TType.STOP:
11121 
        break
11122 
      if fid == 0:
11123 
        if ftype == TType.BOOL:
11124 
          self.success = iprot.readBool();
11125 
        else:
11126 
          iprot.skip(ftype)
11127 
      else:
11128 
        iprot.skip(ftype)
11129 
      iprot.readFieldEnd()
11130 
    iprot.readStructEnd()
11131 
 
11132 
  def write(self, oprot):
11133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11135 
      return
11136 
    oprot.writeStructBegin('addBannerMap_result')
11137 
    if self.success is not None:
11138 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11139 
      oprot.writeBool(self.success)
11140 
      oprot.writeFieldEnd()
11141 
    oprot.writeFieldStop()
11142 
    oprot.writeStructEnd()
11143 
 
11144 
  def validate(self):
11145 
    return
11146 
 
11147 
 
11148 
  def __repr__(self):
11149 
    L = ['%s=%r' % (key, value)
11150 
      for key, value in self.__dict__.iteritems()]
11151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11152 
 
11153 
  def __eq__(self, other):
11154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11155 
 
11156 
  def __ne__(self, other):
11157 
    return not (self == other)
11158 
 
11159 
class deleteBannerMap_args:
11160 
  """
11161 
  Attributes:
11162 
   - bannerName
11163 
  """
11164 
 
11165 
  thrift_spec = (
11166 
    None, # 0
11167 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11168 
  )
11169 
 
11170 
  def __init__(self, bannerName=None,):
11171 
    self.bannerName = bannerName
11172 
 
11173 
  def read(self, iprot):
11174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11176 
      return
11177 
    iprot.readStructBegin()
11178 
    while True:
11179 
      (fname, ftype, fid) = iprot.readFieldBegin()
11180 
      if ftype == TType.STOP:
11181 
        break
11182 
      if fid == 1:
11183 
        if ftype == TType.STRING:
11184 
          self.bannerName = iprot.readString();
11185 
        else:
11186 
          iprot.skip(ftype)
11187 
      else:
11188 
        iprot.skip(ftype)
11189 
      iprot.readFieldEnd()
11190 
    iprot.readStructEnd()
11191 
 
11192 
  def write(self, oprot):
11193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11195 
      return
11196 
    oprot.writeStructBegin('deleteBannerMap_args')
11197 
    if self.bannerName is not None:
11198 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11199 
      oprot.writeString(self.bannerName)
11200 
      oprot.writeFieldEnd()
11201 
    oprot.writeFieldStop()
11202 
    oprot.writeStructEnd()
11203 
 
11204 
  def validate(self):
11205 
    return
11206 
 
11207 
 
11208 
  def __repr__(self):
11209 
    L = ['%s=%r' % (key, value)
11210 
      for key, value in self.__dict__.iteritems()]
11211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11212 
 
11213 
  def __eq__(self, other):
11214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11215 
 
11216 
  def __ne__(self, other):
11217 
    return not (self == other)
11218 
 
11219 
class deleteBannerMap_result:
11220 
  """
11221 
  Attributes:
11222 
   - success
11223 
  """
11224 
 
11225 
  thrift_spec = (
11226 
    (0, TType.BOOL, 'success', None, None, ), # 0
11227 
  )
11228 
 
11229 
  def __init__(self, success=None,):
11230 
    self.success = success
11231 
 
11232 
  def read(self, iprot):
11233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11235 
      return
11236 
    iprot.readStructBegin()
11237 
    while True:
11238 
      (fname, ftype, fid) = iprot.readFieldBegin()
11239 
      if ftype == TType.STOP:
11240 
        break
11241 
      if fid == 0:
11242 
        if ftype == TType.BOOL:
11243 
          self.success = iprot.readBool();
11244 
        else:
11245 
          iprot.skip(ftype)
11246 
      else:
11247 
        iprot.skip(ftype)
11248 
      iprot.readFieldEnd()
11249 
    iprot.readStructEnd()
11250 
 
11251 
  def write(self, oprot):
11252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11254 
      return
11255 
    oprot.writeStructBegin('deleteBannerMap_result')
11256 
    if self.success is not None:
11257 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11258 
      oprot.writeBool(self.success)
11259 
      oprot.writeFieldEnd()
11260 
    oprot.writeFieldStop()
11261 
    oprot.writeStructEnd()
11262 
 
11263 
  def validate(self):
11264 
    return
11265 
 
11266 
 
11267 
  def __repr__(self):
11268 
    L = ['%s=%r' % (key, value)
11269 
      for key, value in self.__dict__.iteritems()]
11270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11271 
 
11272 
  def __eq__(self, other):
11273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11274 
 
11275 
  def __ne__(self, other):
11276 
    return not (self == other)
11277 
 
11278 
class getBannerMapDetails_args:
11279 
  """
11280 
  Attributes:
11281 
   - bannerName
11282 
  """
11283 
 
11284 
  thrift_spec = (
11285 
    None, # 0
11286 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11287 
  )
11288 
 
11289 
  def __init__(self, bannerName=None,):
11290 
    self.bannerName = bannerName
11291 
 
11292 
  def read(self, iprot):
11293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11295 
      return
11296 
    iprot.readStructBegin()
11297 
    while True:
11298 
      (fname, ftype, fid) = iprot.readFieldBegin()
11299 
      if ftype == TType.STOP:
11300 
        break
11301 
      if fid == 1:
11302 
        if ftype == TType.STRING:
11303 
          self.bannerName = iprot.readString();
11304 
        else:
11305 
          iprot.skip(ftype)
11306 
      else:
11307 
        iprot.skip(ftype)
11308 
      iprot.readFieldEnd()
11309 
    iprot.readStructEnd()
11310 
 
11311 
  def write(self, oprot):
11312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11314 
      return
11315 
    oprot.writeStructBegin('getBannerMapDetails_args')
11316 
    if self.bannerName is not None:
11317 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11318 
      oprot.writeString(self.bannerName)
11319 
      oprot.writeFieldEnd()
11320 
    oprot.writeFieldStop()
11321 
    oprot.writeStructEnd()
11322 
 
11323 
  def validate(self):
11324 
    return
11325 
 
11326 
 
11327 
  def __repr__(self):
11328 
    L = ['%s=%r' % (key, value)
11329 
      for key, value in self.__dict__.iteritems()]
11330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11331 
 
11332 
  def __eq__(self, other):
11333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11334 
 
11335 
  def __ne__(self, other):
11336 
    return not (self == other)
11337 
 
11338 
class getBannerMapDetails_result:
11339 
  """
11340 
  Attributes:
11341 
   - success
11342 
  """
11343 
 
11344 
  thrift_spec = (
11345 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11346 
  )
11347 
 
11348 
  def __init__(self, success=None,):
11349 
    self.success = success
11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      if fid == 0:
11361 
        if ftype == TType.LIST:
11362 
          self.success = []
6850 kshitij.so 11363 
          (_etype182, _size179) = iprot.readListBegin()
11364 
          for _i183 in xrange(_size179):
11365 
            _elem184 = BannerMap()
11366 
            _elem184.read(iprot)
11367 
            self.success.append(_elem184)
6849 kshitij.so 11368 
          iprot.readListEnd()
11369 
        else:
11370 
          iprot.skip(ftype)
11371 
      else:
11372 
        iprot.skip(ftype)
11373 
      iprot.readFieldEnd()
11374 
    iprot.readStructEnd()
11375 
 
11376 
  def write(self, oprot):
11377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11379 
      return
11380 
    oprot.writeStructBegin('getBannerMapDetails_result')
11381 
    if self.success is not None:
11382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11384 
      for iter185 in self.success:
11385 
        iter185.write(oprot)
6849 kshitij.so 11386 
      oprot.writeListEnd()
11387 
      oprot.writeFieldEnd()
11388 
    oprot.writeFieldStop()
11389 
    oprot.writeStructEnd()
11390 
 
11391 
  def validate(self):
11392 
    return
11393 
 
11394 
 
11395 
  def __repr__(self):
11396 
    L = ['%s=%r' % (key, value)
11397 
      for key, value in self.__dict__.iteritems()]
11398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11399 
 
11400 
  def __eq__(self, other):
11401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11402 
 
11403 
  def __ne__(self, other):
11404 
    return not (self == other)
11405 
 
5944 mandeep.dh 11406 
class deleteSimilarItem_args:
11407 
  """
11408 
  Attributes:
11409 
   - itemId
11410 
   - catalogItemId
11411 
  """
11412 
 
11413 
  thrift_spec = (
11414 
    None, # 0
11415 
    (1, TType.I64, 'itemId', None, None, ), # 1
11416 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11417 
  )
11418 
 
11419 
  def __init__(self, itemId=None, catalogItemId=None,):
11420 
    self.itemId = itemId
11421 
    self.catalogItemId = catalogItemId
11422 
 
11423 
  def read(self, iprot):
11424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11426 
      return
11427 
    iprot.readStructBegin()
11428 
    while True:
11429 
      (fname, ftype, fid) = iprot.readFieldBegin()
11430 
      if ftype == TType.STOP:
11431 
        break
11432 
      if fid == 1:
11433 
        if ftype == TType.I64:
11434 
          self.itemId = iprot.readI64();
11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      elif fid == 2:
11438 
        if ftype == TType.I64:
11439 
          self.catalogItemId = iprot.readI64();
11440 
        else:
11441 
          iprot.skip(ftype)
11442 
      else:
11443 
        iprot.skip(ftype)
11444 
      iprot.readFieldEnd()
11445 
    iprot.readStructEnd()
11446 
 
11447 
  def write(self, oprot):
11448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11450 
      return
11451 
    oprot.writeStructBegin('deleteSimilarItem_args')
11452 
    if self.itemId is not None:
11453 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11454 
      oprot.writeI64(self.itemId)
11455 
      oprot.writeFieldEnd()
11456 
    if self.catalogItemId is not None:
11457 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11458 
      oprot.writeI64(self.catalogItemId)
11459 
      oprot.writeFieldEnd()
11460 
    oprot.writeFieldStop()
11461 
    oprot.writeStructEnd()
11462 
 
11463 
  def validate(self):
11464 
    return
11465 
 
11466 
 
11467 
  def __repr__(self):
11468 
    L = ['%s=%r' % (key, value)
11469 
      for key, value in self.__dict__.iteritems()]
11470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11471 
 
11472 
  def __eq__(self, other):
11473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11474 
 
11475 
  def __ne__(self, other):
11476 
    return not (self == other)
11477 
 
11478 
class deleteSimilarItem_result:
11479 
  """
11480 
  Attributes:
11481 
   - success
11482 
   - cex
11483 
  """
11484 
 
11485 
  thrift_spec = (
11486 
    (0, TType.BOOL, 'success', None, None, ), # 0
11487 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11488 
  )
11489 
 
11490 
  def __init__(self, success=None, cex=None,):
11491 
    self.success = success
11492 
    self.cex = cex
11493 
 
11494 
  def read(self, iprot):
11495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11497 
      return
11498 
    iprot.readStructBegin()
11499 
    while True:
11500 
      (fname, ftype, fid) = iprot.readFieldBegin()
11501 
      if ftype == TType.STOP:
11502 
        break
11503 
      if fid == 0:
11504 
        if ftype == TType.BOOL:
11505 
          self.success = iprot.readBool();
11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      elif fid == 1:
11509 
        if ftype == TType.STRUCT:
11510 
          self.cex = CatalogServiceException()
11511 
          self.cex.read(iprot)
11512 
        else:
11513 
          iprot.skip(ftype)
11514 
      else:
11515 
        iprot.skip(ftype)
11516 
      iprot.readFieldEnd()
11517 
    iprot.readStructEnd()
11518 
 
11519 
  def write(self, oprot):
11520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11522 
      return
11523 
    oprot.writeStructBegin('deleteSimilarItem_result')
11524 
    if self.success is not None:
11525 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11526 
      oprot.writeBool(self.success)
11527 
      oprot.writeFieldEnd()
11528 
    if self.cex is not None:
11529 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11530 
      self.cex.write(oprot)
11531 
      oprot.writeFieldEnd()
11532 
    oprot.writeFieldStop()
11533 
    oprot.writeStructEnd()
11534 
 
11535 
  def validate(self):
11536 
    return
11537 
 
11538 
 
11539 
  def __repr__(self):
11540 
    L = ['%s=%r' % (key, value)
11541 
      for key, value in self.__dict__.iteritems()]
11542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11543 
 
11544 
  def __eq__(self, other):
11545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11546 
 
11547 
  def __ne__(self, other):
11548 
    return not (self == other)
11549 
 
11550 
class checkSimilarItem_args:
11551 
  """
11552 
  Attributes:
11553 
   - brand
11554 
   - modelNumber
11555 
   - modelName
11556 
   - color
11557 
  """
11558 
 
11559 
  thrift_spec = (
11560 
    None, # 0
11561 
    (1, TType.STRING, 'brand', None, None, ), # 1
11562 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11563 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11564 
    (4, TType.STRING, 'color', None, None, ), # 4
11565 
  )
11566 
 
11567 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11568 
    self.brand = brand
11569 
    self.modelNumber = modelNumber
11570 
    self.modelName = modelName
11571 
    self.color = color
11572 
 
11573 
  def read(self, iprot):
11574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11576 
      return
11577 
    iprot.readStructBegin()
11578 
    while True:
11579 
      (fname, ftype, fid) = iprot.readFieldBegin()
11580 
      if ftype == TType.STOP:
11581 
        break
11582 
      if fid == 1:
11583 
        if ftype == TType.STRING:
11584 
          self.brand = iprot.readString();
11585 
        else:
11586 
          iprot.skip(ftype)
11587 
      elif fid == 2:
11588 
        if ftype == TType.STRING:
11589 
          self.modelNumber = iprot.readString();
11590 
        else:
11591 
          iprot.skip(ftype)
11592 
      elif fid == 3:
11593 
        if ftype == TType.STRING:
11594 
          self.modelName = iprot.readString();
11595 
        else:
11596 
          iprot.skip(ftype)
11597 
      elif fid == 4:
11598 
        if ftype == TType.STRING:
11599 
          self.color = iprot.readString();
11600 
        else:
11601 
          iprot.skip(ftype)
11602 
      else:
11603 
        iprot.skip(ftype)
11604 
      iprot.readFieldEnd()
11605 
    iprot.readStructEnd()
11606 
 
11607 
  def write(self, oprot):
11608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11610 
      return
11611 
    oprot.writeStructBegin('checkSimilarItem_args')
11612 
    if self.brand is not None:
11613 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11614 
      oprot.writeString(self.brand)
11615 
      oprot.writeFieldEnd()
11616 
    if self.modelNumber is not None:
11617 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11618 
      oprot.writeString(self.modelNumber)
11619 
      oprot.writeFieldEnd()
11620 
    if self.modelName is not None:
11621 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11622 
      oprot.writeString(self.modelName)
11623 
      oprot.writeFieldEnd()
11624 
    if self.color is not None:
11625 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11626 
      oprot.writeString(self.color)
11627 
      oprot.writeFieldEnd()
11628 
    oprot.writeFieldStop()
11629 
    oprot.writeStructEnd()
11630 
 
11631 
  def validate(self):
11632 
    return
11633 
 
11634 
 
11635 
  def __repr__(self):
11636 
    L = ['%s=%r' % (key, value)
11637 
      for key, value in self.__dict__.iteritems()]
11638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11639 
 
11640 
  def __eq__(self, other):
11641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11642 
 
11643 
  def __ne__(self, other):
11644 
    return not (self == other)
11645 
 
11646 
class checkSimilarItem_result:
11647 
  """
11648 
  Attributes:
11649 
   - success
11650 
  """
11651 
 
11652 
  thrift_spec = (
11653 
    (0, TType.I64, 'success', None, None, ), # 0
11654 
  )
11655 
 
11656 
  def __init__(self, success=None,):
11657 
    self.success = success
11658 
 
11659 
  def read(self, iprot):
11660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11662 
      return
11663 
    iprot.readStructBegin()
11664 
    while True:
11665 
      (fname, ftype, fid) = iprot.readFieldBegin()
11666 
      if ftype == TType.STOP:
11667 
        break
11668 
      if fid == 0:
11669 
        if ftype == TType.I64:
11670 
          self.success = iprot.readI64();
11671 
        else:
11672 
          iprot.skip(ftype)
11673 
      else:
11674 
        iprot.skip(ftype)
11675 
      iprot.readFieldEnd()
11676 
    iprot.readStructEnd()
11677 
 
11678 
  def write(self, oprot):
11679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11681 
      return
11682 
    oprot.writeStructBegin('checkSimilarItem_result')
11683 
    if self.success is not None:
11684 
      oprot.writeFieldBegin('success', TType.I64, 0)
11685 
      oprot.writeI64(self.success)
11686 
      oprot.writeFieldEnd()
11687 
    oprot.writeFieldStop()
11688 
    oprot.writeStructEnd()
11689 
 
11690 
  def validate(self):
11691 
    return
11692 
 
11693 
 
11694 
  def __repr__(self):
11695 
    L = ['%s=%r' % (key, value)
11696 
      for key, value in self.__dict__.iteritems()]
11697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11698 
 
11699 
  def __eq__(self, other):
11700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11701 
 
11702 
  def __ne__(self, other):
11703 
    return not (self == other)
11704 
 
11705 
class validateRiskyStatus_args:
11706 
  """
11707 
  Attributes:
11708 
   - itemId
11709 
  """
11710 
 
11711 
  thrift_spec = (
11712 
    None, # 0
11713 
    (1, TType.I64, 'itemId', None, None, ), # 1
11714 
  )
11715 
 
11716 
  def __init__(self, itemId=None,):
11717 
    self.itemId = itemId
11718 
 
11719 
  def read(self, iprot):
11720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11722 
      return
11723 
    iprot.readStructBegin()
11724 
    while True:
11725 
      (fname, ftype, fid) = iprot.readFieldBegin()
11726 
      if ftype == TType.STOP:
11727 
        break
11728 
      if fid == 1:
11729 
        if ftype == TType.I64:
11730 
          self.itemId = iprot.readI64();
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      else:
11734 
        iprot.skip(ftype)
11735 
      iprot.readFieldEnd()
11736 
    iprot.readStructEnd()
11737 
 
11738 
  def write(self, oprot):
11739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11741 
      return
11742 
    oprot.writeStructBegin('validateRiskyStatus_args')
11743 
    if self.itemId is not None:
11744 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11745 
      oprot.writeI64(self.itemId)
11746 
      oprot.writeFieldEnd()
11747 
    oprot.writeFieldStop()
11748 
    oprot.writeStructEnd()
11749 
 
11750 
  def validate(self):
11751 
    return
11752 
 
11753 
 
11754 
  def __repr__(self):
11755 
    L = ['%s=%r' % (key, value)
11756 
      for key, value in self.__dict__.iteritems()]
11757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11758 
 
11759 
  def __eq__(self, other):
11760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11761 
 
11762 
  def __ne__(self, other):
11763 
    return not (self == other)
11764 
 
11765 
class validateRiskyStatus_result:
11766 
 
11767 
  thrift_spec = (
11768 
  )
11769 
 
11770 
  def read(self, iprot):
11771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11773 
      return
11774 
    iprot.readStructBegin()
11775 
    while True:
11776 
      (fname, ftype, fid) = iprot.readFieldBegin()
11777 
      if ftype == TType.STOP:
11778 
        break
11779 
      else:
11780 
        iprot.skip(ftype)
11781 
      iprot.readFieldEnd()
11782 
    iprot.readStructEnd()
11783 
 
11784 
  def write(self, oprot):
11785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11787 
      return
11788 
    oprot.writeStructBegin('validateRiskyStatus_result')
11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
11807 
class changeItemRiskyFlag_args:
11808 
  """
11809 
  Attributes:
11810 
   - itemId
11811 
   - risky
11812 
  """
11813 
 
11814 
  thrift_spec = (
11815 
    None, # 0
11816 
    (1, TType.I64, 'itemId', None, None, ), # 1
11817 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11818 
  )
11819 
 
11820 
  def __init__(self, itemId=None, risky=None,):
11821 
    self.itemId = itemId
11822 
    self.risky = risky
11823 
 
11824 
  def read(self, iprot):
11825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11827 
      return
11828 
    iprot.readStructBegin()
11829 
    while True:
11830 
      (fname, ftype, fid) = iprot.readFieldBegin()
11831 
      if ftype == TType.STOP:
11832 
        break
11833 
      if fid == 1:
11834 
        if ftype == TType.I64:
11835 
          self.itemId = iprot.readI64();
11836 
        else:
11837 
          iprot.skip(ftype)
11838 
      elif fid == 2:
11839 
        if ftype == TType.BOOL:
11840 
          self.risky = iprot.readBool();
11841 
        else:
11842 
          iprot.skip(ftype)
11843 
      else:
11844 
        iprot.skip(ftype)
11845 
      iprot.readFieldEnd()
11846 
    iprot.readStructEnd()
11847 
 
11848 
  def write(self, oprot):
11849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11851 
      return
11852 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11853 
    if self.itemId is not None:
11854 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11855 
      oprot.writeI64(self.itemId)
11856 
      oprot.writeFieldEnd()
11857 
    if self.risky is not None:
11858 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11859 
      oprot.writeBool(self.risky)
11860 
      oprot.writeFieldEnd()
11861 
    oprot.writeFieldStop()
11862 
    oprot.writeStructEnd()
11863 
 
11864 
  def validate(self):
11865 
    return
11866 
 
11867 
 
11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
11879 
class changeItemRiskyFlag_result:
11880 
 
11881 
  thrift_spec = (
11882 
  )
11883 
 
11884 
  def read(self, iprot):
11885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11887 
      return
11888 
    iprot.readStructBegin()
11889 
    while True:
11890 
      (fname, ftype, fid) = iprot.readFieldBegin()
11891 
      if ftype == TType.STOP:
11892 
        break
11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
11902 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11903 
    oprot.writeFieldStop()
11904 
    oprot.writeStructEnd()
11905 
 
11906 
  def validate(self):
11907 
    return
11908 
 
11909 
 
11910 
  def __repr__(self):
11911 
    L = ['%s=%r' % (key, value)
11912 
      for key, value in self.__dict__.iteritems()]
11913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11914 
 
11915 
  def __eq__(self, other):
11916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11917 
 
11918 
  def __ne__(self, other):
11919 
    return not (self == other)
11920 
 
11921 
class getItemsByRiskyFlag_args:
11922 
 
11923 
  thrift_spec = (
11924 
  )
11925 
 
11926 
  def read(self, iprot):
11927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11929 
      return
11930 
    iprot.readStructBegin()
11931 
    while True:
11932 
      (fname, ftype, fid) = iprot.readFieldBegin()
11933 
      if ftype == TType.STOP:
11934 
        break
11935 
      else:
11936 
        iprot.skip(ftype)
11937 
      iprot.readFieldEnd()
11938 
    iprot.readStructEnd()
11939 
 
11940 
  def write(self, oprot):
11941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11943 
      return
11944 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
11945 
    oprot.writeFieldStop()
11946 
    oprot.writeStructEnd()
11947 
 
11948 
  def validate(self):
11949 
    return
11950 
 
11951 
 
11952 
  def __repr__(self):
11953 
    L = ['%s=%r' % (key, value)
11954 
      for key, value in self.__dict__.iteritems()]
11955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11956 
 
11957 
  def __eq__(self, other):
11958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11959 
 
11960 
  def __ne__(self, other):
11961 
    return not (self == other)
11962 
 
11963 
class getItemsByRiskyFlag_result:
11964 
  """
11965 
  Attributes:
11966 
   - success
11967 
  """
11968 
 
11969 
  thrift_spec = (
11970 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
11971 
  )
11972 
 
11973 
  def __init__(self, success=None,):
11974 
    self.success = success
11975 
 
11976 
  def read(self, iprot):
11977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11979 
      return
11980 
    iprot.readStructBegin()
11981 
    while True:
11982 
      (fname, ftype, fid) = iprot.readFieldBegin()
11983 
      if ftype == TType.STOP:
11984 
        break
11985 
      if fid == 0:
11986 
        if ftype == TType.LIST:
11987 
          self.success = []
6850 kshitij.so 11988 
          (_etype189, _size186) = iprot.readListBegin()
11989 
          for _i190 in xrange(_size186):
11990 
            _elem191 = Item()
11991 
            _elem191.read(iprot)
11992 
            self.success.append(_elem191)
5944 mandeep.dh 11993 
          iprot.readListEnd()
11994 
        else:
11995 
          iprot.skip(ftype)
11996 
      else:
11997 
        iprot.skip(ftype)
11998 
      iprot.readFieldEnd()
11999 
    iprot.readStructEnd()
12000 
 
12001 
  def write(self, oprot):
12002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12004 
      return
12005 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12006 
    if self.success is not None:
12007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12009 
      for iter192 in self.success:
12010 
        iter192.write(oprot)
5944 mandeep.dh 12011 
      oprot.writeListEnd()
12012 
      oprot.writeFieldEnd()
12013 
    oprot.writeFieldStop()
12014 
    oprot.writeStructEnd()
12015 
 
12016 
  def validate(self):
12017 
    return
12018 
 
12019 
 
12020 
  def __repr__(self):
12021 
    L = ['%s=%r' % (key, value)
12022 
      for key, value in self.__dict__.iteritems()]
12023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12024 
 
12025 
  def __eq__(self, other):
12026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12027 
 
12028 
  def __ne__(self, other):
12029 
    return not (self == other)
12030 
 
12031 
class getItemsForMasterSheet_args:
12032 
  """
12033 
  Attributes:
12034 
   - category
12035 
   - brand
12036 
  """
12037 
 
12038 
  thrift_spec = (
12039 
    None, # 0
12040 
    (1, TType.STRING, 'category', None, None, ), # 1
12041 
    (2, TType.STRING, 'brand', None, None, ), # 2
12042 
  )
12043 
 
12044 
  def __init__(self, category=None, brand=None,):
12045 
    self.category = category
12046 
    self.brand = brand
12047 
 
12048 
  def read(self, iprot):
12049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12051 
      return
12052 
    iprot.readStructBegin()
12053 
    while True:
12054 
      (fname, ftype, fid) = iprot.readFieldBegin()
12055 
      if ftype == TType.STOP:
12056 
        break
12057 
      if fid == 1:
12058 
        if ftype == TType.STRING:
12059 
          self.category = iprot.readString();
12060 
        else:
12061 
          iprot.skip(ftype)
12062 
      elif fid == 2:
12063 
        if ftype == TType.STRING:
12064 
          self.brand = iprot.readString();
12065 
        else:
12066 
          iprot.skip(ftype)
12067 
      else:
12068 
        iprot.skip(ftype)
12069 
      iprot.readFieldEnd()
12070 
    iprot.readStructEnd()
12071 
 
12072 
  def write(self, oprot):
12073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12075 
      return
12076 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12077 
    if self.category is not None:
12078 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12079 
      oprot.writeString(self.category)
12080 
      oprot.writeFieldEnd()
12081 
    if self.brand is not None:
12082 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12083 
      oprot.writeString(self.brand)
12084 
      oprot.writeFieldEnd()
12085 
    oprot.writeFieldStop()
12086 
    oprot.writeStructEnd()
12087 
 
12088 
  def validate(self):
12089 
    return
12090 
 
12091 
 
12092 
  def __repr__(self):
12093 
    L = ['%s=%r' % (key, value)
12094 
      for key, value in self.__dict__.iteritems()]
12095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12096 
 
12097 
  def __eq__(self, other):
12098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12099 
 
12100 
  def __ne__(self, other):
12101 
    return not (self == other)
12102 
 
12103 
class getItemsForMasterSheet_result:
12104 
  """
12105 
  Attributes:
12106 
   - success
12107 
  """
12108 
 
12109 
  thrift_spec = (
12110 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12111 
  )
12112 
 
12113 
  def __init__(self, success=None,):
12114 
    self.success = success
12115 
 
12116 
  def read(self, iprot):
12117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12119 
      return
12120 
    iprot.readStructBegin()
12121 
    while True:
12122 
      (fname, ftype, fid) = iprot.readFieldBegin()
12123 
      if ftype == TType.STOP:
12124 
        break
12125 
      if fid == 0:
12126 
        if ftype == TType.LIST:
12127 
          self.success = []
6850 kshitij.so 12128 
          (_etype196, _size193) = iprot.readListBegin()
12129 
          for _i197 in xrange(_size193):
12130 
            _elem198 = Item()
12131 
            _elem198.read(iprot)
12132 
            self.success.append(_elem198)
5944 mandeep.dh 12133 
          iprot.readListEnd()
12134 
        else:
12135 
          iprot.skip(ftype)
12136 
      else:
12137 
        iprot.skip(ftype)
12138 
      iprot.readFieldEnd()
12139 
    iprot.readStructEnd()
12140 
 
12141 
  def write(self, oprot):
12142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12144 
      return
12145 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12146 
    if self.success is not None:
12147 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12148 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12149 
      for iter199 in self.success:
12150 
        iter199.write(oprot)
5944 mandeep.dh 12151 
      oprot.writeListEnd()
12152 
      oprot.writeFieldEnd()
12153 
    oprot.writeFieldStop()
12154 
    oprot.writeStructEnd()
12155 
 
12156 
  def validate(self):
12157 
    return
12158 
 
12159 
 
12160 
  def __repr__(self):
12161 
    L = ['%s=%r' % (key, value)
12162 
      for key, value in self.__dict__.iteritems()]
12163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12164 
 
12165 
  def __eq__(self, other):
12166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12167 
 
12168 
  def __ne__(self, other):
12169 
    return not (self == other)
12170 
 
12171 
class getSimilarItemsCatalogIds_args:
12172 
  """
12173 
  Attributes:
12174 
   - beginIndex
12175 
   - totalItems
12176 
   - itemId
12177 
  """
12178 
 
12179 
  thrift_spec = (
12180 
    None, # 0
12181 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12182 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12183 
    (3, TType.I64, 'itemId', None, None, ), # 3
12184 
  )
12185 
 
12186 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12187 
    self.beginIndex = beginIndex
12188 
    self.totalItems = totalItems
12189 
    self.itemId = itemId
12190 
 
12191 
  def read(self, iprot):
12192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12194 
      return
12195 
    iprot.readStructBegin()
12196 
    while True:
12197 
      (fname, ftype, fid) = iprot.readFieldBegin()
12198 
      if ftype == TType.STOP:
12199 
        break
12200 
      if fid == 1:
12201 
        if ftype == TType.I64:
12202 
          self.beginIndex = iprot.readI64();
12203 
        else:
12204 
          iprot.skip(ftype)
12205 
      elif fid == 2:
12206 
        if ftype == TType.I64:
12207 
          self.totalItems = iprot.readI64();
12208 
        else:
12209 
          iprot.skip(ftype)
12210 
      elif fid == 3:
12211 
        if ftype == TType.I64:
12212 
          self.itemId = iprot.readI64();
12213 
        else:
12214 
          iprot.skip(ftype)
12215 
      else:
12216 
        iprot.skip(ftype)
12217 
      iprot.readFieldEnd()
12218 
    iprot.readStructEnd()
12219 
 
12220 
  def write(self, oprot):
12221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12223 
      return
12224 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12225 
    if self.beginIndex is not None:
12226 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12227 
      oprot.writeI64(self.beginIndex)
12228 
      oprot.writeFieldEnd()
12229 
    if self.totalItems is not None:
12230 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12231 
      oprot.writeI64(self.totalItems)
12232 
      oprot.writeFieldEnd()
12233 
    if self.itemId is not None:
12234 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12235 
      oprot.writeI64(self.itemId)
12236 
      oprot.writeFieldEnd()
12237 
    oprot.writeFieldStop()
12238 
    oprot.writeStructEnd()
12239 
 
12240 
  def validate(self):
12241 
    return
12242 
 
12243 
 
12244 
  def __repr__(self):
12245 
    L = ['%s=%r' % (key, value)
12246 
      for key, value in self.__dict__.iteritems()]
12247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12248 
 
12249 
  def __eq__(self, other):
12250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12251 
 
12252 
  def __ne__(self, other):
12253 
    return not (self == other)
12254 
 
12255 
class getSimilarItemsCatalogIds_result:
12256 
  """
12257 
  Attributes:
12258 
   - success
12259 
  """
12260 
 
12261 
  thrift_spec = (
12262 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12263 
  )
12264 
 
12265 
  def __init__(self, success=None,):
12266 
    self.success = success
12267 
 
12268 
  def read(self, iprot):
12269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12271 
      return
12272 
    iprot.readStructBegin()
12273 
    while True:
12274 
      (fname, ftype, fid) = iprot.readFieldBegin()
12275 
      if ftype == TType.STOP:
12276 
        break
12277 
      if fid == 0:
12278 
        if ftype == TType.LIST:
12279 
          self.success = []
6850 kshitij.so 12280 
          (_etype203, _size200) = iprot.readListBegin()
12281 
          for _i204 in xrange(_size200):
12282 
            _elem205 = iprot.readI64();
12283 
            self.success.append(_elem205)
5944 mandeep.dh 12284 
          iprot.readListEnd()
12285 
        else:
12286 
          iprot.skip(ftype)
12287 
      else:
12288 
        iprot.skip(ftype)
12289 
      iprot.readFieldEnd()
12290 
    iprot.readStructEnd()
12291 
 
12292 
  def write(self, oprot):
12293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12295 
      return
12296 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12297 
    if self.success is not None:
12298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12299 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12300 
      for iter206 in self.success:
12301 
        oprot.writeI64(iter206)
5944 mandeep.dh 12302 
      oprot.writeListEnd()
12303 
      oprot.writeFieldEnd()
12304 
    oprot.writeFieldStop()
12305 
    oprot.writeStructEnd()
12306 
 
12307 
  def validate(self):
12308 
    return
12309 
 
12310 
 
12311 
  def __repr__(self):
12312 
    L = ['%s=%r' % (key, value)
12313 
      for key, value in self.__dict__.iteritems()]
12314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12315 
 
12316 
  def __eq__(self, other):
12317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12318 
 
12319 
  def __ne__(self, other):
12320 
    return not (self == other)
12321 
 
12322 
class addProductNotification_args:
12323 
  """
12324 
  Attributes:
12325 
   - itemId
12326 
   - email
12327 
  """
12328 
 
12329 
  thrift_spec = None
12330 
  def __init__(self, itemId=None, email=None,):
12331 
    self.itemId = itemId
12332 
    self.email = email
12333 
 
12334 
  def read(self, iprot):
12335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12337 
      return
12338 
    iprot.readStructBegin()
12339 
    while True:
12340 
      (fname, ftype, fid) = iprot.readFieldBegin()
12341 
      if ftype == TType.STOP:
12342 
        break
12343 
      if fid == -1:
12344 
        if ftype == TType.I64:
12345 
          self.itemId = iprot.readI64();
12346 
        else:
12347 
          iprot.skip(ftype)
12348 
      elif fid == -2:
12349 
        if ftype == TType.STRING:
12350 
          self.email = iprot.readString();
12351 
        else:
12352 
          iprot.skip(ftype)
12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
12362 
    oprot.writeStructBegin('addProductNotification_args')
12363 
    if self.email is not None:
12364 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12365 
      oprot.writeString(self.email)
12366 
      oprot.writeFieldEnd()
12367 
    if self.itemId is not None:
12368 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12369 
      oprot.writeI64(self.itemId)
12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
12374 
  def validate(self):
12375 
    return
12376 
 
12377 
 
12378 
  def __repr__(self):
12379 
    L = ['%s=%r' % (key, value)
12380 
      for key, value in self.__dict__.iteritems()]
12381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12382 
 
12383 
  def __eq__(self, other):
12384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12385 
 
12386 
  def __ne__(self, other):
12387 
    return not (self == other)
12388 
 
12389 
class addProductNotification_result:
12390 
  """
12391 
  Attributes:
12392 
   - success
12393 
  """
12394 
 
12395 
  thrift_spec = (
12396 
    (0, TType.BOOL, 'success', None, None, ), # 0
12397 
  )
12398 
 
12399 
  def __init__(self, success=None,):
12400 
    self.success = success
12401 
 
12402 
  def read(self, iprot):
12403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12405 
      return
12406 
    iprot.readStructBegin()
12407 
    while True:
12408 
      (fname, ftype, fid) = iprot.readFieldBegin()
12409 
      if ftype == TType.STOP:
12410 
        break
12411 
      if fid == 0:
12412 
        if ftype == TType.BOOL:
12413 
          self.success = iprot.readBool();
12414 
        else:
12415 
          iprot.skip(ftype)
12416 
      else:
12417 
        iprot.skip(ftype)
12418 
      iprot.readFieldEnd()
12419 
    iprot.readStructEnd()
12420 
 
12421 
  def write(self, oprot):
12422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12424 
      return
12425 
    oprot.writeStructBegin('addProductNotification_result')
12426 
    if self.success is not None:
12427 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12428 
      oprot.writeBool(self.success)
12429 
      oprot.writeFieldEnd()
12430 
    oprot.writeFieldStop()
12431 
    oprot.writeStructEnd()
12432 
 
12433 
  def validate(self):
12434 
    return
12435 
 
12436 
 
12437 
  def __repr__(self):
12438 
    L = ['%s=%r' % (key, value)
12439 
      for key, value in self.__dict__.iteritems()]
12440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12441 
 
12442 
  def __eq__(self, other):
12443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12444 
 
12445 
  def __ne__(self, other):
12446 
    return not (self == other)
12447 
 
12448 
class sendProductNotifications_args:
12449 
 
12450 
  thrift_spec = (
12451 
  )
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      else:
12463 
        iprot.skip(ftype)
12464 
      iprot.readFieldEnd()
12465 
    iprot.readStructEnd()
12466 
 
12467 
  def write(self, oprot):
12468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12470 
      return
12471 
    oprot.writeStructBegin('sendProductNotifications_args')
12472 
    oprot.writeFieldStop()
12473 
    oprot.writeStructEnd()
12474 
 
12475 
  def validate(self):
12476 
    return
12477 
 
12478 
 
12479 
  def __repr__(self):
12480 
    L = ['%s=%r' % (key, value)
12481 
      for key, value in self.__dict__.iteritems()]
12482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12483 
 
12484 
  def __eq__(self, other):
12485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12486 
 
12487 
  def __ne__(self, other):
12488 
    return not (self == other)
12489 
 
12490 
class sendProductNotifications_result:
12491 
  """
12492 
  Attributes:
12493 
   - success
12494 
  """
12495 
 
12496 
  thrift_spec = (
12497 
    (0, TType.BOOL, 'success', None, None, ), # 0
12498 
  )
12499 
 
12500 
  def __init__(self, success=None,):
12501 
    self.success = success
12502 
 
12503 
  def read(self, iprot):
12504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12506 
      return
12507 
    iprot.readStructBegin()
12508 
    while True:
12509 
      (fname, ftype, fid) = iprot.readFieldBegin()
12510 
      if ftype == TType.STOP:
12511 
        break
12512 
      if fid == 0:
12513 
        if ftype == TType.BOOL:
12514 
          self.success = iprot.readBool();
12515 
        else:
12516 
          iprot.skip(ftype)
12517 
      else:
12518 
        iprot.skip(ftype)
12519 
      iprot.readFieldEnd()
12520 
    iprot.readStructEnd()
12521 
 
12522 
  def write(self, oprot):
12523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12525 
      return
12526 
    oprot.writeStructBegin('sendProductNotifications_result')
12527 
    if self.success is not None:
12528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12529 
      oprot.writeBool(self.success)
12530 
      oprot.writeFieldEnd()
12531 
    oprot.writeFieldStop()
12532 
    oprot.writeStructEnd()
12533 
 
12534 
  def validate(self):
12535 
    return
12536 
 
12537 
 
12538 
  def __repr__(self):
12539 
    L = ['%s=%r' % (key, value)
12540 
      for key, value in self.__dict__.iteritems()]
12541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12542 
 
12543 
  def __eq__(self, other):
12544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12545 
 
12546 
  def __ne__(self, other):
12547 
    return not (self == other)
12548 
 
12549 
class getAllBrandsByCategory_args:
12550 
  """
12551 
  Attributes:
12552 
   - categoryId
12553 
  """
12554 
 
12555 
  thrift_spec = (
12556 
    None, # 0
12557 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12558 
  )
12559 
 
12560 
  def __init__(self, categoryId=None,):
12561 
    self.categoryId = categoryId
12562 
 
12563 
  def read(self, iprot):
12564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12566 
      return
12567 
    iprot.readStructBegin()
12568 
    while True:
12569 
      (fname, ftype, fid) = iprot.readFieldBegin()
12570 
      if ftype == TType.STOP:
12571 
        break
12572 
      if fid == 1:
12573 
        if ftype == TType.I64:
12574 
          self.categoryId = iprot.readI64();
12575 
        else:
12576 
          iprot.skip(ftype)
12577 
      else:
12578 
        iprot.skip(ftype)
12579 
      iprot.readFieldEnd()
12580 
    iprot.readStructEnd()
12581 
 
12582 
  def write(self, oprot):
12583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12585 
      return
12586 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12587 
    if self.categoryId is not None:
12588 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12589 
      oprot.writeI64(self.categoryId)
12590 
      oprot.writeFieldEnd()
12591 
    oprot.writeFieldStop()
12592 
    oprot.writeStructEnd()
12593 
 
12594 
  def validate(self):
12595 
    return
12596 
 
12597 
 
12598 
  def __repr__(self):
12599 
    L = ['%s=%r' % (key, value)
12600 
      for key, value in self.__dict__.iteritems()]
12601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12602 
 
12603 
  def __eq__(self, other):
12604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12605 
 
12606 
  def __ne__(self, other):
12607 
    return not (self == other)
12608 
 
12609 
class getAllBrandsByCategory_result:
12610 
  """
12611 
  Attributes:
12612 
   - success
12613 
  """
12614 
 
12615 
  thrift_spec = (
12616 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12617 
  )
12618 
 
12619 
  def __init__(self, success=None,):
12620 
    self.success = success
12621 
 
12622 
  def read(self, iprot):
12623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12625 
      return
12626 
    iprot.readStructBegin()
12627 
    while True:
12628 
      (fname, ftype, fid) = iprot.readFieldBegin()
12629 
      if ftype == TType.STOP:
12630 
        break
12631 
      if fid == 0:
12632 
        if ftype == TType.LIST:
12633 
          self.success = []
6850 kshitij.so 12634 
          (_etype210, _size207) = iprot.readListBegin()
12635 
          for _i211 in xrange(_size207):
12636 
            _elem212 = iprot.readString();
12637 
            self.success.append(_elem212)
5944 mandeep.dh 12638 
          iprot.readListEnd()
12639 
        else:
12640 
          iprot.skip(ftype)
12641 
      else:
12642 
        iprot.skip(ftype)
12643 
      iprot.readFieldEnd()
12644 
    iprot.readStructEnd()
12645 
 
12646 
  def write(self, oprot):
12647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12649 
      return
12650 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12651 
    if self.success is not None:
12652 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12653 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12654 
      for iter213 in self.success:
12655 
        oprot.writeString(iter213)
5944 mandeep.dh 12656 
      oprot.writeListEnd()
12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
12676 
class getAllBrands_args:
12677 
 
12678 
  thrift_spec = (
12679 
  )
12680 
 
12681 
  def read(self, iprot):
12682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12684 
      return
12685 
    iprot.readStructBegin()
12686 
    while True:
12687 
      (fname, ftype, fid) = iprot.readFieldBegin()
12688 
      if ftype == TType.STOP:
12689 
        break
12690 
      else:
12691 
        iprot.skip(ftype)
12692 
      iprot.readFieldEnd()
12693 
    iprot.readStructEnd()
12694 
 
12695 
  def write(self, oprot):
12696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12698 
      return
12699 
    oprot.writeStructBegin('getAllBrands_args')
12700 
    oprot.writeFieldStop()
12701 
    oprot.writeStructEnd()
12702 
 
12703 
  def validate(self):
12704 
    return
12705 
 
12706 
 
12707 
  def __repr__(self):
12708 
    L = ['%s=%r' % (key, value)
12709 
      for key, value in self.__dict__.iteritems()]
12710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12711 
 
12712 
  def __eq__(self, other):
12713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12714 
 
12715 
  def __ne__(self, other):
12716 
    return not (self == other)
12717 
 
12718 
class getAllBrands_result:
12719 
  """
12720 
  Attributes:
12721 
   - success
12722 
  """
12723 
 
12724 
  thrift_spec = (
12725 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12726 
  )
12727 
 
12728 
  def __init__(self, success=None,):
12729 
    self.success = success
12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
12740 
      if fid == 0:
12741 
        if ftype == TType.LIST:
12742 
          self.success = []
6850 kshitij.so 12743 
          (_etype217, _size214) = iprot.readListBegin()
12744 
          for _i218 in xrange(_size214):
12745 
            _elem219 = iprot.readString();
12746 
            self.success.append(_elem219)
5944 mandeep.dh 12747 
          iprot.readListEnd()
12748 
        else:
12749 
          iprot.skip(ftype)
12750 
      else:
12751 
        iprot.skip(ftype)
12752 
      iprot.readFieldEnd()
12753 
    iprot.readStructEnd()
12754 
 
12755 
  def write(self, oprot):
12756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12758 
      return
12759 
    oprot.writeStructBegin('getAllBrands_result')
12760 
    if self.success is not None:
12761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12762 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12763 
      for iter220 in self.success:
12764 
        oprot.writeString(iter220)
5944 mandeep.dh 12765 
      oprot.writeListEnd()
12766 
      oprot.writeFieldEnd()
12767 
    oprot.writeFieldStop()
12768 
    oprot.writeStructEnd()
12769 
 
12770 
  def validate(self):
12771 
    return
12772 
 
12773 
 
12774 
  def __repr__(self):
12775 
    L = ['%s=%r' % (key, value)
12776 
      for key, value in self.__dict__.iteritems()]
12777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12778 
 
12779 
  def __eq__(self, other):
12780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12781 
 
12782 
  def __ne__(self, other):
12783 
    return not (self == other)
12784 
 
12785 
class getAllSources_args:
12786 
 
12787 
  thrift_spec = (
12788 
  )
12789 
 
12790 
  def read(self, iprot):
12791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12793 
      return
12794 
    iprot.readStructBegin()
12795 
    while True:
12796 
      (fname, ftype, fid) = iprot.readFieldBegin()
12797 
      if ftype == TType.STOP:
12798 
        break
12799 
      else:
12800 
        iprot.skip(ftype)
12801 
      iprot.readFieldEnd()
12802 
    iprot.readStructEnd()
12803 
 
12804 
  def write(self, oprot):
12805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12807 
      return
12808 
    oprot.writeStructBegin('getAllSources_args')
12809 
    oprot.writeFieldStop()
12810 
    oprot.writeStructEnd()
12811 
 
12812 
  def validate(self):
12813 
    return
12814 
 
12815 
 
12816 
  def __repr__(self):
12817 
    L = ['%s=%r' % (key, value)
12818 
      for key, value in self.__dict__.iteritems()]
12819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12820 
 
12821 
  def __eq__(self, other):
12822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12823 
 
12824 
  def __ne__(self, other):
12825 
    return not (self == other)
12826 
 
12827 
class getAllSources_result:
12828 
  """
12829 
  Attributes:
12830 
   - success
12831 
  """
12832 
 
12833 
  thrift_spec = (
12834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12835 
  )
12836 
 
12837 
  def __init__(self, success=None,):
12838 
    self.success = success
12839 
 
12840 
  def read(self, iprot):
12841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12843 
      return
12844 
    iprot.readStructBegin()
12845 
    while True:
12846 
      (fname, ftype, fid) = iprot.readFieldBegin()
12847 
      if ftype == TType.STOP:
12848 
        break
12849 
      if fid == 0:
12850 
        if ftype == TType.LIST:
12851 
          self.success = []
6850 kshitij.so 12852 
          (_etype224, _size221) = iprot.readListBegin()
12853 
          for _i225 in xrange(_size221):
12854 
            _elem226 = Source()
12855 
            _elem226.read(iprot)
12856 
            self.success.append(_elem226)
5944 mandeep.dh 12857 
          iprot.readListEnd()
12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
12869 
    oprot.writeStructBegin('getAllSources_result')
12870 
    if self.success is not None:
12871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12873 
      for iter227 in self.success:
12874 
        iter227.write(oprot)
5944 mandeep.dh 12875 
      oprot.writeListEnd()
12876 
      oprot.writeFieldEnd()
12877 
    oprot.writeFieldStop()
12878 
    oprot.writeStructEnd()
12879 
 
12880 
  def validate(self):
12881 
    return
12882 
 
12883 
 
12884 
  def __repr__(self):
12885 
    L = ['%s=%r' % (key, value)
12886 
      for key, value in self.__dict__.iteritems()]
12887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12888 
 
12889 
  def __eq__(self, other):
12890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12891 
 
12892 
  def __ne__(self, other):
12893 
    return not (self == other)
12894 
 
12895 
class getItemPricingBySource_args:
12896 
  """
12897 
  Attributes:
12898 
   - itemId
12899 
   - sourceId
12900 
  """
12901 
 
12902 
  thrift_spec = (
12903 
    None, # 0
12904 
    (1, TType.I64, 'itemId', None, None, ), # 1
12905 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12906 
  )
12907 
 
12908 
  def __init__(self, itemId=None, sourceId=None,):
12909 
    self.itemId = itemId
12910 
    self.sourceId = sourceId
12911 
 
12912 
  def read(self, iprot):
12913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12915 
      return
12916 
    iprot.readStructBegin()
12917 
    while True:
12918 
      (fname, ftype, fid) = iprot.readFieldBegin()
12919 
      if ftype == TType.STOP:
12920 
        break
12921 
      if fid == 1:
12922 
        if ftype == TType.I64:
12923 
          self.itemId = iprot.readI64();
12924 
        else:
12925 
          iprot.skip(ftype)
12926 
      elif fid == 2:
12927 
        if ftype == TType.I64:
12928 
          self.sourceId = iprot.readI64();
12929 
        else:
12930 
          iprot.skip(ftype)
12931 
      else:
12932 
        iprot.skip(ftype)
12933 
      iprot.readFieldEnd()
12934 
    iprot.readStructEnd()
12935 
 
12936 
  def write(self, oprot):
12937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12939 
      return
12940 
    oprot.writeStructBegin('getItemPricingBySource_args')
12941 
    if self.itemId is not None:
12942 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12943 
      oprot.writeI64(self.itemId)
12944 
      oprot.writeFieldEnd()
12945 
    if self.sourceId is not None:
12946 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
12947 
      oprot.writeI64(self.sourceId)
12948 
      oprot.writeFieldEnd()
12949 
    oprot.writeFieldStop()
12950 
    oprot.writeStructEnd()
12951 
 
12952 
  def validate(self):
12953 
    return
12954 
 
12955 
 
12956 
  def __repr__(self):
12957 
    L = ['%s=%r' % (key, value)
12958 
      for key, value in self.__dict__.iteritems()]
12959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12960 
 
12961 
  def __eq__(self, other):
12962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12963 
 
12964 
  def __ne__(self, other):
12965 
    return not (self == other)
12966 
 
12967 
class getItemPricingBySource_result:
12968 
  """
12969 
  Attributes:
12970 
   - success
12971 
   - cex
12972 
  """
12973 
 
12974 
  thrift_spec = (
12975 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
12976 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
12977 
  )
12978 
 
12979 
  def __init__(self, success=None, cex=None,):
12980 
    self.success = success
12981 
    self.cex = cex
12982 
 
12983 
  def read(self, iprot):
12984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12986 
      return
12987 
    iprot.readStructBegin()
12988 
    while True:
12989 
      (fname, ftype, fid) = iprot.readFieldBegin()
12990 
      if ftype == TType.STOP:
12991 
        break
12992 
      if fid == 0:
12993 
        if ftype == TType.STRUCT:
12994 
          self.success = SourceItemPricing()
12995 
          self.success.read(iprot)
12996 
        else:
12997 
          iprot.skip(ftype)
12998 
      elif fid == 1:
12999 
        if ftype == TType.STRUCT:
13000 
          self.cex = CatalogServiceException()
13001 
          self.cex.read(iprot)
13002 
        else:
13003 
          iprot.skip(ftype)
13004 
      else:
13005 
        iprot.skip(ftype)
13006 
      iprot.readFieldEnd()
13007 
    iprot.readStructEnd()
13008 
 
13009 
  def write(self, oprot):
13010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13012 
      return
13013 
    oprot.writeStructBegin('getItemPricingBySource_result')
13014 
    if self.success is not None:
13015 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13016 
      self.success.write(oprot)
13017 
      oprot.writeFieldEnd()
13018 
    if self.cex is not None:
13019 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13020 
      self.cex.write(oprot)
13021 
      oprot.writeFieldEnd()
13022 
    oprot.writeFieldStop()
13023 
    oprot.writeStructEnd()
13024 
 
13025 
  def validate(self):
13026 
    return
13027 
 
13028 
 
13029 
  def __repr__(self):
13030 
    L = ['%s=%r' % (key, value)
13031 
      for key, value in self.__dict__.iteritems()]
13032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13033 
 
13034 
  def __eq__(self, other):
13035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13036 
 
13037 
  def __ne__(self, other):
13038 
    return not (self == other)
13039 
 
13040 
class addSourceItemPricing_args:
13041 
  """
13042 
  Attributes:
13043 
   - sourceItemPricing
13044 
  """
13045 
 
13046 
  thrift_spec = (
13047 
    None, # 0
13048 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13049 
  )
13050 
 
13051 
  def __init__(self, sourceItemPricing=None,):
13052 
    self.sourceItemPricing = sourceItemPricing
13053 
 
13054 
  def read(self, iprot):
13055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13057 
      return
13058 
    iprot.readStructBegin()
13059 
    while True:
13060 
      (fname, ftype, fid) = iprot.readFieldBegin()
13061 
      if ftype == TType.STOP:
13062 
        break
13063 
      if fid == 1:
13064 
        if ftype == TType.STRUCT:
13065 
          self.sourceItemPricing = SourceItemPricing()
13066 
          self.sourceItemPricing.read(iprot)
13067 
        else:
13068 
          iprot.skip(ftype)
13069 
      else:
13070 
        iprot.skip(ftype)
13071 
      iprot.readFieldEnd()
13072 
    iprot.readStructEnd()
13073 
 
13074 
  def write(self, oprot):
13075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13077 
      return
13078 
    oprot.writeStructBegin('addSourceItemPricing_args')
13079 
    if self.sourceItemPricing is not None:
13080 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13081 
      self.sourceItemPricing.write(oprot)
13082 
      oprot.writeFieldEnd()
13083 
    oprot.writeFieldStop()
13084 
    oprot.writeStructEnd()
13085 
 
13086 
  def validate(self):
13087 
    return
13088 
 
13089 
 
13090 
  def __repr__(self):
13091 
    L = ['%s=%r' % (key, value)
13092 
      for key, value in self.__dict__.iteritems()]
13093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13094 
 
13095 
  def __eq__(self, other):
13096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13097 
 
13098 
  def __ne__(self, other):
13099 
    return not (self == other)
13100 
 
13101 
class addSourceItemPricing_result:
13102 
  """
13103 
  Attributes:
13104 
   - cex
13105 
  """
13106 
 
13107 
  thrift_spec = (
13108 
    None, # 0
13109 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13110 
  )
13111 
 
13112 
  def __init__(self, cex=None,):
13113 
    self.cex = cex
13114 
 
13115 
  def read(self, iprot):
13116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13118 
      return
13119 
    iprot.readStructBegin()
13120 
    while True:
13121 
      (fname, ftype, fid) = iprot.readFieldBegin()
13122 
      if ftype == TType.STOP:
13123 
        break
13124 
      if fid == 1:
13125 
        if ftype == TType.STRUCT:
13126 
          self.cex = CatalogServiceException()
13127 
          self.cex.read(iprot)
13128 
        else:
13129 
          iprot.skip(ftype)
13130 
      else:
13131 
        iprot.skip(ftype)
13132 
      iprot.readFieldEnd()
13133 
    iprot.readStructEnd()
13134 
 
13135 
  def write(self, oprot):
13136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13138 
      return
13139 
    oprot.writeStructBegin('addSourceItemPricing_result')
13140 
    if self.cex is not None:
13141 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13142 
      self.cex.write(oprot)
13143 
      oprot.writeFieldEnd()
13144 
    oprot.writeFieldStop()
13145 
    oprot.writeStructEnd()
13146 
 
13147 
  def validate(self):
13148 
    return
13149 
 
13150 
 
13151 
  def __repr__(self):
13152 
    L = ['%s=%r' % (key, value)
13153 
      for key, value in self.__dict__.iteritems()]
13154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13155 
 
13156 
  def __eq__(self, other):
13157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13158 
 
13159 
  def __ne__(self, other):
13160 
    return not (self == other)
13161 
 
13162 
class getAllSourcePricing_args:
13163 
  """
13164 
  Attributes:
13165 
   - itemId
13166 
  """
13167 
 
13168 
  thrift_spec = (
13169 
    None, # 0
13170 
    (1, TType.I64, 'itemId', None, None, ), # 1
13171 
  )
13172 
 
13173 
  def __init__(self, itemId=None,):
13174 
    self.itemId = itemId
13175 
 
13176 
  def read(self, iprot):
13177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13179 
      return
13180 
    iprot.readStructBegin()
13181 
    while True:
13182 
      (fname, ftype, fid) = iprot.readFieldBegin()
13183 
      if ftype == TType.STOP:
13184 
        break
13185 
      if fid == 1:
13186 
        if ftype == TType.I64:
13187 
          self.itemId = iprot.readI64();
13188 
        else:
13189 
          iprot.skip(ftype)
13190 
      else:
13191 
        iprot.skip(ftype)
13192 
      iprot.readFieldEnd()
13193 
    iprot.readStructEnd()
13194 
 
13195 
  def write(self, oprot):
13196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13198 
      return
13199 
    oprot.writeStructBegin('getAllSourcePricing_args')
13200 
    if self.itemId is not None:
13201 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13202 
      oprot.writeI64(self.itemId)
13203 
      oprot.writeFieldEnd()
13204 
    oprot.writeFieldStop()
13205 
    oprot.writeStructEnd()
13206 
 
13207 
  def validate(self):
13208 
    return
13209 
 
13210 
 
13211 
  def __repr__(self):
13212 
    L = ['%s=%r' % (key, value)
13213 
      for key, value in self.__dict__.iteritems()]
13214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13215 
 
13216 
  def __eq__(self, other):
13217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13218 
 
13219 
  def __ne__(self, other):
13220 
    return not (self == other)
13221 
 
13222 
class getAllSourcePricing_result:
13223 
  """
13224 
  Attributes:
13225 
   - success
13226 
   - cex
13227 
  """
13228 
 
13229 
  thrift_spec = (
13230 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13231 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13232 
  )
13233 
 
13234 
  def __init__(self, success=None, cex=None,):
13235 
    self.success = success
13236 
    self.cex = cex
13237 
 
13238 
  def read(self, iprot):
13239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13241 
      return
13242 
    iprot.readStructBegin()
13243 
    while True:
13244 
      (fname, ftype, fid) = iprot.readFieldBegin()
13245 
      if ftype == TType.STOP:
13246 
        break
13247 
      if fid == 0:
13248 
        if ftype == TType.LIST:
13249 
          self.success = []
6850 kshitij.so 13250 
          (_etype231, _size228) = iprot.readListBegin()
13251 
          for _i232 in xrange(_size228):
13252 
            _elem233 = SourceItemPricing()
13253 
            _elem233.read(iprot)
13254 
            self.success.append(_elem233)
5944 mandeep.dh 13255 
          iprot.readListEnd()
13256 
        else:
13257 
          iprot.skip(ftype)
13258 
      elif fid == 1:
13259 
        if ftype == TType.STRUCT:
13260 
          self.cex = CatalogServiceException()
13261 
          self.cex.read(iprot)
13262 
        else:
13263 
          iprot.skip(ftype)
13264 
      else:
13265 
        iprot.skip(ftype)
13266 
      iprot.readFieldEnd()
13267 
    iprot.readStructEnd()
13268 
 
13269 
  def write(self, oprot):
13270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13272 
      return
13273 
    oprot.writeStructBegin('getAllSourcePricing_result')
13274 
    if self.success is not None:
13275 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13276 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13277 
      for iter234 in self.success:
13278 
        iter234.write(oprot)
5944 mandeep.dh 13279 
      oprot.writeListEnd()
13280 
      oprot.writeFieldEnd()
13281 
    if self.cex is not None:
13282 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13283 
      self.cex.write(oprot)
13284 
      oprot.writeFieldEnd()
13285 
    oprot.writeFieldStop()
13286 
    oprot.writeStructEnd()
13287 
 
13288 
  def validate(self):
13289 
    return
13290 
 
13291 
 
13292 
  def __repr__(self):
13293 
    L = ['%s=%r' % (key, value)
13294 
      for key, value in self.__dict__.iteritems()]
13295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13296 
 
13297 
  def __eq__(self, other):
13298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13299 
 
13300 
  def __ne__(self, other):
13301 
    return not (self == other)
13302 
 
13303 
class getItemForSource_args:
13304 
  """
13305 
  Attributes:
13306 
   - item_id
13307 
   - sourceId
13308 
  """
13309 
 
13310 
  thrift_spec = (
13311 
    None, # 0
13312 
    (1, TType.I64, 'item_id', None, None, ), # 1
13313 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13314 
  )
13315 
 
13316 
  def __init__(self, item_id=None, sourceId=None,):
13317 
    self.item_id = item_id
13318 
    self.sourceId = sourceId
13319 
 
13320 
  def read(self, iprot):
13321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13323 
      return
13324 
    iprot.readStructBegin()
13325 
    while True:
13326 
      (fname, ftype, fid) = iprot.readFieldBegin()
13327 
      if ftype == TType.STOP:
13328 
        break
13329 
      if fid == 1:
13330 
        if ftype == TType.I64:
13331 
          self.item_id = iprot.readI64();
13332 
        else:
13333 
          iprot.skip(ftype)
13334 
      elif fid == 2:
13335 
        if ftype == TType.I64:
13336 
          self.sourceId = iprot.readI64();
13337 
        else:
13338 
          iprot.skip(ftype)
13339 
      else:
13340 
        iprot.skip(ftype)
13341 
      iprot.readFieldEnd()
13342 
    iprot.readStructEnd()
13343 
 
13344 
  def write(self, oprot):
13345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13347 
      return
13348 
    oprot.writeStructBegin('getItemForSource_args')
13349 
    if self.item_id is not None:
13350 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13351 
      oprot.writeI64(self.item_id)
13352 
      oprot.writeFieldEnd()
13353 
    if self.sourceId is not None:
13354 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13355 
      oprot.writeI64(self.sourceId)
13356 
      oprot.writeFieldEnd()
13357 
    oprot.writeFieldStop()
13358 
    oprot.writeStructEnd()
13359 
 
13360 
  def validate(self):
13361 
    return
13362 
 
13363 
 
13364 
  def __repr__(self):
13365 
    L = ['%s=%r' % (key, value)
13366 
      for key, value in self.__dict__.iteritems()]
13367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13368 
 
13369 
  def __eq__(self, other):
13370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13371 
 
13372 
  def __ne__(self, other):
13373 
    return not (self == other)
13374 
 
13375 
class getItemForSource_result:
13376 
  """
13377 
  Attributes:
13378 
   - success
13379 
   - cex
13380 
  """
13381 
 
13382 
  thrift_spec = (
13383 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13384 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13385 
  )
13386 
 
13387 
  def __init__(self, success=None, cex=None,):
13388 
    self.success = success
13389 
    self.cex = cex
13390 
 
13391 
  def read(self, iprot):
13392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13394 
      return
13395 
    iprot.readStructBegin()
13396 
    while True:
13397 
      (fname, ftype, fid) = iprot.readFieldBegin()
13398 
      if ftype == TType.STOP:
13399 
        break
13400 
      if fid == 0:
13401 
        if ftype == TType.STRUCT:
13402 
          self.success = Item()
13403 
          self.success.read(iprot)
13404 
        else:
13405 
          iprot.skip(ftype)
13406 
      elif fid == 1:
13407 
        if ftype == TType.STRUCT:
13408 
          self.cex = CatalogServiceException()
13409 
          self.cex.read(iprot)
13410 
        else:
13411 
          iprot.skip(ftype)
13412 
      else:
13413 
        iprot.skip(ftype)
13414 
      iprot.readFieldEnd()
13415 
    iprot.readStructEnd()
13416 
 
13417 
  def write(self, oprot):
13418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13420 
      return
13421 
    oprot.writeStructBegin('getItemForSource_result')
13422 
    if self.success is not None:
13423 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13424 
      self.success.write(oprot)
13425 
      oprot.writeFieldEnd()
13426 
    if self.cex is not None:
13427 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13428 
      self.cex.write(oprot)
13429 
      oprot.writeFieldEnd()
13430 
    oprot.writeFieldStop()
13431 
    oprot.writeStructEnd()
13432 
 
13433 
  def validate(self):
13434 
    return
13435 
 
13436 
 
13437 
  def __repr__(self):
13438 
    L = ['%s=%r' % (key, value)
13439 
      for key, value in self.__dict__.iteritems()]
13440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13441 
 
13442 
  def __eq__(self, other):
13443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13444 
 
13445 
  def __ne__(self, other):
13446 
    return not (self == other)
13447 
 
13448 
class searchItemsInRange_args:
13449 
  """
13450 
  Attributes:
13451 
   - searchTerms
13452 
   - offset
13453 
   - limit
13454 
  """
13455 
 
13456 
  thrift_spec = (
13457 
    None, # 0
13458 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13459 
    (2, TType.I64, 'offset', None, None, ), # 2
13460 
    (3, TType.I64, 'limit', None, None, ), # 3
13461 
  )
13462 
 
13463 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13464 
    self.searchTerms = searchTerms
13465 
    self.offset = offset
13466 
    self.limit = limit
13467 
 
13468 
  def read(self, iprot):
13469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13471 
      return
13472 
    iprot.readStructBegin()
13473 
    while True:
13474 
      (fname, ftype, fid) = iprot.readFieldBegin()
13475 
      if ftype == TType.STOP:
13476 
        break
13477 
      if fid == 1:
13478 
        if ftype == TType.LIST:
13479 
          self.searchTerms = []
6850 kshitij.so 13480 
          (_etype238, _size235) = iprot.readListBegin()
13481 
          for _i239 in xrange(_size235):
13482 
            _elem240 = iprot.readString();
13483 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13484 
          iprot.readListEnd()
13485 
        else:
13486 
          iprot.skip(ftype)
13487 
      elif fid == 2:
13488 
        if ftype == TType.I64:
13489 
          self.offset = iprot.readI64();
13490 
        else:
13491 
          iprot.skip(ftype)
13492 
      elif fid == 3:
13493 
        if ftype == TType.I64:
13494 
          self.limit = iprot.readI64();
13495 
        else:
13496 
          iprot.skip(ftype)
13497 
      else:
13498 
        iprot.skip(ftype)
13499 
      iprot.readFieldEnd()
13500 
    iprot.readStructEnd()
13501 
 
13502 
  def write(self, oprot):
13503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13505 
      return
13506 
    oprot.writeStructBegin('searchItemsInRange_args')
13507 
    if self.searchTerms is not None:
13508 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13509 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13510 
      for iter241 in self.searchTerms:
13511 
        oprot.writeString(iter241)
5944 mandeep.dh 13512 
      oprot.writeListEnd()
13513 
      oprot.writeFieldEnd()
13514 
    if self.offset is not None:
13515 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13516 
      oprot.writeI64(self.offset)
13517 
      oprot.writeFieldEnd()
13518 
    if self.limit is not None:
13519 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13520 
      oprot.writeI64(self.limit)
13521 
      oprot.writeFieldEnd()
13522 
    oprot.writeFieldStop()
13523 
    oprot.writeStructEnd()
13524 
 
13525 
  def validate(self):
13526 
    return
13527 
 
13528 
 
13529 
  def __repr__(self):
13530 
    L = ['%s=%r' % (key, value)
13531 
      for key, value in self.__dict__.iteritems()]
13532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13533 
 
13534 
  def __eq__(self, other):
13535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13536 
 
13537 
  def __ne__(self, other):
13538 
    return not (self == other)
13539 
 
13540 
class searchItemsInRange_result:
13541 
  """
13542 
  Attributes:
13543 
   - success
13544 
  """
13545 
 
13546 
  thrift_spec = (
13547 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13548 
  )
13549 
 
13550 
  def __init__(self, success=None,):
13551 
    self.success = success
13552 
 
13553 
  def read(self, iprot):
13554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13556 
      return
13557 
    iprot.readStructBegin()
13558 
    while True:
13559 
      (fname, ftype, fid) = iprot.readFieldBegin()
13560 
      if ftype == TType.STOP:
13561 
        break
13562 
      if fid == 0:
13563 
        if ftype == TType.LIST:
13564 
          self.success = []
6850 kshitij.so 13565 
          (_etype245, _size242) = iprot.readListBegin()
13566 
          for _i246 in xrange(_size242):
13567 
            _elem247 = Item()
13568 
            _elem247.read(iprot)
13569 
            self.success.append(_elem247)
5944 mandeep.dh 13570 
          iprot.readListEnd()
13571 
        else:
13572 
          iprot.skip(ftype)
13573 
      else:
13574 
        iprot.skip(ftype)
13575 
      iprot.readFieldEnd()
13576 
    iprot.readStructEnd()
13577 
 
13578 
  def write(self, oprot):
13579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13581 
      return
13582 
    oprot.writeStructBegin('searchItemsInRange_result')
13583 
    if self.success is not None:
13584 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13585 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13586 
      for iter248 in self.success:
13587 
        iter248.write(oprot)
5944 mandeep.dh 13588 
      oprot.writeListEnd()
13589 
      oprot.writeFieldEnd()
13590 
    oprot.writeFieldStop()
13591 
    oprot.writeStructEnd()
13592 
 
13593 
  def validate(self):
13594 
    return
13595 
 
13596 
 
13597 
  def __repr__(self):
13598 
    L = ['%s=%r' % (key, value)
13599 
      for key, value in self.__dict__.iteritems()]
13600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13601 
 
13602 
  def __eq__(self, other):
13603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13604 
 
13605 
  def __ne__(self, other):
13606 
    return not (self == other)
13607 
 
13608 
class getSearchResultCount_args:
13609 
  """
13610 
  Attributes:
13611 
   - searchTerms
13612 
  """
13613 
 
13614 
  thrift_spec = (
13615 
    None, # 0
13616 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13617 
  )
13618 
 
13619 
  def __init__(self, searchTerms=None,):
13620 
    self.searchTerms = searchTerms
13621 
 
13622 
  def read(self, iprot):
13623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13625 
      return
13626 
    iprot.readStructBegin()
13627 
    while True:
13628 
      (fname, ftype, fid) = iprot.readFieldBegin()
13629 
      if ftype == TType.STOP:
13630 
        break
13631 
      if fid == 1:
13632 
        if ftype == TType.LIST:
13633 
          self.searchTerms = []
6850 kshitij.so 13634 
          (_etype252, _size249) = iprot.readListBegin()
13635 
          for _i253 in xrange(_size249):
13636 
            _elem254 = iprot.readString();
13637 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13638 
          iprot.readListEnd()
13639 
        else:
13640 
          iprot.skip(ftype)
13641 
      else:
13642 
        iprot.skip(ftype)
13643 
      iprot.readFieldEnd()
13644 
    iprot.readStructEnd()
13645 
 
13646 
  def write(self, oprot):
13647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13649 
      return
13650 
    oprot.writeStructBegin('getSearchResultCount_args')
13651 
    if self.searchTerms is not None:
13652 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13653 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13654 
      for iter255 in self.searchTerms:
13655 
        oprot.writeString(iter255)
5944 mandeep.dh 13656 
      oprot.writeListEnd()
13657 
      oprot.writeFieldEnd()
13658 
    oprot.writeFieldStop()
13659 
    oprot.writeStructEnd()
13660 
 
13661 
  def validate(self):
13662 
    return
13663 
 
13664 
 
13665 
  def __repr__(self):
13666 
    L = ['%s=%r' % (key, value)
13667 
      for key, value in self.__dict__.iteritems()]
13668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13669 
 
13670 
  def __eq__(self, other):
13671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13672 
 
13673 
  def __ne__(self, other):
13674 
    return not (self == other)
13675 
 
13676 
class getSearchResultCount_result:
13677 
  """
13678 
  Attributes:
13679 
   - success
13680 
  """
13681 
 
13682 
  thrift_spec = (
13683 
    (0, TType.I32, 'success', None, None, ), # 0
13684 
  )
13685 
 
13686 
  def __init__(self, success=None,):
13687 
    self.success = success
13688 
 
13689 
  def read(self, iprot):
13690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13692 
      return
13693 
    iprot.readStructBegin()
13694 
    while True:
13695 
      (fname, ftype, fid) = iprot.readFieldBegin()
13696 
      if ftype == TType.STOP:
13697 
        break
13698 
      if fid == 0:
13699 
        if ftype == TType.I32:
13700 
          self.success = iprot.readI32();
13701 
        else:
13702 
          iprot.skip(ftype)
13703 
      else:
13704 
        iprot.skip(ftype)
13705 
      iprot.readFieldEnd()
13706 
    iprot.readStructEnd()
13707 
 
13708 
  def write(self, oprot):
13709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13711 
      return
13712 
    oprot.writeStructBegin('getSearchResultCount_result')
13713 
    if self.success is not None:
13714 
      oprot.writeFieldBegin('success', TType.I32, 0)
13715 
      oprot.writeI32(self.success)
13716 
      oprot.writeFieldEnd()
13717 
    oprot.writeFieldStop()
13718 
    oprot.writeStructEnd()
13719 
 
13720 
  def validate(self):
13721 
    return
13722 
 
13723 
 
13724 
  def __repr__(self):
13725 
    L = ['%s=%r' % (key, value)
13726 
      for key, value in self.__dict__.iteritems()]
13727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13728 
 
13729 
  def __eq__(self, other):
13730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13731 
 
13732 
  def __ne__(self, other):
13733 
    return not (self == other)
13734 
 
13735 
class getProductNotifications_args:
13736 
  """
13737 
  Attributes:
13738 
   - startDateTime
13739 
  """
13740 
 
13741 
  thrift_spec = (
13742 
    None, # 0
13743 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13744 
  )
13745 
 
13746 
  def __init__(self, startDateTime=None,):
13747 
    self.startDateTime = startDateTime
13748 
 
13749 
  def read(self, iprot):
13750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13752 
      return
13753 
    iprot.readStructBegin()
13754 
    while True:
13755 
      (fname, ftype, fid) = iprot.readFieldBegin()
13756 
      if ftype == TType.STOP:
13757 
        break
13758 
      if fid == 1:
13759 
        if ftype == TType.I64:
13760 
          self.startDateTime = iprot.readI64();
13761 
        else:
13762 
          iprot.skip(ftype)
13763 
      else:
13764 
        iprot.skip(ftype)
13765 
      iprot.readFieldEnd()
13766 
    iprot.readStructEnd()
13767 
 
13768 
  def write(self, oprot):
13769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13771 
      return
13772 
    oprot.writeStructBegin('getProductNotifications_args')
13773 
    if self.startDateTime is not None:
13774 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13775 
      oprot.writeI64(self.startDateTime)
13776 
      oprot.writeFieldEnd()
13777 
    oprot.writeFieldStop()
13778 
    oprot.writeStructEnd()
13779 
 
13780 
  def validate(self):
13781 
    return
13782 
 
13783 
 
13784 
  def __repr__(self):
13785 
    L = ['%s=%r' % (key, value)
13786 
      for key, value in self.__dict__.iteritems()]
13787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13788 
 
13789 
  def __eq__(self, other):
13790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13791 
 
13792 
  def __ne__(self, other):
13793 
    return not (self == other)
13794 
 
13795 
class getProductNotifications_result:
13796 
  """
13797 
  Attributes:
13798 
   - success
13799 
  """
13800 
 
13801 
  thrift_spec = (
13802 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13803 
  )
13804 
 
13805 
  def __init__(self, success=None,):
13806 
    self.success = success
13807 
 
13808 
  def read(self, iprot):
13809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13811 
      return
13812 
    iprot.readStructBegin()
13813 
    while True:
13814 
      (fname, ftype, fid) = iprot.readFieldBegin()
13815 
      if ftype == TType.STOP:
13816 
        break
13817 
      if fid == 0:
13818 
        if ftype == TType.LIST:
13819 
          self.success = []
6850 kshitij.so 13820 
          (_etype259, _size256) = iprot.readListBegin()
13821 
          for _i260 in xrange(_size256):
13822 
            _elem261 = ProductNotificationRequest()
13823 
            _elem261.read(iprot)
13824 
            self.success.append(_elem261)
5944 mandeep.dh 13825 
          iprot.readListEnd()
13826 
        else:
13827 
          iprot.skip(ftype)
13828 
      else:
13829 
        iprot.skip(ftype)
13830 
      iprot.readFieldEnd()
13831 
    iprot.readStructEnd()
13832 
 
13833 
  def write(self, oprot):
13834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13836 
      return
13837 
    oprot.writeStructBegin('getProductNotifications_result')
13838 
    if self.success is not None:
13839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13841 
      for iter262 in self.success:
13842 
        iter262.write(oprot)
5944 mandeep.dh 13843 
      oprot.writeListEnd()
13844 
      oprot.writeFieldEnd()
13845 
    oprot.writeFieldStop()
13846 
    oprot.writeStructEnd()
13847 
 
13848 
  def validate(self):
13849 
    return
13850 
 
13851 
 
13852 
  def __repr__(self):
13853 
    L = ['%s=%r' % (key, value)
13854 
      for key, value in self.__dict__.iteritems()]
13855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13856 
 
13857 
  def __eq__(self, other):
13858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13859 
 
13860 
  def __ne__(self, other):
13861 
    return not (self == other)
13862 
 
13863 
class getProductNotificationRequestCount_args:
13864 
  """
13865 
  Attributes:
13866 
   - startDateTime
13867 
  """
13868 
 
13869 
  thrift_spec = (
13870 
    None, # 0
13871 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13872 
  )
13873 
 
13874 
  def __init__(self, startDateTime=None,):
13875 
    self.startDateTime = startDateTime
13876 
 
13877 
  def read(self, iprot):
13878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13880 
      return
13881 
    iprot.readStructBegin()
13882 
    while True:
13883 
      (fname, ftype, fid) = iprot.readFieldBegin()
13884 
      if ftype == TType.STOP:
13885 
        break
13886 
      if fid == 1:
13887 
        if ftype == TType.I64:
13888 
          self.startDateTime = iprot.readI64();
13889 
        else:
13890 
          iprot.skip(ftype)
13891 
      else:
13892 
        iprot.skip(ftype)
13893 
      iprot.readFieldEnd()
13894 
    iprot.readStructEnd()
13895 
 
13896 
  def write(self, oprot):
13897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13899 
      return
13900 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13901 
    if self.startDateTime is not None:
13902 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13903 
      oprot.writeI64(self.startDateTime)
13904 
      oprot.writeFieldEnd()
13905 
    oprot.writeFieldStop()
13906 
    oprot.writeStructEnd()
13907 
 
13908 
  def validate(self):
13909 
    return
13910 
 
13911 
 
13912 
  def __repr__(self):
13913 
    L = ['%s=%r' % (key, value)
13914 
      for key, value in self.__dict__.iteritems()]
13915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13916 
 
13917 
  def __eq__(self, other):
13918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13919 
 
13920 
  def __ne__(self, other):
13921 
    return not (self == other)
13922 
 
13923 
class getProductNotificationRequestCount_result:
13924 
  """
13925 
  Attributes:
13926 
   - success
13927 
  """
13928 
 
13929 
  thrift_spec = (
13930 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13931 
  )
13932 
 
13933 
  def __init__(self, success=None,):
13934 
    self.success = success
13935 
 
13936 
  def read(self, iprot):
13937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13939 
      return
13940 
    iprot.readStructBegin()
13941 
    while True:
13942 
      (fname, ftype, fid) = iprot.readFieldBegin()
13943 
      if ftype == TType.STOP:
13944 
        break
13945 
      if fid == 0:
13946 
        if ftype == TType.LIST:
13947 
          self.success = []
6850 kshitij.so 13948 
          (_etype266, _size263) = iprot.readListBegin()
13949 
          for _i267 in xrange(_size263):
13950 
            _elem268 = ProductNotificationRequestCount()
13951 
            _elem268.read(iprot)
13952 
            self.success.append(_elem268)
5944 mandeep.dh 13953 
          iprot.readListEnd()
13954 
        else:
13955 
          iprot.skip(ftype)
13956 
      else:
13957 
        iprot.skip(ftype)
13958 
      iprot.readFieldEnd()
13959 
    iprot.readStructEnd()
13960 
 
13961 
  def write(self, oprot):
13962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13964 
      return
13965 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
13966 
    if self.success is not None:
13967 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13968 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13969 
      for iter269 in self.success:
13970 
        iter269.write(oprot)
5944 mandeep.dh 13971 
      oprot.writeListEnd()
13972 
      oprot.writeFieldEnd()
13973 
    oprot.writeFieldStop()
13974 
    oprot.writeStructEnd()
13975 
 
13976 
  def validate(self):
13977 
    return
13978 
 
13979 
 
13980 
  def __repr__(self):
13981 
    L = ['%s=%r' % (key, value)
13982 
      for key, value in self.__dict__.iteritems()]
13983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13984 
 
13985 
  def __eq__(self, other):
13986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13987 
 
13988 
  def __ne__(self, other):
13989 
    return not (self == other)
13990 
 
13991 
class addAuthorizationLog_args:
13992 
  """
13993 
  Attributes:
13994 
   - itemId
13995 
   - username
13996 
   - reason
13997 
  """
13998 
 
13999 
  thrift_spec = (
14000 
    None, # 0
14001 
    (1, TType.I64, 'itemId', None, None, ), # 1
14002 
    (2, TType.STRING, 'username', None, None, ), # 2
14003 
    (3, TType.STRING, 'reason', None, None, ), # 3
14004 
  )
14005 
 
14006 
  def __init__(self, itemId=None, username=None, reason=None,):
14007 
    self.itemId = itemId
14008 
    self.username = username
14009 
    self.reason = reason
14010 
 
14011 
  def read(self, iprot):
14012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14014 
      return
14015 
    iprot.readStructBegin()
14016 
    while True:
14017 
      (fname, ftype, fid) = iprot.readFieldBegin()
14018 
      if ftype == TType.STOP:
14019 
        break
14020 
      if fid == 1:
14021 
        if ftype == TType.I64:
14022 
          self.itemId = iprot.readI64();
14023 
        else:
14024 
          iprot.skip(ftype)
14025 
      elif fid == 2:
14026 
        if ftype == TType.STRING:
14027 
          self.username = iprot.readString();
14028 
        else:
14029 
          iprot.skip(ftype)
14030 
      elif fid == 3:
14031 
        if ftype == TType.STRING:
14032 
          self.reason = iprot.readString();
14033 
        else:
14034 
          iprot.skip(ftype)
14035 
      else:
14036 
        iprot.skip(ftype)
14037 
      iprot.readFieldEnd()
14038 
    iprot.readStructEnd()
14039 
 
14040 
  def write(self, oprot):
14041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14043 
      return
14044 
    oprot.writeStructBegin('addAuthorizationLog_args')
14045 
    if self.itemId is not None:
14046 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14047 
      oprot.writeI64(self.itemId)
14048 
      oprot.writeFieldEnd()
14049 
    if self.username is not None:
14050 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14051 
      oprot.writeString(self.username)
14052 
      oprot.writeFieldEnd()
14053 
    if self.reason is not None:
14054 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14055 
      oprot.writeString(self.reason)
14056 
      oprot.writeFieldEnd()
14057 
    oprot.writeFieldStop()
14058 
    oprot.writeStructEnd()
14059 
 
14060 
  def validate(self):
14061 
    return
14062 
 
14063 
 
14064 
  def __repr__(self):
14065 
    L = ['%s=%r' % (key, value)
14066 
      for key, value in self.__dict__.iteritems()]
14067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14068 
 
14069 
  def __eq__(self, other):
14070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14071 
 
14072 
  def __ne__(self, other):
14073 
    return not (self == other)
14074 
 
14075 
class addAuthorizationLog_result:
14076 
  """
14077 
  Attributes:
14078 
   - success
14079 
   - cex
14080 
  """
14081 
 
14082 
  thrift_spec = (
14083 
    (0, TType.BOOL, 'success', None, None, ), # 0
14084 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14085 
  )
14086 
 
14087 
  def __init__(self, success=None, cex=None,):
14088 
    self.success = success
14089 
    self.cex = cex
14090 
 
14091 
  def read(self, iprot):
14092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14094 
      return
14095 
    iprot.readStructBegin()
14096 
    while True:
14097 
      (fname, ftype, fid) = iprot.readFieldBegin()
14098 
      if ftype == TType.STOP:
14099 
        break
14100 
      if fid == 0:
14101 
        if ftype == TType.BOOL:
14102 
          self.success = iprot.readBool();
14103 
        else:
14104 
          iprot.skip(ftype)
14105 
      elif fid == 1:
14106 
        if ftype == TType.STRUCT:
14107 
          self.cex = CatalogServiceException()
14108 
          self.cex.read(iprot)
14109 
        else:
14110 
          iprot.skip(ftype)
14111 
      else:
14112 
        iprot.skip(ftype)
14113 
      iprot.readFieldEnd()
14114 
    iprot.readStructEnd()
14115 
 
14116 
  def write(self, oprot):
14117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14119 
      return
14120 
    oprot.writeStructBegin('addAuthorizationLog_result')
14121 
    if self.success is not None:
14122 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14123 
      oprot.writeBool(self.success)
14124 
      oprot.writeFieldEnd()
14125 
    if self.cex is not None:
14126 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14127 
      self.cex.write(oprot)
14128 
      oprot.writeFieldEnd()
14129 
    oprot.writeFieldStop()
14130 
    oprot.writeStructEnd()
14131 
 
14132 
  def validate(self):
14133 
    return
14134 
 
14135 
 
14136 
  def __repr__(self):
14137 
    L = ['%s=%r' % (key, value)
14138 
      for key, value in self.__dict__.iteritems()]
14139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14140 
 
14141 
  def __eq__(self, other):
14142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14143 
 
14144 
  def __ne__(self, other):
14145 
    return not (self == other)
14146 
 
14147 
class addupdateVoucherForItem_args:
14148 
  """
14149 
  Attributes:
14150 
   - catalog_item_id
14151 
   - voucherType
14152 
   - voucherAmount
14153 
  """
14154 
 
14155 
  thrift_spec = (
14156 
    None, # 0
14157 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14158 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14159 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14160 
  )
14161 
 
14162 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14163 
    self.catalog_item_id = catalog_item_id
14164 
    self.voucherType = voucherType
14165 
    self.voucherAmount = voucherAmount
14166 
 
14167 
  def read(self, iprot):
14168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14170 
      return
14171 
    iprot.readStructBegin()
14172 
    while True:
14173 
      (fname, ftype, fid) = iprot.readFieldBegin()
14174 
      if ftype == TType.STOP:
14175 
        break
14176 
      if fid == 1:
14177 
        if ftype == TType.I64:
14178 
          self.catalog_item_id = iprot.readI64();
14179 
        else:
14180 
          iprot.skip(ftype)
14181 
      elif fid == 2:
14182 
        if ftype == TType.I64:
14183 
          self.voucherType = iprot.readI64();
14184 
        else:
14185 
          iprot.skip(ftype)
14186 
      elif fid == 3:
14187 
        if ftype == TType.I64:
14188 
          self.voucherAmount = iprot.readI64();
14189 
        else:
14190 
          iprot.skip(ftype)
14191 
      else:
14192 
        iprot.skip(ftype)
14193 
      iprot.readFieldEnd()
14194 
    iprot.readStructEnd()
14195 
 
14196 
  def write(self, oprot):
14197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14199 
      return
14200 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14201 
    if self.catalog_item_id is not None:
14202 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14203 
      oprot.writeI64(self.catalog_item_id)
14204 
      oprot.writeFieldEnd()
14205 
    if self.voucherType is not None:
14206 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14207 
      oprot.writeI64(self.voucherType)
14208 
      oprot.writeFieldEnd()
14209 
    if self.voucherAmount is not None:
14210 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14211 
      oprot.writeI64(self.voucherAmount)
14212 
      oprot.writeFieldEnd()
14213 
    oprot.writeFieldStop()
14214 
    oprot.writeStructEnd()
14215 
 
14216 
  def validate(self):
14217 
    return
14218 
 
14219 
 
14220 
  def __repr__(self):
14221 
    L = ['%s=%r' % (key, value)
14222 
      for key, value in self.__dict__.iteritems()]
14223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14224 
 
14225 
  def __eq__(self, other):
14226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14227 
 
14228 
  def __ne__(self, other):
14229 
    return not (self == other)
14230 
 
14231 
class addupdateVoucherForItem_result:
14232 
  """
14233 
  Attributes:
14234 
   - success
14235 
   - cex
14236 
  """
14237 
 
14238 
  thrift_spec = (
14239 
    (0, TType.BOOL, 'success', None, None, ), # 0
14240 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14241 
  )
14242 
 
14243 
  def __init__(self, success=None, cex=None,):
14244 
    self.success = success
14245 
    self.cex = cex
14246 
 
14247 
  def read(self, iprot):
14248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14250 
      return
14251 
    iprot.readStructBegin()
14252 
    while True:
14253 
      (fname, ftype, fid) = iprot.readFieldBegin()
14254 
      if ftype == TType.STOP:
14255 
        break
14256 
      if fid == 0:
14257 
        if ftype == TType.BOOL:
14258 
          self.success = iprot.readBool();
14259 
        else:
14260 
          iprot.skip(ftype)
14261 
      elif fid == 1:
14262 
        if ftype == TType.STRUCT:
14263 
          self.cex = CatalogServiceException()
14264 
          self.cex.read(iprot)
14265 
        else:
14266 
          iprot.skip(ftype)
14267 
      else:
14268 
        iprot.skip(ftype)
14269 
      iprot.readFieldEnd()
14270 
    iprot.readStructEnd()
14271 
 
14272 
  def write(self, oprot):
14273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14275 
      return
14276 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14277 
    if self.success is not None:
14278 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14279 
      oprot.writeBool(self.success)
14280 
      oprot.writeFieldEnd()
14281 
    if self.cex is not None:
14282 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14283 
      self.cex.write(oprot)
14284 
      oprot.writeFieldEnd()
14285 
    oprot.writeFieldStop()
14286 
    oprot.writeStructEnd()
14287 
 
14288 
  def validate(self):
14289 
    return
14290 
 
14291 
 
14292 
  def __repr__(self):
14293 
    L = ['%s=%r' % (key, value)
14294 
      for key, value in self.__dict__.iteritems()]
14295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14296 
 
14297 
  def __eq__(self, other):
14298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14299 
 
14300 
  def __ne__(self, other):
14301 
    return not (self == other)
14302 
 
14303 
class deleteVoucherForItem_args:
14304 
  """
14305 
  Attributes:
14306 
   - catalog_item_id
14307 
   - voucherType
14308 
  """
14309 
 
14310 
  thrift_spec = (
14311 
    None, # 0
14312 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14313 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14314 
  )
14315 
 
14316 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14317 
    self.catalog_item_id = catalog_item_id
14318 
    self.voucherType = voucherType
14319 
 
14320 
  def read(self, iprot):
14321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14323 
      return
14324 
    iprot.readStructBegin()
14325 
    while True:
14326 
      (fname, ftype, fid) = iprot.readFieldBegin()
14327 
      if ftype == TType.STOP:
14328 
        break
14329 
      if fid == 1:
14330 
        if ftype == TType.I64:
14331 
          self.catalog_item_id = iprot.readI64();
14332 
        else:
14333 
          iprot.skip(ftype)
14334 
      elif fid == 2:
14335 
        if ftype == TType.I64:
14336 
          self.voucherType = iprot.readI64();
14337 
        else:
14338 
          iprot.skip(ftype)
14339 
      else:
14340 
        iprot.skip(ftype)
14341 
      iprot.readFieldEnd()
14342 
    iprot.readStructEnd()
14343 
 
14344 
  def write(self, oprot):
14345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14347 
      return
14348 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14349 
    if self.catalog_item_id is not None:
14350 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14351 
      oprot.writeI64(self.catalog_item_id)
14352 
      oprot.writeFieldEnd()
14353 
    if self.voucherType is not None:
14354 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14355 
      oprot.writeI64(self.voucherType)
14356 
      oprot.writeFieldEnd()
14357 
    oprot.writeFieldStop()
14358 
    oprot.writeStructEnd()
14359 
 
14360 
  def validate(self):
14361 
    return
14362 
 
14363 
 
14364 
  def __repr__(self):
14365 
    L = ['%s=%r' % (key, value)
14366 
      for key, value in self.__dict__.iteritems()]
14367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14368 
 
14369 
  def __eq__(self, other):
14370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14371 
 
14372 
  def __ne__(self, other):
14373 
    return not (self == other)
14374 
 
14375 
class deleteVoucherForItem_result:
14376 
  """
14377 
  Attributes:
14378 
   - success
14379 
   - cex
14380 
  """
14381 
 
14382 
  thrift_spec = (
14383 
    (0, TType.BOOL, 'success', None, None, ), # 0
14384 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14385 
  )
14386 
 
14387 
  def __init__(self, success=None, cex=None,):
14388 
    self.success = success
14389 
    self.cex = cex
14390 
 
14391 
  def read(self, iprot):
14392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14394 
      return
14395 
    iprot.readStructBegin()
14396 
    while True:
14397 
      (fname, ftype, fid) = iprot.readFieldBegin()
14398 
      if ftype == TType.STOP:
14399 
        break
14400 
      if fid == 0:
14401 
        if ftype == TType.BOOL:
14402 
          self.success = iprot.readBool();
14403 
        else:
14404 
          iprot.skip(ftype)
14405 
      elif fid == 1:
14406 
        if ftype == TType.STRUCT:
14407 
          self.cex = CatalogServiceException()
14408 
          self.cex.read(iprot)
14409 
        else:
14410 
          iprot.skip(ftype)
14411 
      else:
14412 
        iprot.skip(ftype)
14413 
      iprot.readFieldEnd()
14414 
    iprot.readStructEnd()
14415 
 
14416 
  def write(self, oprot):
14417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14419 
      return
14420 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14421 
    if self.success is not None:
14422 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14423 
      oprot.writeBool(self.success)
14424 
      oprot.writeFieldEnd()
14425 
    if self.cex is not None:
14426 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14427 
      self.cex.write(oprot)
14428 
      oprot.writeFieldEnd()
14429 
    oprot.writeFieldStop()
14430 
    oprot.writeStructEnd()
14431 
 
14432 
  def validate(self):
14433 
    return
14434 
 
14435 
 
14436 
  def __repr__(self):
14437 
    L = ['%s=%r' % (key, value)
14438 
      for key, value in self.__dict__.iteritems()]
14439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14440 
 
14441 
  def __eq__(self, other):
14442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14443 
 
14444 
  def __ne__(self, other):
14445 
    return not (self == other)
14446 
 
14447 
class getVoucherAmount_args:
14448 
  """
14449 
  Attributes:
14450 
   - itemId
14451 
   - voucherType
14452 
  """
14453 
 
14454 
  thrift_spec = (
14455 
    None, # 0
14456 
    (1, TType.I64, 'itemId', None, None, ), # 1
14457 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14458 
  )
14459 
 
14460 
  def __init__(self, itemId=None, voucherType=None,):
14461 
    self.itemId = itemId
14462 
    self.voucherType = voucherType
14463 
 
14464 
  def read(self, iprot):
14465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14467 
      return
14468 
    iprot.readStructBegin()
14469 
    while True:
14470 
      (fname, ftype, fid) = iprot.readFieldBegin()
14471 
      if ftype == TType.STOP:
14472 
        break
14473 
      if fid == 1:
14474 
        if ftype == TType.I64:
14475 
          self.itemId = iprot.readI64();
14476 
        else:
14477 
          iprot.skip(ftype)
14478 
      elif fid == 2:
14479 
        if ftype == TType.I64:
14480 
          self.voucherType = iprot.readI64();
14481 
        else:
14482 
          iprot.skip(ftype)
14483 
      else:
14484 
        iprot.skip(ftype)
14485 
      iprot.readFieldEnd()
14486 
    iprot.readStructEnd()
14487 
 
14488 
  def write(self, oprot):
14489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14491 
      return
14492 
    oprot.writeStructBegin('getVoucherAmount_args')
14493 
    if self.itemId is not None:
14494 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14495 
      oprot.writeI64(self.itemId)
14496 
      oprot.writeFieldEnd()
14497 
    if self.voucherType is not None:
14498 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14499 
      oprot.writeI64(self.voucherType)
14500 
      oprot.writeFieldEnd()
14501 
    oprot.writeFieldStop()
14502 
    oprot.writeStructEnd()
14503 
 
14504 
  def validate(self):
14505 
    return
14506 
 
14507 
 
14508 
  def __repr__(self):
14509 
    L = ['%s=%r' % (key, value)
14510 
      for key, value in self.__dict__.iteritems()]
14511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14512 
 
14513 
  def __eq__(self, other):
14514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14515 
 
14516 
  def __ne__(self, other):
14517 
    return not (self == other)
14518 
 
14519 
class getVoucherAmount_result:
14520 
  """
14521 
  Attributes:
14522 
   - success
14523 
  """
14524 
 
14525 
  thrift_spec = (
14526 
    (0, TType.I64, 'success', None, None, ), # 0
14527 
  )
14528 
 
14529 
  def __init__(self, success=None,):
14530 
    self.success = success
14531 
 
14532 
  def read(self, iprot):
14533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14535 
      return
14536 
    iprot.readStructBegin()
14537 
    while True:
14538 
      (fname, ftype, fid) = iprot.readFieldBegin()
14539 
      if ftype == TType.STOP:
14540 
        break
14541 
      if fid == 0:
14542 
        if ftype == TType.I64:
14543 
          self.success = iprot.readI64();
14544 
        else:
14545 
          iprot.skip(ftype)
14546 
      else:
14547 
        iprot.skip(ftype)
14548 
      iprot.readFieldEnd()
14549 
    iprot.readStructEnd()
14550 
 
14551 
  def write(self, oprot):
14552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14554 
      return
14555 
    oprot.writeStructBegin('getVoucherAmount_result')
14556 
    if self.success is not None:
14557 
      oprot.writeFieldBegin('success', TType.I64, 0)
14558 
      oprot.writeI64(self.success)
14559 
      oprot.writeFieldEnd()
14560 
    oprot.writeFieldStop()
14561 
    oprot.writeStructEnd()
14562 
 
14563 
  def validate(self):
14564 
    return
14565 
 
14566 
 
14567 
  def __repr__(self):
14568 
    L = ['%s=%r' % (key, value)
14569 
      for key, value in self.__dict__.iteritems()]
14570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14571 
 
14572 
  def __eq__(self, other):
14573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14574 
 
14575 
  def __ne__(self, other):
14576 
    return not (self == other)
14577 
 
14578 
class getAllItemVouchers_args:
14579 
  """
14580 
  Attributes:
14581 
   - itemId
14582 
  """
14583 
 
14584 
  thrift_spec = (
14585 
    None, # 0
14586 
    (1, TType.I64, 'itemId', None, None, ), # 1
14587 
  )
14588 
 
14589 
  def __init__(self, itemId=None,):
14590 
    self.itemId = itemId
14591 
 
14592 
  def read(self, iprot):
14593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14595 
      return
14596 
    iprot.readStructBegin()
14597 
    while True:
14598 
      (fname, ftype, fid) = iprot.readFieldBegin()
14599 
      if ftype == TType.STOP:
14600 
        break
14601 
      if fid == 1:
14602 
        if ftype == TType.I64:
14603 
          self.itemId = iprot.readI64();
14604 
        else:
14605 
          iprot.skip(ftype)
14606 
      else:
14607 
        iprot.skip(ftype)
14608 
      iprot.readFieldEnd()
14609 
    iprot.readStructEnd()
14610 
 
14611 
  def write(self, oprot):
14612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14614 
      return
14615 
    oprot.writeStructBegin('getAllItemVouchers_args')
14616 
    if self.itemId is not None:
14617 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14618 
      oprot.writeI64(self.itemId)
14619 
      oprot.writeFieldEnd()
14620 
    oprot.writeFieldStop()
14621 
    oprot.writeStructEnd()
14622 
 
14623 
  def validate(self):
14624 
    return
14625 
 
14626 
 
14627 
  def __repr__(self):
14628 
    L = ['%s=%r' % (key, value)
14629 
      for key, value in self.__dict__.iteritems()]
14630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14631 
 
14632 
  def __eq__(self, other):
14633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14634 
 
14635 
  def __ne__(self, other):
14636 
    return not (self == other)
14637 
 
14638 
class getAllItemVouchers_result:
14639 
  """
14640 
  Attributes:
14641 
   - success
14642 
  """
14643 
 
14644 
  thrift_spec = (
14645 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14646 
  )
14647 
 
14648 
  def __init__(self, success=None,):
14649 
    self.success = success
14650 
 
14651 
  def read(self, iprot):
14652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14654 
      return
14655 
    iprot.readStructBegin()
14656 
    while True:
14657 
      (fname, ftype, fid) = iprot.readFieldBegin()
14658 
      if ftype == TType.STOP:
14659 
        break
14660 
      if fid == 0:
14661 
        if ftype == TType.LIST:
14662 
          self.success = []
7256 rajveer 14663 
          (_etype273, _size270) = iprot.readListBegin()
14664 
          for _i274 in xrange(_size270):
14665 
            _elem275 = VoucherItemMapping()
14666 
            _elem275.read(iprot)
14667 
            self.success.append(_elem275)
5944 mandeep.dh 14668 
          iprot.readListEnd()
14669 
        else:
14670 
          iprot.skip(ftype)
14671 
      else:
14672 
        iprot.skip(ftype)
14673 
      iprot.readFieldEnd()
14674 
    iprot.readStructEnd()
14675 
 
14676 
  def write(self, oprot):
14677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14679 
      return
14680 
    oprot.writeStructBegin('getAllItemVouchers_result')
14681 
    if self.success is not None:
14682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14684 
      for iter276 in self.success:
14685 
        iter276.write(oprot)
5944 mandeep.dh 14686 
      oprot.writeListEnd()
14687 
      oprot.writeFieldEnd()
14688 
    oprot.writeFieldStop()
14689 
    oprot.writeStructEnd()
14690 
 
14691 
  def validate(self):
14692 
    return
14693 
 
14694 
 
14695 
  def __repr__(self):
14696 
    L = ['%s=%r' % (key, value)
14697 
      for key, value in self.__dict__.iteritems()]
14698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14699 
 
14700 
  def __eq__(self, other):
14701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14702 
 
14703 
  def __ne__(self, other):
14704 
    return not (self == other)
14705 
 
14706 
class isValidCatalogItemId_args:
14707 
  """
14708 
  Attributes:
14709 
   - catalog_item_id
14710 
  """
14711 
 
14712 
  thrift_spec = (
14713 
    None, # 0
14714 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14715 
  )
14716 
 
14717 
  def __init__(self, catalog_item_id=None,):
14718 
    self.catalog_item_id = catalog_item_id
14719 
 
14720 
  def read(self, iprot):
14721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14723 
      return
14724 
    iprot.readStructBegin()
14725 
    while True:
14726 
      (fname, ftype, fid) = iprot.readFieldBegin()
14727 
      if ftype == TType.STOP:
14728 
        break
14729 
      if fid == 1:
14730 
        if ftype == TType.I64:
14731 
          self.catalog_item_id = iprot.readI64();
14732 
        else:
14733 
          iprot.skip(ftype)
14734 
      else:
14735 
        iprot.skip(ftype)
14736 
      iprot.readFieldEnd()
14737 
    iprot.readStructEnd()
14738 
 
14739 
  def write(self, oprot):
14740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14742 
      return
14743 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14744 
    if self.catalog_item_id is not None:
14745 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14746 
      oprot.writeI64(self.catalog_item_id)
14747 
      oprot.writeFieldEnd()
14748 
    oprot.writeFieldStop()
14749 
    oprot.writeStructEnd()
14750 
 
14751 
  def validate(self):
14752 
    return
14753 
 
14754 
 
14755 
  def __repr__(self):
14756 
    L = ['%s=%r' % (key, value)
14757 
      for key, value in self.__dict__.iteritems()]
14758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14759 
 
14760 
  def __eq__(self, other):
14761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14762 
 
14763 
  def __ne__(self, other):
14764 
    return not (self == other)
14765 
 
14766 
class isValidCatalogItemId_result:
14767 
  """
14768 
  Attributes:
14769 
   - success
14770 
  """
14771 
 
14772 
  thrift_spec = (
14773 
    (0, TType.BOOL, 'success', None, None, ), # 0
14774 
  )
14775 
 
14776 
  def __init__(self, success=None,):
14777 
    self.success = success
14778 
 
14779 
  def read(self, iprot):
14780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14782 
      return
14783 
    iprot.readStructBegin()
14784 
    while True:
14785 
      (fname, ftype, fid) = iprot.readFieldBegin()
14786 
      if ftype == TType.STOP:
14787 
        break
14788 
      if fid == 0:
14789 
        if ftype == TType.BOOL:
14790 
          self.success = iprot.readBool();
14791 
        else:
14792 
          iprot.skip(ftype)
14793 
      else:
14794 
        iprot.skip(ftype)
14795 
      iprot.readFieldEnd()
14796 
    iprot.readStructEnd()
14797 
 
14798 
  def write(self, oprot):
14799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14801 
      return
14802 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14803 
    if self.success is not None:
14804 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14805 
      oprot.writeBool(self.success)
14806 
      oprot.writeFieldEnd()
14807 
    oprot.writeFieldStop()
14808 
    oprot.writeStructEnd()
14809 
 
14810 
  def validate(self):
14811 
    return
14812 
 
14813 
 
14814 
  def __repr__(self):
14815 
    L = ['%s=%r' % (key, value)
14816 
      for key, value in self.__dict__.iteritems()]
14817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14818 
 
14819 
  def __eq__(self, other):
14820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14821 
 
14822 
  def __ne__(self, other):
14823 
    return not (self == other)
6039 amit.gupta 14824 
 
14825 
class getVatPercentageForItem_args:
14826 
  """
14827 
  Attributes:
14828 
   - itemId
14829 
   - price
14830 
  """
14831 
 
14832 
  thrift_spec = (
14833 
    None, # 0
14834 
    (1, TType.I64, 'itemId', None, None, ), # 1
14835 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
14836 
  )
14837 
 
14838 
  def __init__(self, itemId=None, price=None,):
14839 
    self.itemId = itemId
14840 
    self.price = price
14841 
 
14842 
  def read(self, iprot):
14843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14845 
      return
14846 
    iprot.readStructBegin()
14847 
    while True:
14848 
      (fname, ftype, fid) = iprot.readFieldBegin()
14849 
      if ftype == TType.STOP:
14850 
        break
14851 
      if fid == 1:
14852 
        if ftype == TType.I64:
14853 
          self.itemId = iprot.readI64();
14854 
        else:
14855 
          iprot.skip(ftype)
14856 
      elif fid == 2:
14857 
        if ftype == TType.DOUBLE:
14858 
          self.price = iprot.readDouble();
14859 
        else:
14860 
          iprot.skip(ftype)
14861 
      else:
14862 
        iprot.skip(ftype)
14863 
      iprot.readFieldEnd()
14864 
    iprot.readStructEnd()
14865 
 
14866 
  def write(self, oprot):
14867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14869 
      return
14870 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14871 
    if self.itemId is not None:
14872 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14873 
      oprot.writeI64(self.itemId)
14874 
      oprot.writeFieldEnd()
14875 
    if self.price is not None:
14876 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
14877 
      oprot.writeDouble(self.price)
14878 
      oprot.writeFieldEnd()
14879 
    oprot.writeFieldStop()
14880 
    oprot.writeStructEnd()
14881 
 
14882 
  def validate(self):
14883 
    return
14884 
 
14885 
 
14886 
  def __repr__(self):
14887 
    L = ['%s=%r' % (key, value)
14888 
      for key, value in self.__dict__.iteritems()]
14889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14890 
 
14891 
  def __eq__(self, other):
14892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14893 
 
14894 
  def __ne__(self, other):
14895 
    return not (self == other)
14896 
 
14897 
class getVatPercentageForItem_result:
14898 
  """
14899 
  Attributes:
14900 
   - success
14901 
  """
14902 
 
14903 
  thrift_spec = (
14904 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
14905 
  )
14906 
 
14907 
  def __init__(self, success=None,):
14908 
    self.success = success
14909 
 
14910 
  def read(self, iprot):
14911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14913 
      return
14914 
    iprot.readStructBegin()
14915 
    while True:
14916 
      (fname, ftype, fid) = iprot.readFieldBegin()
14917 
      if ftype == TType.STOP:
14918 
        break
14919 
      if fid == 0:
14920 
        if ftype == TType.DOUBLE:
14921 
          self.success = iprot.readDouble();
14922 
        else:
14923 
          iprot.skip(ftype)
14924 
      else:
14925 
        iprot.skip(ftype)
14926 
      iprot.readFieldEnd()
14927 
    iprot.readStructEnd()
14928 
 
14929 
  def write(self, oprot):
14930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14932 
      return
14933 
    oprot.writeStructBegin('getVatPercentageForItem_result')
14934 
    if self.success is not None:
14935 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
14936 
      oprot.writeDouble(self.success)
14937 
      oprot.writeFieldEnd()
14938 
    oprot.writeFieldStop()
14939 
    oprot.writeStructEnd()
14940 
 
14941 
  def validate(self):
14942 
    return
14943 
 
14944 
 
14945 
  def __repr__(self):
14946 
    L = ['%s=%r' % (key, value)
14947 
      for key, value in self.__dict__.iteritems()]
14948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14949 
 
14950 
  def __eq__(self, other):
14951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14952 
 
14953 
  def __ne__(self, other):
14954 
    return not (self == other)
14955 
 
14956 
class getVatAmountForItem_args:
14957 
  """
14958 
  Attributes:
14959 
   - itemId
14960 
   - price
14961 
  """
14962 
 
14963 
  thrift_spec = (
14964 
    None, # 0
14965 
    (1, TType.I64, 'itemId', None, None, ), # 1
14966 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
14967 
  )
14968 
 
14969 
  def __init__(self, itemId=None, price=None,):
14970 
    self.itemId = itemId
14971 
    self.price = price
14972 
 
14973 
  def read(self, iprot):
14974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14976 
      return
14977 
    iprot.readStructBegin()
14978 
    while True:
14979 
      (fname, ftype, fid) = iprot.readFieldBegin()
14980 
      if ftype == TType.STOP:
14981 
        break
14982 
      if fid == 1:
14983 
        if ftype == TType.I64:
14984 
          self.itemId = iprot.readI64();
14985 
        else:
14986 
          iprot.skip(ftype)
14987 
      elif fid == 2:
14988 
        if ftype == TType.DOUBLE:
14989 
          self.price = iprot.readDouble();
14990 
        else:
14991 
          iprot.skip(ftype)
14992 
      else:
14993 
        iprot.skip(ftype)
14994 
      iprot.readFieldEnd()
14995 
    iprot.readStructEnd()
14996 
 
14997 
  def write(self, oprot):
14998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15000 
      return
15001 
    oprot.writeStructBegin('getVatAmountForItem_args')
15002 
    if self.itemId is not None:
15003 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15004 
      oprot.writeI64(self.itemId)
15005 
      oprot.writeFieldEnd()
15006 
    if self.price is not None:
15007 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15008 
      oprot.writeDouble(self.price)
15009 
      oprot.writeFieldEnd()
15010 
    oprot.writeFieldStop()
15011 
    oprot.writeStructEnd()
15012 
 
15013 
  def validate(self):
15014 
    return
15015 
 
15016 
 
15017 
  def __repr__(self):
15018 
    L = ['%s=%r' % (key, value)
15019 
      for key, value in self.__dict__.iteritems()]
15020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15021 
 
15022 
  def __eq__(self, other):
15023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15024 
 
15025 
  def __ne__(self, other):
15026 
    return not (self == other)
15027 
 
15028 
class getVatAmountForItem_result:
15029 
  """
15030 
  Attributes:
15031 
   - success
15032 
  """
15033 
 
15034 
  thrift_spec = (
15035 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15036 
  )
15037 
 
15038 
  def __init__(self, success=None,):
15039 
    self.success = success
15040 
 
15041 
  def read(self, iprot):
15042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15044 
      return
15045 
    iprot.readStructBegin()
15046 
    while True:
15047 
      (fname, ftype, fid) = iprot.readFieldBegin()
15048 
      if ftype == TType.STOP:
15049 
        break
15050 
      if fid == 0:
15051 
        if ftype == TType.DOUBLE:
15052 
          self.success = iprot.readDouble();
15053 
        else:
15054 
          iprot.skip(ftype)
15055 
      else:
15056 
        iprot.skip(ftype)
15057 
      iprot.readFieldEnd()
15058 
    iprot.readStructEnd()
15059 
 
15060 
  def write(self, oprot):
15061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15063 
      return
15064 
    oprot.writeStructBegin('getVatAmountForItem_result')
15065 
    if self.success is not None:
15066 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15067 
      oprot.writeDouble(self.success)
15068 
      oprot.writeFieldEnd()
15069 
    oprot.writeFieldStop()
15070 
    oprot.writeStructEnd()
15071 
 
15072 
  def validate(self):
15073 
    return
15074 
 
15075 
 
15076 
  def __repr__(self):
15077 
    L = ['%s=%r' % (key, value)
15078 
      for key, value in self.__dict__.iteritems()]
15079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15080 
 
15081 
  def __eq__(self, other):
15082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15083 
 
15084 
  def __ne__(self, other):
15085 
    return not (self == other)
6531 vikram.rag 15086 
 
15087 
class getAllIgnoredInventoryUpdateItemsList_args:
15088 
  """
15089 
  Attributes:
15090 
   - offset
15091 
   - limit
15092 
  """
15093 
 
15094 
  thrift_spec = (
15095 
    None, # 0
15096 
    (1, TType.I32, 'offset', None, None, ), # 1
15097 
    (2, TType.I32, 'limit', None, None, ), # 2
15098 
  )
15099 
 
15100 
  def __init__(self, offset=None, limit=None,):
15101 
    self.offset = offset
15102 
    self.limit = limit
15103 
 
15104 
  def read(self, iprot):
15105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15107 
      return
15108 
    iprot.readStructBegin()
15109 
    while True:
15110 
      (fname, ftype, fid) = iprot.readFieldBegin()
15111 
      if ftype == TType.STOP:
15112 
        break
15113 
      if fid == 1:
15114 
        if ftype == TType.I32:
15115 
          self.offset = iprot.readI32();
15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      elif fid == 2:
15119 
        if ftype == TType.I32:
15120 
          self.limit = iprot.readI32();
15121 
        else:
15122 
          iprot.skip(ftype)
15123 
      else:
15124 
        iprot.skip(ftype)
15125 
      iprot.readFieldEnd()
15126 
    iprot.readStructEnd()
15127 
 
15128 
  def write(self, oprot):
15129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15131 
      return
15132 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15133 
    if self.offset is not None:
15134 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15135 
      oprot.writeI32(self.offset)
15136 
      oprot.writeFieldEnd()
15137 
    if self.limit is not None:
15138 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15139 
      oprot.writeI32(self.limit)
15140 
      oprot.writeFieldEnd()
15141 
    oprot.writeFieldStop()
15142 
    oprot.writeStructEnd()
15143 
 
15144 
  def validate(self):
15145 
    return
15146 
 
15147 
 
15148 
  def __repr__(self):
15149 
    L = ['%s=%r' % (key, value)
15150 
      for key, value in self.__dict__.iteritems()]
15151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15152 
 
15153 
  def __eq__(self, other):
15154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15155 
 
15156 
  def __ne__(self, other):
15157 
    return not (self == other)
15158 
 
15159 
class getAllIgnoredInventoryUpdateItemsList_result:
15160 
  """
15161 
  Attributes:
15162 
   - success
15163 
  """
15164 
 
15165 
  thrift_spec = (
15166 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15167 
  )
15168 
 
15169 
  def __init__(self, success=None,):
15170 
    self.success = success
15171 
 
15172 
  def read(self, iprot):
15173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15175 
      return
15176 
    iprot.readStructBegin()
15177 
    while True:
15178 
      (fname, ftype, fid) = iprot.readFieldBegin()
15179 
      if ftype == TType.STOP:
15180 
        break
15181 
      if fid == 0:
15182 
        if ftype == TType.LIST:
15183 
          self.success = []
7256 rajveer 15184 
          (_etype280, _size277) = iprot.readListBegin()
15185 
          for _i281 in xrange(_size277):
15186 
            _elem282 = Item()
15187 
            _elem282.read(iprot)
15188 
            self.success.append(_elem282)
6531 vikram.rag 15189 
          iprot.readListEnd()
15190 
        else:
15191 
          iprot.skip(ftype)
15192 
      else:
15193 
        iprot.skip(ftype)
15194 
      iprot.readFieldEnd()
15195 
    iprot.readStructEnd()
15196 
 
15197 
  def write(self, oprot):
15198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15200 
      return
15201 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15202 
    if self.success is not None:
15203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15204 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15205 
      for iter283 in self.success:
15206 
        iter283.write(oprot)
6531 vikram.rag 15207 
      oprot.writeListEnd()
15208 
      oprot.writeFieldEnd()
15209 
    oprot.writeFieldStop()
15210 
    oprot.writeStructEnd()
15211 
 
15212 
  def validate(self):
15213 
    return
15214 
 
15215 
 
15216 
  def __repr__(self):
15217 
    L = ['%s=%r' % (key, value)
15218 
      for key, value in self.__dict__.iteritems()]
15219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15220 
 
15221 
  def __eq__(self, other):
15222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15223 
 
15224 
  def __ne__(self, other):
15225 
    return not (self == other)
6805 anupam.sin 15226 
 
6821 amar.kumar 15227 
class getAllAliveItems_args:
15228 
 
15229 
  thrift_spec = (
15230 
  )
15231 
 
15232 
  def read(self, iprot):
15233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15235 
      return
15236 
    iprot.readStructBegin()
15237 
    while True:
15238 
      (fname, ftype, fid) = iprot.readFieldBegin()
15239 
      if ftype == TType.STOP:
15240 
        break
15241 
      else:
15242 
        iprot.skip(ftype)
15243 
      iprot.readFieldEnd()
15244 
    iprot.readStructEnd()
15245 
 
15246 
  def write(self, oprot):
15247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15249 
      return
15250 
    oprot.writeStructBegin('getAllAliveItems_args')
15251 
    oprot.writeFieldStop()
15252 
    oprot.writeStructEnd()
15253 
 
15254 
  def validate(self):
15255 
    return
15256 
 
15257 
 
15258 
  def __repr__(self):
15259 
    L = ['%s=%r' % (key, value)
15260 
      for key, value in self.__dict__.iteritems()]
15261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15262 
 
15263 
  def __eq__(self, other):
15264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15265 
 
15266 
  def __ne__(self, other):
15267 
    return not (self == other)
15268 
 
15269 
class getAllAliveItems_result:
15270 
  """
15271 
  Attributes:
15272 
   - success
15273 
  """
15274 
 
15275 
  thrift_spec = (
15276 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15277 
  )
15278 
 
15279 
  def __init__(self, success=None,):
15280 
    self.success = success
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
15291 
      if fid == 0:
15292 
        if ftype == TType.LIST:
15293 
          self.success = []
7256 rajveer 15294 
          (_etype287, _size284) = iprot.readListBegin()
15295 
          for _i288 in xrange(_size284):
15296 
            _elem289 = Item()
15297 
            _elem289.read(iprot)
15298 
            self.success.append(_elem289)
6821 amar.kumar 15299 
          iprot.readListEnd()
15300 
        else:
15301 
          iprot.skip(ftype)
15302 
      else:
15303 
        iprot.skip(ftype)
15304 
      iprot.readFieldEnd()
15305 
    iprot.readStructEnd()
15306 
 
15307 
  def write(self, oprot):
15308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15310 
      return
15311 
    oprot.writeStructBegin('getAllAliveItems_result')
15312 
    if self.success is not None:
15313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15315 
      for iter290 in self.success:
15316 
        iter290.write(oprot)
6821 amar.kumar 15317 
      oprot.writeListEnd()
15318 
      oprot.writeFieldEnd()
15319 
    oprot.writeFieldStop()
15320 
    oprot.writeStructEnd()
15321 
 
15322 
  def validate(self):
15323 
    return
15324 
 
15325 
 
15326 
  def __repr__(self):
15327 
    L = ['%s=%r' % (key, value)
15328 
      for key, value in self.__dict__.iteritems()]
15329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15330 
 
15331 
  def __eq__(self, other):
15332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15333 
 
15334 
  def __ne__(self, other):
15335 
    return not (self == other)
15336 
 
6805 anupam.sin 15337 
class getInsuranceAmount_args:
15338 
  """
15339 
  Attributes:
15340 
   - itemId
6921 anupam.sin 15341 
   - price
6805 anupam.sin 15342 
   - insurerId
15343 
   - quantity
15344 
  """
15345 
 
15346 
  thrift_spec = (
15347 
    None, # 0
15348 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15349 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15350 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15351 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15352 
  )
15353 
 
6921 anupam.sin 15354 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15355 
    self.itemId = itemId
6921 anupam.sin 15356 
    self.price = price
6805 anupam.sin 15357 
    self.insurerId = insurerId
15358 
    self.quantity = quantity
15359 
 
15360 
  def read(self, iprot):
15361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15363 
      return
15364 
    iprot.readStructBegin()
15365 
    while True:
15366 
      (fname, ftype, fid) = iprot.readFieldBegin()
15367 
      if ftype == TType.STOP:
15368 
        break
15369 
      if fid == 1:
15370 
        if ftype == TType.I64:
15371 
          self.itemId = iprot.readI64();
15372 
        else:
15373 
          iprot.skip(ftype)
15374 
      elif fid == 2:
6921 anupam.sin 15375 
        if ftype == TType.DOUBLE:
15376 
          self.price = iprot.readDouble();
15377 
        else:
15378 
          iprot.skip(ftype)
15379 
      elif fid == 3:
6805 anupam.sin 15380 
        if ftype == TType.I64:
15381 
          self.insurerId = iprot.readI64();
15382 
        else:
15383 
          iprot.skip(ftype)
6921 anupam.sin 15384 
      elif fid == 4:
6805 anupam.sin 15385 
        if ftype == TType.I64:
15386 
          self.quantity = iprot.readI64();
15387 
        else:
15388 
          iprot.skip(ftype)
15389 
      else:
15390 
        iprot.skip(ftype)
15391 
      iprot.readFieldEnd()
15392 
    iprot.readStructEnd()
15393 
 
15394 
  def write(self, oprot):
15395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15397 
      return
15398 
    oprot.writeStructBegin('getInsuranceAmount_args')
15399 
    if self.itemId is not None:
15400 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15401 
      oprot.writeI64(self.itemId)
15402 
      oprot.writeFieldEnd()
6921 anupam.sin 15403 
    if self.price is not None:
15404 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15405 
      oprot.writeDouble(self.price)
15406 
      oprot.writeFieldEnd()
6805 anupam.sin 15407 
    if self.insurerId is not None:
6921 anupam.sin 15408 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15409 
      oprot.writeI64(self.insurerId)
15410 
      oprot.writeFieldEnd()
15411 
    if self.quantity is not None:
6921 anupam.sin 15412 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15413 
      oprot.writeI64(self.quantity)
15414 
      oprot.writeFieldEnd()
15415 
    oprot.writeFieldStop()
15416 
    oprot.writeStructEnd()
15417 
 
15418 
  def validate(self):
15419 
    return
15420 
 
15421 
 
15422 
  def __repr__(self):
15423 
    L = ['%s=%r' % (key, value)
15424 
      for key, value in self.__dict__.iteritems()]
15425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15426 
 
15427 
  def __eq__(self, other):
15428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15429 
 
15430 
  def __ne__(self, other):
15431 
    return not (self == other)
15432 
 
15433 
class getInsuranceAmount_result:
15434 
  """
15435 
  Attributes:
15436 
   - success
15437 
  """
15438 
 
15439 
  thrift_spec = (
15440 
    (0, TType.I64, 'success', None, None, ), # 0
15441 
  )
15442 
 
15443 
  def __init__(self, success=None,):
15444 
    self.success = success
15445 
 
15446 
  def read(self, iprot):
15447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15449 
      return
15450 
    iprot.readStructBegin()
15451 
    while True:
15452 
      (fname, ftype, fid) = iprot.readFieldBegin()
15453 
      if ftype == TType.STOP:
15454 
        break
15455 
      if fid == 0:
15456 
        if ftype == TType.I64:
15457 
          self.success = iprot.readI64();
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('getInsuranceAmount_result')
15470 
    if self.success is not None:
15471 
      oprot.writeFieldBegin('success', TType.I64, 0)
15472 
      oprot.writeI64(self.success)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
15491 
 
15492 
class getInsurer_args:
15493 
  """
15494 
  Attributes:
15495 
   - insurerId
15496 
  """
15497 
 
15498 
  thrift_spec = (
15499 
    None, # 0
15500 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15501 
  )
15502 
 
15503 
  def __init__(self, insurerId=None,):
15504 
    self.insurerId = insurerId
15505 
 
15506 
  def read(self, iprot):
15507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15509 
      return
15510 
    iprot.readStructBegin()
15511 
    while True:
15512 
      (fname, ftype, fid) = iprot.readFieldBegin()
15513 
      if ftype == TType.STOP:
15514 
        break
15515 
      if fid == 1:
15516 
        if ftype == TType.I64:
15517 
          self.insurerId = iprot.readI64();
15518 
        else:
15519 
          iprot.skip(ftype)
15520 
      else:
15521 
        iprot.skip(ftype)
15522 
      iprot.readFieldEnd()
15523 
    iprot.readStructEnd()
15524 
 
15525 
  def write(self, oprot):
15526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15528 
      return
15529 
    oprot.writeStructBegin('getInsurer_args')
15530 
    if self.insurerId is not None:
15531 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15532 
      oprot.writeI64(self.insurerId)
15533 
      oprot.writeFieldEnd()
15534 
    oprot.writeFieldStop()
15535 
    oprot.writeStructEnd()
15536 
 
15537 
  def validate(self):
15538 
    return
15539 
 
15540 
 
15541 
  def __repr__(self):
15542 
    L = ['%s=%r' % (key, value)
15543 
      for key, value in self.__dict__.iteritems()]
15544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15545 
 
15546 
  def __eq__(self, other):
15547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15548 
 
15549 
  def __ne__(self, other):
15550 
    return not (self == other)
15551 
 
15552 
class getInsurer_result:
15553 
  """
15554 
  Attributes:
15555 
   - success
15556 
  """
15557 
 
15558 
  thrift_spec = (
15559 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15560 
  )
15561 
 
15562 
  def __init__(self, success=None,):
15563 
    self.success = success
15564 
 
15565 
  def read(self, iprot):
15566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15568 
      return
15569 
    iprot.readStructBegin()
15570 
    while True:
15571 
      (fname, ftype, fid) = iprot.readFieldBegin()
15572 
      if ftype == TType.STOP:
15573 
        break
15574 
      if fid == 0:
15575 
        if ftype == TType.STRUCT:
15576 
          self.success = Insurer()
15577 
          self.success.read(iprot)
15578 
        else:
15579 
          iprot.skip(ftype)
15580 
      else:
15581 
        iprot.skip(ftype)
15582 
      iprot.readFieldEnd()
15583 
    iprot.readStructEnd()
15584 
 
15585 
  def write(self, oprot):
15586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15588 
      return
15589 
    oprot.writeStructBegin('getInsurer_result')
15590 
    if self.success is not None:
15591 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15592 
      self.success.write(oprot)
15593 
      oprot.writeFieldEnd()
15594 
    oprot.writeFieldStop()
15595 
    oprot.writeStructEnd()
15596 
 
15597 
  def validate(self):
15598 
    return
15599 
 
15600 
 
15601 
  def __repr__(self):
15602 
    L = ['%s=%r' % (key, value)
15603 
      for key, value in self.__dict__.iteritems()]
15604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15605 
 
15606 
  def __eq__(self, other):
15607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15608 
 
15609 
  def __ne__(self, other):
15610 
    return not (self == other)
6838 vikram.rag 15611 
 
15612 
class getAllInsurers_args:
15613 
 
15614 
  thrift_spec = (
15615 
  )
15616 
 
15617 
  def read(self, iprot):
15618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15620 
      return
15621 
    iprot.readStructBegin()
15622 
    while True:
15623 
      (fname, ftype, fid) = iprot.readFieldBegin()
15624 
      if ftype == TType.STOP:
15625 
        break
15626 
      else:
15627 
        iprot.skip(ftype)
15628 
      iprot.readFieldEnd()
15629 
    iprot.readStructEnd()
15630 
 
15631 
  def write(self, oprot):
15632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15634 
      return
15635 
    oprot.writeStructBegin('getAllInsurers_args')
15636 
    oprot.writeFieldStop()
15637 
    oprot.writeStructEnd()
15638 
 
15639 
  def validate(self):
15640 
    return
15641 
 
15642 
 
15643 
  def __repr__(self):
15644 
    L = ['%s=%r' % (key, value)
15645 
      for key, value in self.__dict__.iteritems()]
15646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15647 
 
15648 
  def __eq__(self, other):
15649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15650 
 
15651 
  def __ne__(self, other):
15652 
    return not (self == other)
15653 
 
15654 
class getAllInsurers_result:
15655 
  """
15656 
  Attributes:
15657 
   - success
15658 
  """
15659 
 
15660 
  thrift_spec = (
15661 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15662 
  )
15663 
 
15664 
  def __init__(self, success=None,):
15665 
    self.success = success
15666 
 
15667 
  def read(self, iprot):
15668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15670 
      return
15671 
    iprot.readStructBegin()
15672 
    while True:
15673 
      (fname, ftype, fid) = iprot.readFieldBegin()
15674 
      if ftype == TType.STOP:
15675 
        break
15676 
      if fid == 0:
15677 
        if ftype == TType.LIST:
15678 
          self.success = []
7256 rajveer 15679 
          (_etype294, _size291) = iprot.readListBegin()
15680 
          for _i295 in xrange(_size291):
15681 
            _elem296 = Insurer()
15682 
            _elem296.read(iprot)
15683 
            self.success.append(_elem296)
6838 vikram.rag 15684 
          iprot.readListEnd()
15685 
        else:
15686 
          iprot.skip(ftype)
15687 
      else:
15688 
        iprot.skip(ftype)
15689 
      iprot.readFieldEnd()
15690 
    iprot.readStructEnd()
15691 
 
15692 
  def write(self, oprot):
15693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15695 
      return
15696 
    oprot.writeStructBegin('getAllInsurers_result')
15697 
    if self.success is not None:
15698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15700 
      for iter297 in self.success:
15701 
        iter297.write(oprot)
6838 vikram.rag 15702 
      oprot.writeListEnd()
15703 
      oprot.writeFieldEnd()
15704 
    oprot.writeFieldStop()
15705 
    oprot.writeStructEnd()
15706 
 
15707 
  def validate(self):
15708 
    return
15709 
 
15710 
 
15711 
  def __repr__(self):
15712 
    L = ['%s=%r' % (key, value)
15713 
      for key, value in self.__dict__.iteritems()]
15714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15715 
 
15716 
  def __eq__(self, other):
15717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15718 
 
15719 
  def __ne__(self, other):
15720 
    return not (self == other)
6962 rajveer 15721 
 
15722 
class updateInsuranceDeclaredAmount_args:
15723 
  """
15724 
  Attributes:
15725 
   - insurerId
15726 
   - amount
15727 
  """
15728 
 
15729 
  thrift_spec = (
15730 
    None, # 0
15731 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15732 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15733 
  )
15734 
 
15735 
  def __init__(self, insurerId=None, amount=None,):
15736 
    self.insurerId = insurerId
15737 
    self.amount = amount
15738 
 
15739 
  def read(self, iprot):
15740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15742 
      return
15743 
    iprot.readStructBegin()
15744 
    while True:
15745 
      (fname, ftype, fid) = iprot.readFieldBegin()
15746 
      if ftype == TType.STOP:
15747 
        break
15748 
      if fid == 1:
15749 
        if ftype == TType.I64:
15750 
          self.insurerId = iprot.readI64();
15751 
        else:
15752 
          iprot.skip(ftype)
15753 
      elif fid == 2:
15754 
        if ftype == TType.DOUBLE:
15755 
          self.amount = iprot.readDouble();
15756 
        else:
15757 
          iprot.skip(ftype)
15758 
      else:
15759 
        iprot.skip(ftype)
15760 
      iprot.readFieldEnd()
15761 
    iprot.readStructEnd()
15762 
 
15763 
  def write(self, oprot):
15764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15766 
      return
15767 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15768 
    if self.insurerId is not None:
15769 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15770 
      oprot.writeI64(self.insurerId)
15771 
      oprot.writeFieldEnd()
15772 
    if self.amount is not None:
15773 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15774 
      oprot.writeDouble(self.amount)
15775 
      oprot.writeFieldEnd()
15776 
    oprot.writeFieldStop()
15777 
    oprot.writeStructEnd()
15778 
 
15779 
  def validate(self):
15780 
    return
15781 
 
15782 
 
15783 
  def __repr__(self):
15784 
    L = ['%s=%r' % (key, value)
15785 
      for key, value in self.__dict__.iteritems()]
15786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15787 
 
15788 
  def __eq__(self, other):
15789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15790 
 
15791 
  def __ne__(self, other):
15792 
    return not (self == other)
15793 
 
15794 
class updateInsuranceDeclaredAmount_result:
15795 
 
15796 
  thrift_spec = (
15797 
  )
15798 
 
15799 
  def read(self, iprot):
15800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15802 
      return
15803 
    iprot.readStructBegin()
15804 
    while True:
15805 
      (fname, ftype, fid) = iprot.readFieldBegin()
15806 
      if ftype == TType.STOP:
15807 
        break
15808 
      else:
15809 
        iprot.skip(ftype)
15810 
      iprot.readFieldEnd()
15811 
    iprot.readStructEnd()
15812 
 
15813 
  def write(self, oprot):
15814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15816 
      return
15817 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15818 
    oprot.writeFieldStop()
15819 
    oprot.writeStructEnd()
15820 
 
15821 
  def validate(self):
15822 
    return
15823 
 
15824 
 
15825 
  def __repr__(self):
15826 
    L = ['%s=%r' % (key, value)
15827 
      for key, value in self.__dict__.iteritems()]
15828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15829 
 
15830 
  def __eq__(self, other):
15831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15832 
 
15833 
  def __ne__(self, other):
15834 
    return not (self == other)
7190 amar.kumar 15835 
 
15836 
class getFreebieForItem_args:
15837 
  """
15838 
  Attributes:
15839 
   - itemId
15840 
  """
15841 
 
15842 
  thrift_spec = (
15843 
    None, # 0
15844 
    (1, TType.I64, 'itemId', None, None, ), # 1
15845 
  )
15846 
 
15847 
  def __init__(self, itemId=None,):
15848 
    self.itemId = itemId
15849 
 
15850 
  def read(self, iprot):
15851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15853 
      return
15854 
    iprot.readStructBegin()
15855 
    while True:
15856 
      (fname, ftype, fid) = iprot.readFieldBegin()
15857 
      if ftype == TType.STOP:
15858 
        break
15859 
      if fid == 1:
15860 
        if ftype == TType.I64:
15861 
          self.itemId = iprot.readI64();
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('getFreebieForItem_args')
15874 
    if self.itemId is not None:
15875 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15876 
      oprot.writeI64(self.itemId)
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 getFreebieForItem_result:
15897 
  """
15898 
  Attributes:
15899 
   - success
15900 
  """
15901 
 
15902 
  thrift_spec = (
15903 
    (0, TType.I64, 'success', None, None, ), # 0
15904 
  )
15905 
 
15906 
  def __init__(self, success=None,):
15907 
    self.success = success
15908 
 
15909 
  def read(self, iprot):
15910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15912 
      return
15913 
    iprot.readStructBegin()
15914 
    while True:
15915 
      (fname, ftype, fid) = iprot.readFieldBegin()
15916 
      if ftype == TType.STOP:
15917 
        break
15918 
      if fid == 0:
15919 
        if ftype == TType.I64:
15920 
          self.success = iprot.readI64();
15921 
        else:
15922 
          iprot.skip(ftype)
15923 
      else:
15924 
        iprot.skip(ftype)
15925 
      iprot.readFieldEnd()
15926 
    iprot.readStructEnd()
15927 
 
15928 
  def write(self, oprot):
15929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15931 
      return
15932 
    oprot.writeStructBegin('getFreebieForItem_result')
15933 
    if self.success is not None:
15934 
      oprot.writeFieldBegin('success', TType.I64, 0)
15935 
      oprot.writeI64(self.success)
15936 
      oprot.writeFieldEnd()
15937 
    oprot.writeFieldStop()
15938 
    oprot.writeStructEnd()
15939 
 
15940 
  def validate(self):
15941 
    return
15942 
 
15943 
 
15944 
  def __repr__(self):
15945 
    L = ['%s=%r' % (key, value)
15946 
      for key, value in self.__dict__.iteritems()]
15947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15948 
 
15949 
  def __eq__(self, other):
15950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15951 
 
15952 
  def __ne__(self, other):
15953 
    return not (self == other)
15954 
 
15955 
class addOrUpdateFreebieForItem_args:
15956 
  """
15957 
  Attributes:
15958 
   - freebieItem
15959 
  """
15960 
 
15961 
  thrift_spec = (
15962 
    None, # 0
15963 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
15964 
  )
15965 
 
15966 
  def __init__(self, freebieItem=None,):
15967 
    self.freebieItem = freebieItem
15968 
 
15969 
  def read(self, iprot):
15970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15972 
      return
15973 
    iprot.readStructBegin()
15974 
    while True:
15975 
      (fname, ftype, fid) = iprot.readFieldBegin()
15976 
      if ftype == TType.STOP:
15977 
        break
15978 
      if fid == 1:
15979 
        if ftype == TType.STRUCT:
15980 
          self.freebieItem = FreebieItem()
15981 
          self.freebieItem.read(iprot)
15982 
        else:
15983 
          iprot.skip(ftype)
15984 
      else:
15985 
        iprot.skip(ftype)
15986 
      iprot.readFieldEnd()
15987 
    iprot.readStructEnd()
15988 
 
15989 
  def write(self, oprot):
15990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15992 
      return
15993 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
15994 
    if self.freebieItem is not None:
15995 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
15996 
      self.freebieItem.write(oprot)
15997 
      oprot.writeFieldEnd()
15998 
    oprot.writeFieldStop()
15999 
    oprot.writeStructEnd()
16000 
 
16001 
  def validate(self):
16002 
    return
16003 
 
16004 
 
16005 
  def __repr__(self):
16006 
    L = ['%s=%r' % (key, value)
16007 
      for key, value in self.__dict__.iteritems()]
16008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16009 
 
16010 
  def __eq__(self, other):
16011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16012 
 
16013 
  def __ne__(self, other):
16014 
    return not (self == other)
16015 
 
16016 
class addOrUpdateFreebieForItem_result:
16017 
 
16018 
  thrift_spec = (
16019 
  )
16020 
 
16021 
  def read(self, iprot):
16022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16024 
      return
16025 
    iprot.readStructBegin()
16026 
    while True:
16027 
      (fname, ftype, fid) = iprot.readFieldBegin()
16028 
      if ftype == TType.STOP:
16029 
        break
16030 
      else:
16031 
        iprot.skip(ftype)
16032 
      iprot.readFieldEnd()
16033 
    iprot.readStructEnd()
16034 
 
16035 
  def write(self, oprot):
16036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16038 
      return
16039 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16040 
    oprot.writeFieldStop()
16041 
    oprot.writeStructEnd()
16042 
 
16043 
  def validate(self):
16044 
    return
16045 
 
16046 
 
16047 
  def __repr__(self):
16048 
    L = ['%s=%r' % (key, value)
16049 
      for key, value in self.__dict__.iteritems()]
16050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16051 
 
16052 
  def __eq__(self, other):
16053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16054 
 
16055 
  def __ne__(self, other):
16056 
    return not (self == other)
7256 rajveer 16057 
 
7272 amit.gupta 16058 
class addOrUpdateBrandInfo_args:
16059 
  """
16060 
  Attributes:
16061 
   - brandInfo
16062 
  """
16063 
 
16064 
  thrift_spec = (
16065 
    None, # 0
16066 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16067 
  )
16068 
 
16069 
  def __init__(self, brandInfo=None,):
16070 
    self.brandInfo = brandInfo
16071 
 
16072 
  def read(self, iprot):
16073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16075 
      return
16076 
    iprot.readStructBegin()
16077 
    while True:
16078 
      (fname, ftype, fid) = iprot.readFieldBegin()
16079 
      if ftype == TType.STOP:
16080 
        break
16081 
      if fid == 1:
16082 
        if ftype == TType.STRUCT:
16083 
          self.brandInfo = BrandInfo()
16084 
          self.brandInfo.read(iprot)
16085 
        else:
16086 
          iprot.skip(ftype)
16087 
      else:
16088 
        iprot.skip(ftype)
16089 
      iprot.readFieldEnd()
16090 
    iprot.readStructEnd()
16091 
 
16092 
  def write(self, oprot):
16093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16095 
      return
16096 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16097 
    if self.brandInfo is not None:
16098 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16099 
      self.brandInfo.write(oprot)
16100 
      oprot.writeFieldEnd()
16101 
    oprot.writeFieldStop()
16102 
    oprot.writeStructEnd()
16103 
 
16104 
  def validate(self):
16105 
    return
16106 
 
16107 
 
16108 
  def __repr__(self):
16109 
    L = ['%s=%r' % (key, value)
16110 
      for key, value in self.__dict__.iteritems()]
16111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16112 
 
16113 
  def __eq__(self, other):
16114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16115 
 
16116 
  def __ne__(self, other):
16117 
    return not (self == other)
16118 
 
16119 
class addOrUpdateBrandInfo_result:
16120 
 
16121 
  thrift_spec = (
16122 
  )
16123 
 
16124 
  def read(self, iprot):
16125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16127 
      return
16128 
    iprot.readStructBegin()
16129 
    while True:
16130 
      (fname, ftype, fid) = iprot.readFieldBegin()
16131 
      if ftype == TType.STOP:
16132 
        break
16133 
      else:
16134 
        iprot.skip(ftype)
16135 
      iprot.readFieldEnd()
16136 
    iprot.readStructEnd()
16137 
 
16138 
  def write(self, oprot):
16139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16141 
      return
16142 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16143 
    oprot.writeFieldStop()
16144 
    oprot.writeStructEnd()
16145 
 
16146 
  def validate(self):
16147 
    return
16148 
 
16149 
 
16150 
  def __repr__(self):
16151 
    L = ['%s=%r' % (key, value)
16152 
      for key, value in self.__dict__.iteritems()]
16153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16154 
 
16155 
  def __eq__(self, other):
16156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16157 
 
16158 
  def __ne__(self, other):
16159 
    return not (self == other)
16160 
 
16161 
class getBrandInfo_args:
16162 
 
16163 
  thrift_spec = (
16164 
  )
16165 
 
16166 
  def read(self, iprot):
16167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16169 
      return
16170 
    iprot.readStructBegin()
16171 
    while True:
16172 
      (fname, ftype, fid) = iprot.readFieldBegin()
16173 
      if ftype == TType.STOP:
16174 
        break
16175 
      else:
16176 
        iprot.skip(ftype)
16177 
      iprot.readFieldEnd()
16178 
    iprot.readStructEnd()
16179 
 
16180 
  def write(self, oprot):
16181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16183 
      return
16184 
    oprot.writeStructBegin('getBrandInfo_args')
16185 
    oprot.writeFieldStop()
16186 
    oprot.writeStructEnd()
16187 
 
16188 
  def validate(self):
16189 
    return
16190 
 
16191 
 
16192 
  def __repr__(self):
16193 
    L = ['%s=%r' % (key, value)
16194 
      for key, value in self.__dict__.iteritems()]
16195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16196 
 
16197 
  def __eq__(self, other):
16198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16199 
 
16200 
  def __ne__(self, other):
16201 
    return not (self == other)
16202 
 
16203 
class getBrandInfo_result:
16204 
  """
16205 
  Attributes:
16206 
   - success
16207 
  """
16208 
 
16209 
  thrift_spec = (
16210 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16211 
  )
16212 
 
16213 
  def __init__(self, success=None,):
16214 
    self.success = success
16215 
 
16216 
  def read(self, iprot):
16217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16219 
      return
16220 
    iprot.readStructBegin()
16221 
    while True:
16222 
      (fname, ftype, fid) = iprot.readFieldBegin()
16223 
      if ftype == TType.STOP:
16224 
        break
16225 
      if fid == 0:
16226 
        if ftype == TType.MAP:
16227 
          self.success = {}
16228 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16229 
          for _i302 in xrange(_size298):
16230 
            _key303 = iprot.readString();
16231 
            _val304 = BrandInfo()
16232 
            _val304.read(iprot)
16233 
            self.success[_key303] = _val304
16234 
          iprot.readMapEnd()
16235 
        else:
16236 
          iprot.skip(ftype)
16237 
      else:
16238 
        iprot.skip(ftype)
16239 
      iprot.readFieldEnd()
16240 
    iprot.readStructEnd()
16241 
 
16242 
  def write(self, oprot):
16243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16245 
      return
16246 
    oprot.writeStructBegin('getBrandInfo_result')
16247 
    if self.success is not None:
16248 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16249 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16250 
      for kiter305,viter306 in self.success.items():
16251 
        oprot.writeString(kiter305)
16252 
        viter306.write(oprot)
16253 
      oprot.writeMapEnd()
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)
16272 
 
7256 rajveer 16273 
class getStorePricing_args:
16274 
  """
16275 
  Attributes:
16276 
   - itemId
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    None, # 0
16281 
    (1, TType.I64, 'itemId', None, None, ), # 1
16282 
  )
16283 
 
16284 
  def __init__(self, itemId=None,):
16285 
    self.itemId = itemId
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.I64:
16298 
          self.itemId = iprot.readI64();
16299 
        else:
16300 
          iprot.skip(ftype)
16301 
      else:
16302 
        iprot.skip(ftype)
16303 
      iprot.readFieldEnd()
16304 
    iprot.readStructEnd()
16305 
 
16306 
  def write(self, oprot):
16307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16309 
      return
16310 
    oprot.writeStructBegin('getStorePricing_args')
16311 
    if self.itemId is not None:
16312 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16313 
      oprot.writeI64(self.itemId)
16314 
      oprot.writeFieldEnd()
16315 
    oprot.writeFieldStop()
16316 
    oprot.writeStructEnd()
16317 
 
16318 
  def validate(self):
16319 
    return
16320 
 
16321 
 
16322 
  def __repr__(self):
16323 
    L = ['%s=%r' % (key, value)
16324 
      for key, value in self.__dict__.iteritems()]
16325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16326 
 
16327 
  def __eq__(self, other):
16328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16329 
 
16330 
  def __ne__(self, other):
16331 
    return not (self == other)
16332 
 
16333 
class getStorePricing_result:
16334 
  """
16335 
  Attributes:
16336 
   - success
16337 
  """
16338 
 
16339 
  thrift_spec = (
16340 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16341 
  )
16342 
 
16343 
  def __init__(self, success=None,):
16344 
    self.success = success
16345 
 
16346 
  def read(self, iprot):
16347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16349 
      return
16350 
    iprot.readStructBegin()
16351 
    while True:
16352 
      (fname, ftype, fid) = iprot.readFieldBegin()
16353 
      if ftype == TType.STOP:
16354 
        break
16355 
      if fid == 0:
16356 
        if ftype == TType.STRUCT:
16357 
          self.success = StorePricing()
16358 
          self.success.read(iprot)
16359 
        else:
16360 
          iprot.skip(ftype)
16361 
      else:
16362 
        iprot.skip(ftype)
16363 
      iprot.readFieldEnd()
16364 
    iprot.readStructEnd()
16365 
 
16366 
  def write(self, oprot):
16367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16369 
      return
16370 
    oprot.writeStructBegin('getStorePricing_result')
16371 
    if self.success is not None:
16372 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16373 
      self.success.write(oprot)
16374 
      oprot.writeFieldEnd()
16375 
    oprot.writeFieldStop()
16376 
    oprot.writeStructEnd()
16377 
 
16378 
  def validate(self):
16379 
    return
16380 
 
16381 
 
16382 
  def __repr__(self):
16383 
    L = ['%s=%r' % (key, value)
16384 
      for key, value in self.__dict__.iteritems()]
16385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16386 
 
16387 
  def __eq__(self, other):
16388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16389 
 
16390 
  def __ne__(self, other):
16391 
    return not (self == other)
7265 rajveer 16392 
 
16393 
class updateStorePricing_args:
16394 
  """
16395 
  Attributes:
16396 
   - sp
16397 
  """
16398 
 
16399 
  thrift_spec = (
16400 
    None, # 0
16401 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16402 
  )
16403 
 
16404 
  def __init__(self, sp=None,):
16405 
    self.sp = sp
16406 
 
16407 
  def read(self, iprot):
16408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16410 
      return
16411 
    iprot.readStructBegin()
16412 
    while True:
16413 
      (fname, ftype, fid) = iprot.readFieldBegin()
16414 
      if ftype == TType.STOP:
16415 
        break
16416 
      if fid == 1:
16417 
        if ftype == TType.STRUCT:
16418 
          self.sp = StorePricing()
16419 
          self.sp.read(iprot)
16420 
        else:
16421 
          iprot.skip(ftype)
16422 
      else:
16423 
        iprot.skip(ftype)
16424 
      iprot.readFieldEnd()
16425 
    iprot.readStructEnd()
16426 
 
16427 
  def write(self, oprot):
16428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16430 
      return
16431 
    oprot.writeStructBegin('updateStorePricing_args')
16432 
    if self.sp is not None:
16433 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16434 
      self.sp.write(oprot)
16435 
      oprot.writeFieldEnd()
16436 
    oprot.writeFieldStop()
16437 
    oprot.writeStructEnd()
16438 
 
16439 
  def validate(self):
16440 
    return
16441 
 
16442 
 
16443 
  def __repr__(self):
16444 
    L = ['%s=%r' % (key, value)
16445 
      for key, value in self.__dict__.iteritems()]
16446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16447 
 
16448 
  def __eq__(self, other):
16449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16450 
 
16451 
  def __ne__(self, other):
16452 
    return not (self == other)
16453 
 
16454 
class updateStorePricing_result:
16455 
 
16456 
  thrift_spec = (
16457 
  )
16458 
 
16459 
  def read(self, iprot):
16460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16462 
      return
16463 
    iprot.readStructBegin()
16464 
    while True:
16465 
      (fname, ftype, fid) = iprot.readFieldBegin()
16466 
      if ftype == TType.STOP:
16467 
        break
16468 
      else:
16469 
        iprot.skip(ftype)
16470 
      iprot.readFieldEnd()
16471 
    iprot.readStructEnd()
16472 
 
16473 
  def write(self, oprot):
16474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16476 
      return
16477 
    oprot.writeStructBegin('updateStorePricing_result')
16478 
    oprot.writeFieldStop()
16479 
    oprot.writeStructEnd()
16480 
 
16481 
  def validate(self):
16482 
    return
16483 
 
16484 
 
16485 
  def __repr__(self):
16486 
    L = ['%s=%r' % (key, value)
16487 
      for key, value in self.__dict__.iteritems()]
16488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16489 
 
16490 
  def __eq__(self, other):
16491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16492 
 
16493 
  def __ne__(self, other):
16494 
    return not (self == other)
7281 kshitij.so 16495 
 
16496 
class getAllAmazonListedItems_args:
16497 
 
16498 
  thrift_spec = (
16499 
  )
16500 
 
16501 
  def read(self, iprot):
16502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16504 
      return
16505 
    iprot.readStructBegin()
16506 
    while True:
16507 
      (fname, ftype, fid) = iprot.readFieldBegin()
16508 
      if ftype == TType.STOP:
16509 
        break
16510 
      else:
16511 
        iprot.skip(ftype)
16512 
      iprot.readFieldEnd()
16513 
    iprot.readStructEnd()
16514 
 
16515 
  def write(self, oprot):
16516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16518 
      return
16519 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16520 
    oprot.writeFieldStop()
16521 
    oprot.writeStructEnd()
16522 
 
16523 
  def validate(self):
16524 
    return
16525 
 
16526 
 
16527 
  def __repr__(self):
16528 
    L = ['%s=%r' % (key, value)
16529 
      for key, value in self.__dict__.iteritems()]
16530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16531 
 
16532 
  def __eq__(self, other):
16533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16534 
 
16535 
  def __ne__(self, other):
16536 
    return not (self == other)
16537 
 
16538 
class getAllAmazonListedItems_result:
16539 
  """
16540 
  Attributes:
16541 
   - success
16542 
  """
16543 
 
16544 
  thrift_spec = (
16545 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16546 
  )
16547 
 
16548 
  def __init__(self, success=None,):
16549 
    self.success = success
16550 
 
16551 
  def read(self, iprot):
16552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16554 
      return
16555 
    iprot.readStructBegin()
16556 
    while True:
16557 
      (fname, ftype, fid) = iprot.readFieldBegin()
16558 
      if ftype == TType.STOP:
16559 
        break
16560 
      if fid == 0:
16561 
        if ftype == TType.LIST:
16562 
          self.success = []
16563 
          (_etype310, _size307) = iprot.readListBegin()
16564 
          for _i311 in xrange(_size307):
16565 
            _elem312 = Amazonlisted()
16566 
            _elem312.read(iprot)
16567 
            self.success.append(_elem312)
16568 
          iprot.readListEnd()
16569 
        else:
16570 
          iprot.skip(ftype)
16571 
      else:
16572 
        iprot.skip(ftype)
16573 
      iprot.readFieldEnd()
16574 
    iprot.readStructEnd()
16575 
 
16576 
  def write(self, oprot):
16577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16579 
      return
16580 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16581 
    if self.success is not None:
16582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16584 
      for iter313 in self.success:
16585 
        iter313.write(oprot)
16586 
      oprot.writeListEnd()
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 getAmazonItemDetails_args:
16607 
  """
16608 
  Attributes:
16609 
   - itemId
16610 
  """
16611 
 
16612 
  thrift_spec = (
16613 
    None, # 0
16614 
    (1, TType.I64, 'itemId', None, None, ), # 1
16615 
  )
16616 
 
16617 
  def __init__(self, itemId=None,):
16618 
    self.itemId = itemId
16619 
 
16620 
  def read(self, iprot):
16621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16623 
      return
16624 
    iprot.readStructBegin()
16625 
    while True:
16626 
      (fname, ftype, fid) = iprot.readFieldBegin()
16627 
      if ftype == TType.STOP:
16628 
        break
16629 
      if fid == 1:
16630 
        if ftype == TType.I64:
16631 
          self.itemId = iprot.readI64();
16632 
        else:
16633 
          iprot.skip(ftype)
16634 
      else:
16635 
        iprot.skip(ftype)
16636 
      iprot.readFieldEnd()
16637 
    iprot.readStructEnd()
16638 
 
16639 
  def write(self, oprot):
16640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16642 
      return
16643 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16644 
    if self.itemId is not None:
16645 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16646 
      oprot.writeI64(self.itemId)
16647 
      oprot.writeFieldEnd()
16648 
    oprot.writeFieldStop()
16649 
    oprot.writeStructEnd()
16650 
 
16651 
  def validate(self):
16652 
    return
16653 
 
16654 
 
16655 
  def __repr__(self):
16656 
    L = ['%s=%r' % (key, value)
16657 
      for key, value in self.__dict__.iteritems()]
16658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16659 
 
16660 
  def __eq__(self, other):
16661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16662 
 
16663 
  def __ne__(self, other):
16664 
    return not (self == other)
16665 
 
16666 
class getAmazonItemDetails_result:
16667 
  """
16668 
  Attributes:
16669 
   - success
16670 
  """
16671 
 
16672 
  thrift_spec = (
16673 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16674 
  )
16675 
 
16676 
  def __init__(self, success=None,):
16677 
    self.success = success
16678 
 
16679 
  def read(self, iprot):
16680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16682 
      return
16683 
    iprot.readStructBegin()
16684 
    while True:
16685 
      (fname, ftype, fid) = iprot.readFieldBegin()
16686 
      if ftype == TType.STOP:
16687 
        break
16688 
      if fid == 0:
16689 
        if ftype == TType.STRUCT:
16690 
          self.success = Amazonlisted()
16691 
          self.success.read(iprot)
16692 
        else:
16693 
          iprot.skip(ftype)
16694 
      else:
16695 
        iprot.skip(ftype)
16696 
      iprot.readFieldEnd()
16697 
    iprot.readStructEnd()
16698 
 
16699 
  def write(self, oprot):
16700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16702 
      return
16703 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16704 
    if self.success is not None:
16705 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16706 
      self.success.write(oprot)
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_args:
16727 
  """
16728 
  Attributes:
16729 
   - itemId
16730 
   - fbaPrice
16731 
   - sellingPrice
16732 
   - isFba
16733 
   - isNonFba
16734 
   - isInventoryOverride
16735 
  """
16736 
 
16737 
  thrift_spec = (
16738 
    None, # 0
16739 
    (1, TType.I64, 'itemId', None, None, ), # 1
16740 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16741 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16742 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16743 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16744 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
16745 
  )
16746 
 
16747 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None,):
16748 
    self.itemId = itemId
16749 
    self.fbaPrice = fbaPrice
16750 
    self.sellingPrice = sellingPrice
16751 
    self.isFba = isFba
16752 
    self.isNonFba = isNonFba
16753 
    self.isInventoryOverride = isInventoryOverride
16754 
 
16755 
  def read(self, iprot):
16756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16758 
      return
16759 
    iprot.readStructBegin()
16760 
    while True:
16761 
      (fname, ftype, fid) = iprot.readFieldBegin()
16762 
      if ftype == TType.STOP:
16763 
        break
16764 
      if fid == 1:
16765 
        if ftype == TType.I64:
16766 
          self.itemId = iprot.readI64();
16767 
        else:
16768 
          iprot.skip(ftype)
16769 
      elif fid == 2:
16770 
        if ftype == TType.DOUBLE:
16771 
          self.fbaPrice = iprot.readDouble();
16772 
        else:
16773 
          iprot.skip(ftype)
16774 
      elif fid == 3:
16775 
        if ftype == TType.DOUBLE:
16776 
          self.sellingPrice = iprot.readDouble();
16777 
        else:
16778 
          iprot.skip(ftype)
16779 
      elif fid == 4:
16780 
        if ftype == TType.BOOL:
16781 
          self.isFba = iprot.readBool();
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      elif fid == 5:
16785 
        if ftype == TType.BOOL:
16786 
          self.isNonFba = iprot.readBool();
16787 
        else:
16788 
          iprot.skip(ftype)
16789 
      elif fid == 6:
16790 
        if ftype == TType.BOOL:
16791 
          self.isInventoryOverride = iprot.readBool();
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
16804 
    if self.itemId is not None:
16805 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16806 
      oprot.writeI64(self.itemId)
16807 
      oprot.writeFieldEnd()
16808 
    if self.fbaPrice is not None:
16809 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
16810 
      oprot.writeDouble(self.fbaPrice)
16811 
      oprot.writeFieldEnd()
16812 
    if self.sellingPrice is not None:
16813 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
16814 
      oprot.writeDouble(self.sellingPrice)
16815 
      oprot.writeFieldEnd()
16816 
    if self.isFba is not None:
16817 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
16818 
      oprot.writeBool(self.isFba)
16819 
      oprot.writeFieldEnd()
16820 
    if self.isNonFba is not None:
16821 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
16822 
      oprot.writeBool(self.isNonFba)
16823 
      oprot.writeFieldEnd()
16824 
    if self.isInventoryOverride is not None:
16825 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
16826 
      oprot.writeBool(self.isInventoryOverride)
16827 
      oprot.writeFieldEnd()
16828 
    oprot.writeFieldStop()
16829 
    oprot.writeStructEnd()
16830 
 
16831 
  def validate(self):
16832 
    return
16833 
 
16834 
 
16835 
  def __repr__(self):
16836 
    L = ['%s=%r' % (key, value)
16837 
      for key, value in self.__dict__.iteritems()]
16838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16839 
 
16840 
  def __eq__(self, other):
16841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16842 
 
16843 
  def __ne__(self, other):
16844 
    return not (self == other)
16845 
 
16846 
class updateAmazonItemDetails_result:
16847 
 
16848 
  thrift_spec = (
16849 
  )
16850 
 
16851 
  def read(self, iprot):
16852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16854 
      return
16855 
    iprot.readStructBegin()
16856 
    while True:
16857 
      (fname, ftype, fid) = iprot.readFieldBegin()
16858 
      if ftype == TType.STOP:
16859 
        break
16860 
      else:
16861 
        iprot.skip(ftype)
16862 
      iprot.readFieldEnd()
16863 
    iprot.readStructEnd()
16864 
 
16865 
  def write(self, oprot):
16866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16868 
      return
16869 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
16888 
class addAmazonItem_args:
16889 
  """
16890 
  Attributes:
16891 
   - amazonlisted
16892 
  """
16893 
 
16894 
  thrift_spec = (
16895 
    None, # 0
16896 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
16897 
  )
16898 
 
16899 
  def __init__(self, amazonlisted=None,):
16900 
    self.amazonlisted = amazonlisted
16901 
 
16902 
  def read(self, iprot):
16903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16905 
      return
16906 
    iprot.readStructBegin()
16907 
    while True:
16908 
      (fname, ftype, fid) = iprot.readFieldBegin()
16909 
      if ftype == TType.STOP:
16910 
        break
16911 
      if fid == 1:
16912 
        if ftype == TType.STRUCT:
16913 
          self.amazonlisted = Amazonlisted()
16914 
          self.amazonlisted.read(iprot)
16915 
        else:
16916 
          iprot.skip(ftype)
16917 
      else:
16918 
        iprot.skip(ftype)
16919 
      iprot.readFieldEnd()
16920 
    iprot.readStructEnd()
16921 
 
16922 
  def write(self, oprot):
16923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16925 
      return
16926 
    oprot.writeStructBegin('addAmazonItem_args')
16927 
    if self.amazonlisted is not None:
16928 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
16929 
      self.amazonlisted.write(oprot)
16930 
      oprot.writeFieldEnd()
16931 
    oprot.writeFieldStop()
16932 
    oprot.writeStructEnd()
16933 
 
16934 
  def validate(self):
16935 
    return
16936 
 
16937 
 
16938 
  def __repr__(self):
16939 
    L = ['%s=%r' % (key, value)
16940 
      for key, value in self.__dict__.iteritems()]
16941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16942 
 
16943 
  def __eq__(self, other):
16944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16945 
 
16946 
  def __ne__(self, other):
16947 
    return not (self == other)
16948 
 
16949 
class addAmazonItem_result:
16950 
 
16951 
  thrift_spec = (
16952 
  )
16953 
 
16954 
  def read(self, iprot):
16955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16957 
      return
16958 
    iprot.readStructBegin()
16959 
    while True:
16960 
      (fname, ftype, fid) = iprot.readFieldBegin()
16961 
      if ftype == TType.STOP:
16962 
        break
16963 
      else:
16964 
        iprot.skip(ftype)
16965 
      iprot.readFieldEnd()
16966 
    iprot.readStructEnd()
16967 
 
16968 
  def write(self, oprot):
16969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16971 
      return
16972 
    oprot.writeStructBegin('addAmazonItem_result')
16973 
    oprot.writeFieldStop()
16974 
    oprot.writeStructEnd()
16975 
 
16976 
  def validate(self):
16977 
    return
16978 
 
16979 
 
16980 
  def __repr__(self):
16981 
    L = ['%s=%r' % (key, value)
16982 
      for key, value in self.__dict__.iteritems()]
16983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16984 
 
16985 
  def __eq__(self, other):
16986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16987 
 
16988 
  def __ne__(self, other):
16989 
    return not (self == other)
7291 vikram.rag 16990 
 
16991 
class getAsinItems_args:
16992 
 
16993 
  thrift_spec = (
16994 
  )
16995 
 
16996 
  def read(self, iprot):
16997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16999 
      return
17000 
    iprot.readStructBegin()
17001 
    while True:
17002 
      (fname, ftype, fid) = iprot.readFieldBegin()
17003 
      if ftype == TType.STOP:
17004 
        break
17005 
      else:
17006 
        iprot.skip(ftype)
17007 
      iprot.readFieldEnd()
17008 
    iprot.readStructEnd()
17009 
 
17010 
  def write(self, oprot):
17011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17013 
      return
17014 
    oprot.writeStructBegin('getAsinItems_args')
17015 
    oprot.writeFieldStop()
17016 
    oprot.writeStructEnd()
17017 
 
17018 
  def validate(self):
17019 
    return
17020 
 
17021 
 
17022 
  def __repr__(self):
17023 
    L = ['%s=%r' % (key, value)
17024 
      for key, value in self.__dict__.iteritems()]
17025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17026 
 
17027 
  def __eq__(self, other):
17028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17029 
 
17030 
  def __ne__(self, other):
17031 
    return not (self == other)
17032 
 
17033 
class getAsinItems_result:
17034 
  """
17035 
  Attributes:
17036 
   - success
17037 
  """
17038 
 
17039 
  thrift_spec = (
17040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17041 
  )
17042 
 
17043 
  def __init__(self, success=None,):
17044 
    self.success = success
17045 
 
17046 
  def read(self, iprot):
17047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17049 
      return
17050 
    iprot.readStructBegin()
17051 
    while True:
17052 
      (fname, ftype, fid) = iprot.readFieldBegin()
17053 
      if ftype == TType.STOP:
17054 
        break
17055 
      if fid == 0:
17056 
        if ftype == TType.LIST:
17057 
          self.success = []
17058 
          (_etype317, _size314) = iprot.readListBegin()
17059 
          for _i318 in xrange(_size314):
17060 
            _elem319 = Item()
17061 
            _elem319.read(iprot)
17062 
            self.success.append(_elem319)
17063 
          iprot.readListEnd()
17064 
        else:
17065 
          iprot.skip(ftype)
17066 
      else:
17067 
        iprot.skip(ftype)
17068 
      iprot.readFieldEnd()
17069 
    iprot.readStructEnd()
17070 
 
17071 
  def write(self, oprot):
17072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17074 
      return
17075 
    oprot.writeStructBegin('getAsinItems_result')
17076 
    if self.success is not None:
17077 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17078 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17079 
      for iter320 in self.success:
17080 
        iter320.write(oprot)
17081 
      oprot.writeListEnd()
17082 
      oprot.writeFieldEnd()
17083 
    oprot.writeFieldStop()
17084 
    oprot.writeStructEnd()
17085 
 
17086 
  def validate(self):
17087 
    return
17088 
 
17089 
 
17090 
  def __repr__(self):
17091 
    L = ['%s=%r' % (key, value)
17092 
      for key, value in self.__dict__.iteritems()]
17093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17094 
 
17095 
  def __eq__(self, other):
17096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17097 
 
17098 
  def __ne__(self, other):
17099 
    return not (self == other)
17100 
 
17101 
class getAllFbaListedItems_args:
17102 
 
17103 
  thrift_spec = (
17104 
  )
17105 
 
17106 
  def read(self, iprot):
17107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17109 
      return
17110 
    iprot.readStructBegin()
17111 
    while True:
17112 
      (fname, ftype, fid) = iprot.readFieldBegin()
17113 
      if ftype == TType.STOP:
17114 
        break
17115 
      else:
17116 
        iprot.skip(ftype)
17117 
      iprot.readFieldEnd()
17118 
    iprot.readStructEnd()
17119 
 
17120 
  def write(self, oprot):
17121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17123 
      return
17124 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17125 
    oprot.writeFieldStop()
17126 
    oprot.writeStructEnd()
17127 
 
17128 
  def validate(self):
17129 
    return
17130 
 
17131 
 
17132 
  def __repr__(self):
17133 
    L = ['%s=%r' % (key, value)
17134 
      for key, value in self.__dict__.iteritems()]
17135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17136 
 
17137 
  def __eq__(self, other):
17138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17139 
 
17140 
  def __ne__(self, other):
17141 
    return not (self == other)
17142 
 
17143 
class getAllFbaListedItems_result:
17144 
  """
17145 
  Attributes:
17146 
   - success
17147 
  """
17148 
 
17149 
  thrift_spec = (
17150 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17151 
  )
17152 
 
17153 
  def __init__(self, success=None,):
17154 
    self.success = success
17155 
 
17156 
  def read(self, iprot):
17157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17159 
      return
17160 
    iprot.readStructBegin()
17161 
    while True:
17162 
      (fname, ftype, fid) = iprot.readFieldBegin()
17163 
      if ftype == TType.STOP:
17164 
        break
17165 
      if fid == 0:
17166 
        if ftype == TType.LIST:
17167 
          self.success = []
17168 
          (_etype324, _size321) = iprot.readListBegin()
17169 
          for _i325 in xrange(_size321):
17170 
            _elem326 = Amazonlisted()
17171 
            _elem326.read(iprot)
17172 
            self.success.append(_elem326)
17173 
          iprot.readListEnd()
17174 
        else:
17175 
          iprot.skip(ftype)
17176 
      else:
17177 
        iprot.skip(ftype)
17178 
      iprot.readFieldEnd()
17179 
    iprot.readStructEnd()
17180 
 
17181 
  def write(self, oprot):
17182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17184 
      return
17185 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17186 
    if self.success is not None:
17187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17189 
      for iter327 in self.success:
17190 
        iter327.write(oprot)
17191 
      oprot.writeListEnd()
17192 
      oprot.writeFieldEnd()
17193 
    oprot.writeFieldStop()
17194 
    oprot.writeStructEnd()
17195 
 
17196 
  def validate(self):
17197 
    return
17198 
 
17199 
 
17200 
  def __repr__(self):
17201 
    L = ['%s=%r' % (key, value)
17202 
      for key, value in self.__dict__.iteritems()]
17203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17204 
 
17205 
  def __eq__(self, other):
17206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17207 
 
17208 
  def __ne__(self, other):
17209 
    return not (self == other)
17210 
 
17211 
class getAllNonFbaListedItems_args:
17212 
 
17213 
  thrift_spec = (
17214 
  )
17215 
 
17216 
  def read(self, iprot):
17217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17219 
      return
17220 
    iprot.readStructBegin()
17221 
    while True:
17222 
      (fname, ftype, fid) = iprot.readFieldBegin()
17223 
      if ftype == TType.STOP:
17224 
        break
17225 
      else:
17226 
        iprot.skip(ftype)
17227 
      iprot.readFieldEnd()
17228 
    iprot.readStructEnd()
17229 
 
17230 
  def write(self, oprot):
17231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17233 
      return
17234 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17235 
    oprot.writeFieldStop()
17236 
    oprot.writeStructEnd()
17237 
 
17238 
  def validate(self):
17239 
    return
17240 
 
17241 
 
17242 
  def __repr__(self):
17243 
    L = ['%s=%r' % (key, value)
17244 
      for key, value in self.__dict__.iteritems()]
17245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17246 
 
17247 
  def __eq__(self, other):
17248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17249 
 
17250 
  def __ne__(self, other):
17251 
    return not (self == other)
17252 
 
17253 
class getAllNonFbaListedItems_result:
17254 
  """
17255 
  Attributes:
17256 
   - success
17257 
  """
17258 
 
17259 
  thrift_spec = (
17260 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17261 
  )
17262 
 
17263 
  def __init__(self, success=None,):
17264 
    self.success = success
17265 
 
17266 
  def read(self, iprot):
17267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17269 
      return
17270 
    iprot.readStructBegin()
17271 
    while True:
17272 
      (fname, ftype, fid) = iprot.readFieldBegin()
17273 
      if ftype == TType.STOP:
17274 
        break
17275 
      if fid == 0:
17276 
        if ftype == TType.LIST:
17277 
          self.success = []
17278 
          (_etype331, _size328) = iprot.readListBegin()
17279 
          for _i332 in xrange(_size328):
17280 
            _elem333 = Amazonlisted()
17281 
            _elem333.read(iprot)
17282 
            self.success.append(_elem333)
17283 
          iprot.readListEnd()
17284 
        else:
17285 
          iprot.skip(ftype)
17286 
      else:
17287 
        iprot.skip(ftype)
17288 
      iprot.readFieldEnd()
17289 
    iprot.readStructEnd()
17290 
 
17291 
  def write(self, oprot):
17292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17294 
      return
17295 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17296 
    if self.success is not None:
17297 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17298 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
17299 
      for iter334 in self.success:
17300 
        iter334.write(oprot)
17301 
      oprot.writeListEnd()
17302 
      oprot.writeFieldEnd()
17303 
    oprot.writeFieldStop()
17304 
    oprot.writeStructEnd()
17305 
 
17306 
  def validate(self):
17307 
    return
17308 
 
17309 
 
17310 
  def __repr__(self):
17311 
    L = ['%s=%r' % (key, value)
17312 
      for key, value in self.__dict__.iteritems()]
17313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17314 
 
17315 
  def __eq__(self, other):
17316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17317 
 
17318 
  def __ne__(self, other):
17319 
    return not (self == other)