Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
46 
  def getItemStatusDescription(self, itemId):
47 
    """
48 
    Parameters:
49 
     - itemId
50 
    """
51 
    pass
52 
 
53 
  def startItemOn(self, item_id, timestamp):
54 
    """
55 
    Parameters:
56 
     - item_id
57 
     - timestamp
58 
    """
59 
    pass
60 
 
61 
  def retireItemOn(self, item_id, timestamp):
62 
    """
63 
    Parameters:
64 
     - item_id
65 
     - timestamp
66 
    """
67 
    pass
68 
 
69 
  def changeItemStatus(self, item_id, timestamp, newstatus):
70 
    """
71 
    Parameters:
72 
     - item_id
73 
     - timestamp
74 
     - newstatus
75 
    """
76 
    pass
77 
 
78 
  def getItem(self, item_id):
79 
    """
80 
    Parameters:
81 
     - item_id
82 
    """
83 
    pass
84 
 
85 
  def getItemsByCatalogId(self, catalog_item_id):
86 
    """
87 
    Parameters:
88 
     - catalog_item_id
89 
    """
90 
    pass
91 
 
92 
  def getValidItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getAllItems(self, isActive):
100 
    """
101 
    Parameters:
102 
     - isActive
103 
    """
104 
    pass
105 
 
106 
  def getAllItemsByStatus(self, itemStatus):
107 
    """
108 
    Parameters:
109 
     - itemStatus
110 
    """
111 
    pass
112 
 
113 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
114 
    """
115 
    Parameters:
116 
     - entityId
117 
     - category
118 
     - brand
119 
     - modelName
120 
     - modelNumber
121 
    """
122 
    pass
123 
 
124 
  def getAllItemsInRange(self, offset, limit):
125 
    """
126 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
127 
 
128 
    Parameters:
129 
     - offset
130 
     - limit
131 
    """
132 
    pass
133 
 
134 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
135 
    """
136 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
137 
 
138 
    Parameters:
139 
     - itemStatus
140 
     - offset
141 
     - limit
142 
    """
143 
    pass
144 
 
145 
  def getItemCountByStatus(self, useStatus, itemStatus):
146 
    """
147 
    Gets a count of all items by status
148 
 
149 
    Parameters:
150 
     - useStatus
151 
     - itemStatus
152 
    """
153 
    pass
154 
 
155 
  def getBestSellers(self, ):
156 
    pass
157 
 
158 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
159 
    """
160 
    Parameters:
161 
     - beginIndex
162 
     - totalItems
163 
     - brand
164 
     - category
165 
    """
166 
    pass
167 
 
168 
  def getBestSellersCount(self, ):
169 
    pass
170 
 
171 
  def getBestDeals(self, ):
172 
    pass
173 
 
174 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
175 
    """
176 
    Parameters:
177 
     - beginIndex
178 
     - totalItems
179 
     - brand
180 
     - category
181 
    """
182 
    pass
183 
 
184 
  def getBestDealsCount(self, ):
185 
    pass
186 
 
187 
  def getComingSoon(self, ):
188 
    pass
189 
 
190 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
191 
    """
192 
    Parameters:
193 
     - beginIndex
194 
     - totalItems
195 
     - brand
196 
     - category
197 
    """
198 
    pass
199 
 
200 
  def getComingSoonCount(self, ):
201 
    pass
202 
 
203 
  def getLatestArrivals(self, ):
204 
    """
205 
    Returns a list of items sorted in the descending order by start date.
206 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
207 
    """
208 
    pass
209 
 
210 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
211 
    """
212 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
213 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
214 
 
215 
    Parameters:
216 
     - beginIndex
217 
     - totalItems
218 
     - brand
219 
     - categories
220 
    """
221 
    pass
222 
 
223 
  def getLatestArrivalsCount(self, ):
224 
    """
225 
    Get the total number of latest arrivals we are willing to show.
226 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
227 
    """
228 
    pass
229 
 
230 
  def generateNewEntityID(self, ):
231 
    pass
232 
 
233 
  def addCategory(self, category):
234 
    """
235 
    All category related functions
236 
 
237 
    Parameters:
238 
     - category
239 
    """
240 
    pass
241 
 
242 
  def getCategory(self, id):
243 
    """
244 
    Parameters:
245 
     - id
246 
    """
247 
    pass
248 
 
249 
  def getAllCategories(self, ):
250 
    pass
251 
 
252 
  def getAllSimilarItems(self, itemId):
253 
    """
254 
    Returns the list of similar items.
255 
 
256 
    Parameters:
257 
     - itemId
258 
    """
259 
    pass
260 
 
261 
  def addSimilarItem(self, itemId, catalogItemId):
262 
    """
263 
    Adds similar item.
264 
 
265 
    Parameters:
266 
     - itemId
267 
     - catalogItemId
268 
    """
269 
    pass
270 
 
6512 kshitij.so 271 
  def addTag(self, displayName, itemId):
272 
    """
273 
    Tag Related
274 
 
275 
    Parameters:
276 
     - displayName
277 
     - itemId
278 
    """
279 
    pass
280 
 
281 
  def deleteEntityTag(self, displayName, itemId):
282 
    """
283 
    Parameters:
284 
     - displayName
285 
     - itemId
286 
    """
287 
    pass
288 
 
289 
  def deleteTag(self, displayName):
290 
    """
291 
    Parameters:
292 
     - displayName
293 
    """
294 
    pass
295 
 
296 
  def getAllTags(self, ):
297 
    pass
298 
 
299 
  def getAllEntitiesByTagName(self, displayName):
300 
    """
301 
    Parameters:
302 
     - displayName
303 
    """
304 
    pass
305 
 
6845 amit.gupta 306 
  def getAllEntityTags(self, ):
307 
    pass
308 
 
6850 kshitij.so 309 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
310 
    """
311 
    Parameters:
312 
     - bannerName
313 
     - imageName
314 
     - link
315 
     - priority
316 
     - isActive
317 
     - hasMap
318 
    """
319 
    pass
320 
 
321 
  def getAllBanners(self, ):
322 
    pass
323 
 
324 
  def deleteBanner(self, bannerName):
325 
    """
326 
    Parameters:
327 
     - bannerName
328 
    """
329 
    pass
330 
 
331 
  def getBannerDetails(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getActiveBanners(self, ):
339 
    pass
340 
 
6849 kshitij.so 341 
  def addBannerMap(self, bannerName, mapLink, coordinates):
342 
    """
343 
    Parameters:
344 
     - bannerName
345 
     - mapLink
346 
     - coordinates
347 
    """
348 
    pass
349 
 
350 
  def deleteBannerMap(self, bannerName):
351 
    """
352 
    Parameters:
353 
     - bannerName
354 
    """
355 
    pass
356 
 
357 
  def getBannerMapDetails(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
5944 mandeep.dh 364 
  def deleteSimilarItem(self, itemId, catalogItemId):
365 
    """
366 
    Delete similar item.
367 
 
368 
    Parameters:
369 
     - itemId
370 
     - catalogItemId
371 
    """
372 
    pass
373 
 
374 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
375 
    """
376 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
377 
    If yes, returns the itemId else returns 0
378 
 
379 
    Parameters:
380 
     - brand
381 
     - modelNumber
382 
     - modelName
383 
     - color
384 
    """
385 
    pass
386 
 
387 
  def validateRiskyStatus(self, itemId):
388 
    """
389 
    Check wether item is risky and change status if inventory is not available for risky items
390 
 
391 
    Parameters:
392 
     - itemId
393 
    """
394 
    pass
395 
 
396 
  def changeItemRiskyFlag(self, itemId, risky):
397 
    """
398 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
399 
 
400 
    Parameters:
401 
     - itemId
402 
     - risky
403 
    """
404 
    pass
405 
 
406 
  def getItemsByRiskyFlag(self, ):
407 
    """
408 
    Returns list of items marked as risky.
409 
    """
410 
    pass
411 
 
412 
  def getItemsForMasterSheet(self, category, brand):
413 
    """
414 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
415 
 
416 
    Parameters:
417 
     - category
418 
     - brand
419 
    """
420 
    pass
421 
 
422 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
423 
    """
424 
    Returns list of catalog ids of items with same similarity index as of the given itemId
425 
 
426 
    Parameters:
427 
     - beginIndex
428 
     - totalItems
429 
     - itemId
430 
    """
431 
    pass
432 
 
433 
  def addProductNotification(self, itemId, email):
434 
    """
435 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
436 
 
437 
    Parameters:
438 
     - itemId
439 
     - email
440 
    """
441 
    pass
442 
 
443 
  def sendProductNotifications(self, ):
444 
    """
445 
    Send the product notifications to the users for items which has stock.
446 
    """
447 
    pass
448 
 
449 
  def getAllBrandsByCategory(self, categoryId):
450 
    """
451 
    Returns list of brand names for a given category Id
452 
 
453 
    Parameters:
454 
     - categoryId
455 
    """
456 
    pass
457 
 
458 
  def getAllBrands(self, ):
459 
    """
460 
    Returns list of brand names
461 
    """
462 
    pass
463 
 
464 
  def getAllSources(self, ):
465 
    """
466 
    Return list of all sources
467 
    """
468 
    pass
469 
 
470 
  def getItemPricingBySource(self, itemId, sourceId):
471 
    """
472 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
473 
 
474 
    Parameters:
475 
     - itemId
476 
     - sourceId
477 
    """
478 
    pass
479 
 
480 
  def addSourceItemPricing(self, sourceItemPricing):
481 
    """
482 
    Adds prices to be displayed corresponding to the item if user comes from a source.
483 
    If item is not found or source is not found, it will throw exception.
484 
 
485 
    Parameters:
486 
     - sourceItemPricing
487 
    """
488 
    pass
489 
 
490 
  def getAllSourcePricing(self, itemId):
491 
    """
492 
    Returns the list of source pricing information of an item.
493 
    Raises an exception if item not found corresponding to itemId
494 
 
495 
    Parameters:
496 
     - itemId
497 
    """
498 
    pass
499 
 
500 
  def getItemForSource(self, item_id, sourceId):
501 
    """
502 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
503 
 
504 
    Parameters:
505 
     - item_id
506 
     - sourceId
507 
    """
508 
    pass
509 
 
510 
  def searchItemsInRange(self, searchTerms, offset, limit):
511 
    """
512 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
513 
 
514 
    Parameters:
515 
     - searchTerms
516 
     - offset
517 
     - limit
518 
    """
519 
    pass
520 
 
521 
  def getSearchResultCount(self, searchTerms):
522 
    """
523 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
524 
 
525 
    Parameters:
526 
     - searchTerms
527 
    """
528 
    pass
529 
 
530 
  def getProductNotifications(self, startDateTime):
531 
    """
532 
    Returns a list of product notifications added after a supplied datetime
533 
 
534 
    Parameters:
535 
     - startDateTime
536 
    """
537 
    pass
538 
 
539 
  def getProductNotificationRequestCount(self, startDateTime):
540 
    """
541 
    Returns a list of count of requests for product notification against each item
542 
 
543 
    Parameters:
544 
     - startDateTime
545 
    """
546 
    pass
547 
 
548 
  def addAuthorizationLog(self, itemId, username, reason):
549 
    """
550 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
551 
 
552 
    Parameters:
553 
     - itemId
554 
     - username
555 
     - reason
556 
    """
557 
    pass
558 
 
559 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
560 
    """
561 
    Parameters:
562 
     - catalog_item_id
563 
     - voucherType
564 
     - voucherAmount
565 
    """
566 
    pass
567 
 
568 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
569 
    """
570 
    Parameters:
571 
     - catalog_item_id
572 
     - voucherType
573 
    """
574 
    pass
575 
 
576 
  def getVoucherAmount(self, itemId, voucherType):
577 
    """
578 
    Parameters:
579 
     - itemId
580 
     - voucherType
581 
    """
582 
    pass
583 
 
584 
  def getAllItemVouchers(self, itemId):
585 
    """
586 
    Parameters:
587 
     - itemId
588 
    """
589 
    pass
590 
 
591 
  def isValidCatalogItemId(self, catalog_item_id):
592 
    """
593 
    Parameters:
594 
     - catalog_item_id
595 
    """
596 
    pass
597 
 
7330 amit.gupta 598 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 599 
    """
600 
    Parameters:
601 
     - itemId
7330 amit.gupta 602 
     - stateId
6039 amit.gupta 603 
     - price
604 
    """
605 
    pass
5944 mandeep.dh 606 
 
6039 amit.gupta 607 
  def getVatAmountForItem(self, itemId, price):
608 
    """
609 
    Parameters:
610 
     - itemId
611 
     - price
612 
    """
613 
    pass
614 
 
6531 vikram.rag 615 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
616 
    """
617 
    Parameters:
618 
     - offset
619 
     - limit
620 
    """
621 
    pass
6039 amit.gupta 622 
 
6821 amar.kumar 623 
  def getAllAliveItems(self, ):
624 
    pass
625 
 
6921 anupam.sin 626 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 627 
    """
628 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 629 
 
6805 anupam.sin 630 
    Parameters:
631 
     - itemId
6921 anupam.sin 632 
     - price
6805 anupam.sin 633 
     - insurerId
634 
     - quantity
635 
    """
636 
    pass
637 
 
638 
  def getInsurer(self, insurerId):
639 
    """
640 
    Parameters:
641 
     - insurerId
642 
    """
643 
    pass
644 
 
6838 vikram.rag 645 
  def getAllInsurers(self, ):
646 
    pass
6805 anupam.sin 647 
 
6962 rajveer 648 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
649 
    """
650 
    Parameters:
651 
     - insurerId
652 
     - amount
653 
    """
654 
    pass
6838 vikram.rag 655 
 
7190 amar.kumar 656 
  def getFreebieForItem(self, itemId):
657 
    """
658 
    Parameters:
659 
     - itemId
660 
    """
661 
    pass
6962 rajveer 662 
 
7190 amar.kumar 663 
  def addOrUpdateFreebieForItem(self, freebieItem):
664 
    """
665 
    Parameters:
666 
     - freebieItem
667 
    """
668 
    pass
669 
 
7272 amit.gupta 670 
  def addOrUpdateBrandInfo(self, brandInfo):
671 
    """
672 
    Parameters:
673 
     - brandInfo
674 
    """
675 
    pass
676 
 
677 
  def getBrandInfo(self, ):
678 
    pass
679 
 
7256 rajveer 680 
  def getStorePricing(self, itemId):
681 
    """
682 
    Parameters:
683 
     - itemId
684 
    """
685 
    pass
7190 amar.kumar 686 
 
7306 rajveer 687 
  def getStorePricings(self, itemIds):
688 
    """
689 
    Parameters:
690 
     - itemIds
691 
    """
692 
    pass
693 
 
7265 rajveer 694 
  def updateStorePricing(self, sp):
695 
    """
696 
    Parameters:
697 
     - sp
698 
    """
699 
    pass
7256 rajveer 700 
 
7281 kshitij.so 701 
  def getAllAmazonListedItems(self, ):
702 
    pass
7265 rajveer 703 
 
7281 kshitij.so 704 
  def getAmazonItemDetails(self, itemId):
705 
    """
706 
    Parameters:
707 
     - itemId
708 
    """
709 
    pass
710 
 
711 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
712 
    """
713 
    Parameters:
714 
     - itemId
715 
     - fbaPrice
716 
     - sellingPrice
717 
     - isFba
718 
     - isNonFba
719 
     - isInventoryOverride
720 
    """
721 
    pass
722 
 
723 
  def addAmazonItem(self, amazonlisted):
724 
    """
725 
    Parameters:
726 
     - amazonlisted
727 
    """
728 
    pass
729 
 
7291 vikram.rag 730 
  def getAsinItems(self, ):
731 
    pass
7281 kshitij.so 732 
 
7291 vikram.rag 733 
  def getAllFbaListedItems(self, ):
734 
    pass
735 
 
736 
  def getAllNonFbaListedItems(self, ):
737 
    pass
738 
 
739 
 
5944 mandeep.dh 740 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
741 
  def __init__(self, iprot, oprot=None):
742 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
743 
 
744 
  def addItem(self, item):
745 
    """
746 
    Availability and inventory attributes
747 
 
748 
    Parameters:
749 
     - item
750 
    """
751 
    self.send_addItem(item)
752 
    return self.recv_addItem()
753 
 
754 
  def send_addItem(self, item):
755 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
756 
    args = addItem_args()
757 
    args.item = item
758 
    args.write(self._oprot)
759 
    self._oprot.writeMessageEnd()
760 
    self._oprot.trans.flush()
761 
 
762 
  def recv_addItem(self, ):
763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
764 
    if mtype == TMessageType.EXCEPTION:
765 
      x = TApplicationException()
766 
      x.read(self._iprot)
767 
      self._iprot.readMessageEnd()
768 
      raise x
769 
    result = addItem_result()
770 
    result.read(self._iprot)
771 
    self._iprot.readMessageEnd()
772 
    if result.success is not None:
773 
      return result.success
774 
    if result.cex is not None:
775 
      raise result.cex
776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
777 
 
778 
  def updateItem(self, item):
779 
    """
780 
    Parameters:
781 
     - item
782 
    """
783 
    self.send_updateItem(item)
784 
    return self.recv_updateItem()
785 
 
786 
  def send_updateItem(self, item):
787 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
788 
    args = updateItem_args()
789 
    args.item = item
790 
    args.write(self._oprot)
791 
    self._oprot.writeMessageEnd()
792 
    self._oprot.trans.flush()
793 
 
794 
  def recv_updateItem(self, ):
795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
796 
    if mtype == TMessageType.EXCEPTION:
797 
      x = TApplicationException()
798 
      x.read(self._iprot)
799 
      self._iprot.readMessageEnd()
800 
      raise x
801 
    result = updateItem_result()
802 
    result.read(self._iprot)
803 
    self._iprot.readMessageEnd()
804 
    if result.success is not None:
805 
      return result.success
806 
    if result.cex is not None:
807 
      raise result.cex
808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
809 
 
810 
  def isActive(self, itemId):
811 
    """
812 
    Checks if the item given to the corresponding itemId is active. If it's active,
813 
    whether it's risky and if it's risky, its inventory position.
814 
 
815 
    Parameters:
816 
     - itemId
817 
    """
818 
    self.send_isActive(itemId)
819 
    return self.recv_isActive()
820 
 
821 
  def send_isActive(self, itemId):
822 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
823 
    args = isActive_args()
824 
    args.itemId = itemId
825 
    args.write(self._oprot)
826 
    self._oprot.writeMessageEnd()
827 
    self._oprot.trans.flush()
828 
 
829 
  def recv_isActive(self, ):
830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
831 
    if mtype == TMessageType.EXCEPTION:
832 
      x = TApplicationException()
833 
      x.read(self._iprot)
834 
      self._iprot.readMessageEnd()
835 
      raise x
836 
    result = isActive_result()
837 
    result.read(self._iprot)
838 
    self._iprot.readMessageEnd()
839 
    if result.success is not None:
840 
      return result.success
841 
    if result.isex is not None:
842 
      raise result.isex
843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
844 
 
845 
  def getItemStatusDescription(self, itemId):
846 
    """
847 
    Parameters:
848 
     - itemId
849 
    """
850 
    self.send_getItemStatusDescription(itemId)
851 
    return self.recv_getItemStatusDescription()
852 
 
853 
  def send_getItemStatusDescription(self, itemId):
854 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
855 
    args = getItemStatusDescription_args()
856 
    args.itemId = itemId
857 
    args.write(self._oprot)
858 
    self._oprot.writeMessageEnd()
859 
    self._oprot.trans.flush()
860 
 
861 
  def recv_getItemStatusDescription(self, ):
862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
863 
    if mtype == TMessageType.EXCEPTION:
864 
      x = TApplicationException()
865 
      x.read(self._iprot)
866 
      self._iprot.readMessageEnd()
867 
      raise x
868 
    result = getItemStatusDescription_result()
869 
    result.read(self._iprot)
870 
    self._iprot.readMessageEnd()
871 
    if result.success is not None:
872 
      return result.success
873 
    if result.isex is not None:
874 
      raise result.isex
875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
876 
 
877 
  def startItemOn(self, item_id, timestamp):
878 
    """
879 
    Parameters:
880 
     - item_id
881 
     - timestamp
882 
    """
883 
    self.send_startItemOn(item_id, timestamp)
884 
    self.recv_startItemOn()
885 
 
886 
  def send_startItemOn(self, item_id, timestamp):
887 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
888 
    args = startItemOn_args()
889 
    args.item_id = item_id
890 
    args.timestamp = timestamp
891 
    args.write(self._oprot)
892 
    self._oprot.writeMessageEnd()
893 
    self._oprot.trans.flush()
894 
 
895 
  def recv_startItemOn(self, ):
896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
897 
    if mtype == TMessageType.EXCEPTION:
898 
      x = TApplicationException()
899 
      x.read(self._iprot)
900 
      self._iprot.readMessageEnd()
901 
      raise x
902 
    result = startItemOn_result()
903 
    result.read(self._iprot)
904 
    self._iprot.readMessageEnd()
905 
    if result.cex is not None:
906 
      raise result.cex
907 
    return
908 
 
909 
  def retireItemOn(self, item_id, timestamp):
910 
    """
911 
    Parameters:
912 
     - item_id
913 
     - timestamp
914 
    """
915 
    self.send_retireItemOn(item_id, timestamp)
916 
    self.recv_retireItemOn()
917 
 
918 
  def send_retireItemOn(self, item_id, timestamp):
919 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
920 
    args = retireItemOn_args()
921 
    args.item_id = item_id
922 
    args.timestamp = timestamp
923 
    args.write(self._oprot)
924 
    self._oprot.writeMessageEnd()
925 
    self._oprot.trans.flush()
926 
 
927 
  def recv_retireItemOn(self, ):
928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
929 
    if mtype == TMessageType.EXCEPTION:
930 
      x = TApplicationException()
931 
      x.read(self._iprot)
932 
      self._iprot.readMessageEnd()
933 
      raise x
934 
    result = retireItemOn_result()
935 
    result.read(self._iprot)
936 
    self._iprot.readMessageEnd()
937 
    if result.cex is not None:
938 
      raise result.cex
939 
    return
940 
 
941 
  def changeItemStatus(self, item_id, timestamp, newstatus):
942 
    """
943 
    Parameters:
944 
     - item_id
945 
     - timestamp
946 
     - newstatus
947 
    """
948 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
949 
    self.recv_changeItemStatus()
950 
 
951 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
952 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
953 
    args = changeItemStatus_args()
954 
    args.item_id = item_id
955 
    args.timestamp = timestamp
956 
    args.newstatus = newstatus
957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_changeItemStatus(self, ):
962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
963 
    if mtype == TMessageType.EXCEPTION:
964 
      x = TApplicationException()
965 
      x.read(self._iprot)
966 
      self._iprot.readMessageEnd()
967 
      raise x
968 
    result = changeItemStatus_result()
969 
    result.read(self._iprot)
970 
    self._iprot.readMessageEnd()
971 
    if result.cex is not None:
972 
      raise result.cex
973 
    return
974 
 
975 
  def getItem(self, item_id):
976 
    """
977 
    Parameters:
978 
     - item_id
979 
    """
980 
    self.send_getItem(item_id)
981 
    return self.recv_getItem()
982 
 
983 
  def send_getItem(self, item_id):
984 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
985 
    args = getItem_args()
986 
    args.item_id = item_id
987 
    args.write(self._oprot)
988 
    self._oprot.writeMessageEnd()
989 
    self._oprot.trans.flush()
990 
 
991 
  def recv_getItem(self, ):
992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
993 
    if mtype == TMessageType.EXCEPTION:
994 
      x = TApplicationException()
995 
      x.read(self._iprot)
996 
      self._iprot.readMessageEnd()
997 
      raise x
998 
    result = getItem_result()
999 
    result.read(self._iprot)
1000 
    self._iprot.readMessageEnd()
1001 
    if result.success is not None:
1002 
      return result.success
1003 
    if result.cex is not None:
1004 
      raise result.cex
1005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1006 
 
1007 
  def getItemsByCatalogId(self, catalog_item_id):
1008 
    """
1009 
    Parameters:
1010 
     - catalog_item_id
1011 
    """
1012 
    self.send_getItemsByCatalogId(catalog_item_id)
1013 
    return self.recv_getItemsByCatalogId()
1014 
 
1015 
  def send_getItemsByCatalogId(self, catalog_item_id):
1016 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1017 
    args = getItemsByCatalogId_args()
1018 
    args.catalog_item_id = catalog_item_id
1019 
    args.write(self._oprot)
1020 
    self._oprot.writeMessageEnd()
1021 
    self._oprot.trans.flush()
1022 
 
1023 
  def recv_getItemsByCatalogId(self, ):
1024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1025 
    if mtype == TMessageType.EXCEPTION:
1026 
      x = TApplicationException()
1027 
      x.read(self._iprot)
1028 
      self._iprot.readMessageEnd()
1029 
      raise x
1030 
    result = getItemsByCatalogId_result()
1031 
    result.read(self._iprot)
1032 
    self._iprot.readMessageEnd()
1033 
    if result.success is not None:
1034 
      return result.success
1035 
    if result.cex is not None:
1036 
      raise result.cex
1037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1038 
 
1039 
  def getValidItemsByCatalogId(self, catalog_item_id):
1040 
    """
1041 
    Parameters:
1042 
     - catalog_item_id
1043 
    """
1044 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1045 
    return self.recv_getValidItemsByCatalogId()
1046 
 
1047 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1048 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1049 
    args = getValidItemsByCatalogId_args()
1050 
    args.catalog_item_id = catalog_item_id
1051 
    args.write(self._oprot)
1052 
    self._oprot.writeMessageEnd()
1053 
    self._oprot.trans.flush()
1054 
 
1055 
  def recv_getValidItemsByCatalogId(self, ):
1056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1057 
    if mtype == TMessageType.EXCEPTION:
1058 
      x = TApplicationException()
1059 
      x.read(self._iprot)
1060 
      self._iprot.readMessageEnd()
1061 
      raise x
1062 
    result = getValidItemsByCatalogId_result()
1063 
    result.read(self._iprot)
1064 
    self._iprot.readMessageEnd()
1065 
    if result.success is not None:
1066 
      return result.success
1067 
    if result.cex is not None:
1068 
      raise result.cex
1069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1070 
 
1071 
  def getAllItems(self, isActive):
1072 
    """
1073 
    Parameters:
1074 
     - isActive
1075 
    """
1076 
    self.send_getAllItems(isActive)
1077 
    return self.recv_getAllItems()
1078 
 
1079 
  def send_getAllItems(self, isActive):
1080 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1081 
    args = getAllItems_args()
1082 
    args.isActive = isActive
1083 
    args.write(self._oprot)
1084 
    self._oprot.writeMessageEnd()
1085 
    self._oprot.trans.flush()
1086 
 
1087 
  def recv_getAllItems(self, ):
1088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1089 
    if mtype == TMessageType.EXCEPTION:
1090 
      x = TApplicationException()
1091 
      x.read(self._iprot)
1092 
      self._iprot.readMessageEnd()
1093 
      raise x
1094 
    result = getAllItems_result()
1095 
    result.read(self._iprot)
1096 
    self._iprot.readMessageEnd()
1097 
    if result.success is not None:
1098 
      return result.success
1099 
    if result.cex is not None:
1100 
      raise result.cex
1101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1102 
 
1103 
  def getAllItemsByStatus(self, itemStatus):
1104 
    """
1105 
    Parameters:
1106 
     - itemStatus
1107 
    """
1108 
    self.send_getAllItemsByStatus(itemStatus)
1109 
    return self.recv_getAllItemsByStatus()
1110 
 
1111 
  def send_getAllItemsByStatus(self, itemStatus):
1112 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1113 
    args = getAllItemsByStatus_args()
1114 
    args.itemStatus = itemStatus
1115 
    args.write(self._oprot)
1116 
    self._oprot.writeMessageEnd()
1117 
    self._oprot.trans.flush()
1118 
 
1119 
  def recv_getAllItemsByStatus(self, ):
1120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1121 
    if mtype == TMessageType.EXCEPTION:
1122 
      x = TApplicationException()
1123 
      x.read(self._iprot)
1124 
      self._iprot.readMessageEnd()
1125 
      raise x
1126 
    result = getAllItemsByStatus_result()
1127 
    result.read(self._iprot)
1128 
    self._iprot.readMessageEnd()
1129 
    if result.success is not None:
1130 
      return result.success
1131 
    if result.cex is not None:
1132 
      raise result.cex
1133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1134 
 
1135 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1136 
    """
1137 
    Parameters:
1138 
     - entityId
1139 
     - category
1140 
     - brand
1141 
     - modelName
1142 
     - modelNumber
1143 
    """
1144 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1145 
    return self.recv_markItemAsContentComplete()
1146 
 
1147 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1148 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1149 
    args = markItemAsContentComplete_args()
1150 
    args.entityId = entityId
1151 
    args.category = category
1152 
    args.brand = brand
1153 
    args.modelName = modelName
1154 
    args.modelNumber = modelNumber
1155 
    args.write(self._oprot)
1156 
    self._oprot.writeMessageEnd()
1157 
    self._oprot.trans.flush()
1158 
 
1159 
  def recv_markItemAsContentComplete(self, ):
1160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1161 
    if mtype == TMessageType.EXCEPTION:
1162 
      x = TApplicationException()
1163 
      x.read(self._iprot)
1164 
      self._iprot.readMessageEnd()
1165 
      raise x
1166 
    result = markItemAsContentComplete_result()
1167 
    result.read(self._iprot)
1168 
    self._iprot.readMessageEnd()
1169 
    if result.success is not None:
1170 
      return result.success
1171 
    if result.cex is not None:
1172 
      raise result.cex
1173 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1174 
 
1175 
  def getAllItemsInRange(self, offset, limit):
1176 
    """
1177 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1178 
 
1179 
    Parameters:
1180 
     - offset
1181 
     - limit
1182 
    """
1183 
    self.send_getAllItemsInRange(offset, limit)
1184 
    return self.recv_getAllItemsInRange()
1185 
 
1186 
  def send_getAllItemsInRange(self, offset, limit):
1187 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1188 
    args = getAllItemsInRange_args()
1189 
    args.offset = offset
1190 
    args.limit = limit
1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_getAllItemsInRange(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = getAllItemsInRange_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
1205 
    if result.success is not None:
1206 
      return result.success
1207 
    if result.cex is not None:
1208 
      raise result.cex
1209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1210 
 
1211 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1212 
    """
1213 
    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.
1214 
 
1215 
    Parameters:
1216 
     - itemStatus
1217 
     - offset
1218 
     - limit
1219 
    """
1220 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1221 
    return self.recv_getAllItemsByStatusInRange()
1222 
 
1223 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1224 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1225 
    args = getAllItemsByStatusInRange_args()
1226 
    args.itemStatus = itemStatus
1227 
    args.offset = offset
1228 
    args.limit = limit
1229 
    args.write(self._oprot)
1230 
    self._oprot.writeMessageEnd()
1231 
    self._oprot.trans.flush()
1232 
 
1233 
  def recv_getAllItemsByStatusInRange(self, ):
1234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1235 
    if mtype == TMessageType.EXCEPTION:
1236 
      x = TApplicationException()
1237 
      x.read(self._iprot)
1238 
      self._iprot.readMessageEnd()
1239 
      raise x
1240 
    result = getAllItemsByStatusInRange_result()
1241 
    result.read(self._iprot)
1242 
    self._iprot.readMessageEnd()
1243 
    if result.success is not None:
1244 
      return result.success
1245 
    if result.cex is not None:
1246 
      raise result.cex
1247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1248 
 
1249 
  def getItemCountByStatus(self, useStatus, itemStatus):
1250 
    """
1251 
    Gets a count of all items by status
1252 
 
1253 
    Parameters:
1254 
     - useStatus
1255 
     - itemStatus
1256 
    """
1257 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1258 
    return self.recv_getItemCountByStatus()
1259 
 
1260 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1261 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1262 
    args = getItemCountByStatus_args()
1263 
    args.useStatus = useStatus
1264 
    args.itemStatus = itemStatus
1265 
    args.write(self._oprot)
1266 
    self._oprot.writeMessageEnd()
1267 
    self._oprot.trans.flush()
1268 
 
1269 
  def recv_getItemCountByStatus(self, ):
1270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1271 
    if mtype == TMessageType.EXCEPTION:
1272 
      x = TApplicationException()
1273 
      x.read(self._iprot)
1274 
      self._iprot.readMessageEnd()
1275 
      raise x
1276 
    result = getItemCountByStatus_result()
1277 
    result.read(self._iprot)
1278 
    self._iprot.readMessageEnd()
1279 
    if result.success is not None:
1280 
      return result.success
1281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1282 
 
1283 
  def getBestSellers(self, ):
1284 
    self.send_getBestSellers()
1285 
    return self.recv_getBestSellers()
1286 
 
1287 
  def send_getBestSellers(self, ):
1288 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1289 
    args = getBestSellers_args()
1290 
    args.write(self._oprot)
1291 
    self._oprot.writeMessageEnd()
1292 
    self._oprot.trans.flush()
1293 
 
1294 
  def recv_getBestSellers(self, ):
1295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1296 
    if mtype == TMessageType.EXCEPTION:
1297 
      x = TApplicationException()
1298 
      x.read(self._iprot)
1299 
      self._iprot.readMessageEnd()
1300 
      raise x
1301 
    result = getBestSellers_result()
1302 
    result.read(self._iprot)
1303 
    self._iprot.readMessageEnd()
1304 
    if result.success is not None:
1305 
      return result.success
1306 
    if result.isex is not None:
1307 
      raise result.isex
1308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1309 
 
1310 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1311 
    """
1312 
    Parameters:
1313 
     - beginIndex
1314 
     - totalItems
1315 
     - brand
1316 
     - category
1317 
    """
1318 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1319 
    return self.recv_getBestSellersCatalogIds()
1320 
 
1321 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1322 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1323 
    args = getBestSellersCatalogIds_args()
1324 
    args.beginIndex = beginIndex
1325 
    args.totalItems = totalItems
1326 
    args.brand = brand
1327 
    args.category = category
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getBestSellersCatalogIds(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getBestSellersCatalogIds_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
1342 
    if result.success is not None:
1343 
      return result.success
1344 
    if result.cex is not None:
1345 
      raise result.cex
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1347 
 
1348 
  def getBestSellersCount(self, ):
1349 
    self.send_getBestSellersCount()
1350 
    return self.recv_getBestSellersCount()
1351 
 
1352 
  def send_getBestSellersCount(self, ):
1353 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1354 
    args = getBestSellersCount_args()
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_getBestSellersCount(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = getBestSellersCount_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
1369 
    if result.success is not None:
1370 
      return result.success
1371 
    if result.cex is not None:
1372 
      raise result.cex
1373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1374 
 
1375 
  def getBestDeals(self, ):
1376 
    self.send_getBestDeals()
1377 
    return self.recv_getBestDeals()
1378 
 
1379 
  def send_getBestDeals(self, ):
1380 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1381 
    args = getBestDeals_args()
1382 
    args.write(self._oprot)
1383 
    self._oprot.writeMessageEnd()
1384 
    self._oprot.trans.flush()
1385 
 
1386 
  def recv_getBestDeals(self, ):
1387 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1388 
    if mtype == TMessageType.EXCEPTION:
1389 
      x = TApplicationException()
1390 
      x.read(self._iprot)
1391 
      self._iprot.readMessageEnd()
1392 
      raise x
1393 
    result = getBestDeals_result()
1394 
    result.read(self._iprot)
1395 
    self._iprot.readMessageEnd()
1396 
    if result.success is not None:
1397 
      return result.success
1398 
    if result.isex is not None:
1399 
      raise result.isex
1400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1401 
 
1402 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1403 
    """
1404 
    Parameters:
1405 
     - beginIndex
1406 
     - totalItems
1407 
     - brand
1408 
     - category
1409 
    """
1410 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1411 
    return self.recv_getBestDealsCatalogIds()
1412 
 
1413 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1414 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1415 
    args = getBestDealsCatalogIds_args()
1416 
    args.beginIndex = beginIndex
1417 
    args.totalItems = totalItems
1418 
    args.brand = brand
1419 
    args.category = category
1420 
    args.write(self._oprot)
1421 
    self._oprot.writeMessageEnd()
1422 
    self._oprot.trans.flush()
1423 
 
1424 
  def recv_getBestDealsCatalogIds(self, ):
1425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1426 
    if mtype == TMessageType.EXCEPTION:
1427 
      x = TApplicationException()
1428 
      x.read(self._iprot)
1429 
      self._iprot.readMessageEnd()
1430 
      raise x
1431 
    result = getBestDealsCatalogIds_result()
1432 
    result.read(self._iprot)
1433 
    self._iprot.readMessageEnd()
1434 
    if result.success is not None:
1435 
      return result.success
1436 
    if result.cex is not None:
1437 
      raise result.cex
1438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1439 
 
1440 
  def getBestDealsCount(self, ):
1441 
    self.send_getBestDealsCount()
1442 
    return self.recv_getBestDealsCount()
1443 
 
1444 
  def send_getBestDealsCount(self, ):
1445 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1446 
    args = getBestDealsCount_args()
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_getBestDealsCount(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = getBestDealsCount_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
1461 
    if result.success is not None:
1462 
      return result.success
1463 
    if result.cex is not None:
1464 
      raise result.cex
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1466 
 
1467 
  def getComingSoon(self, ):
1468 
    self.send_getComingSoon()
1469 
    return self.recv_getComingSoon()
1470 
 
1471 
  def send_getComingSoon(self, ):
1472 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1473 
    args = getComingSoon_args()
1474 
    args.write(self._oprot)
1475 
    self._oprot.writeMessageEnd()
1476 
    self._oprot.trans.flush()
1477 
 
1478 
  def recv_getComingSoon(self, ):
1479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1480 
    if mtype == TMessageType.EXCEPTION:
1481 
      x = TApplicationException()
1482 
      x.read(self._iprot)
1483 
      self._iprot.readMessageEnd()
1484 
      raise x
1485 
    result = getComingSoon_result()
1486 
    result.read(self._iprot)
1487 
    self._iprot.readMessageEnd()
1488 
    if result.success is not None:
1489 
      return result.success
1490 
    if result.isex is not None:
1491 
      raise result.isex
1492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1493 
 
1494 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1495 
    """
1496 
    Parameters:
1497 
     - beginIndex
1498 
     - totalItems
1499 
     - brand
1500 
     - category
1501 
    """
1502 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1503 
    return self.recv_getComingSoonCatalogIds()
1504 
 
1505 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1506 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1507 
    args = getComingSoonCatalogIds_args()
1508 
    args.beginIndex = beginIndex
1509 
    args.totalItems = totalItems
1510 
    args.brand = brand
1511 
    args.category = category
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getComingSoonCatalogIds(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getComingSoonCatalogIds_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
1526 
    if result.success is not None:
1527 
      return result.success
1528 
    if result.cex is not None:
1529 
      raise result.cex
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1531 
 
1532 
  def getComingSoonCount(self, ):
1533 
    self.send_getComingSoonCount()
1534 
    return self.recv_getComingSoonCount()
1535 
 
1536 
  def send_getComingSoonCount(self, ):
1537 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1538 
    args = getComingSoonCount_args()
1539 
    args.write(self._oprot)
1540 
    self._oprot.writeMessageEnd()
1541 
    self._oprot.trans.flush()
1542 
 
1543 
  def recv_getComingSoonCount(self, ):
1544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1545 
    if mtype == TMessageType.EXCEPTION:
1546 
      x = TApplicationException()
1547 
      x.read(self._iprot)
1548 
      self._iprot.readMessageEnd()
1549 
      raise x
1550 
    result = getComingSoonCount_result()
1551 
    result.read(self._iprot)
1552 
    self._iprot.readMessageEnd()
1553 
    if result.success is not None:
1554 
      return result.success
1555 
    if result.cex is not None:
1556 
      raise result.cex
1557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1558 
 
1559 
  def getLatestArrivals(self, ):
1560 
    """
1561 
    Returns a list of items sorted in the descending order by start date.
1562 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1563 
    """
1564 
    self.send_getLatestArrivals()
1565 
    return self.recv_getLatestArrivals()
1566 
 
1567 
  def send_getLatestArrivals(self, ):
1568 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1569 
    args = getLatestArrivals_args()
1570 
    args.write(self._oprot)
1571 
    self._oprot.writeMessageEnd()
1572 
    self._oprot.trans.flush()
1573 
 
1574 
  def recv_getLatestArrivals(self, ):
1575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1576 
    if mtype == TMessageType.EXCEPTION:
1577 
      x = TApplicationException()
1578 
      x.read(self._iprot)
1579 
      self._iprot.readMessageEnd()
1580 
      raise x
1581 
    result = getLatestArrivals_result()
1582 
    result.read(self._iprot)
1583 
    self._iprot.readMessageEnd()
1584 
    if result.success is not None:
1585 
      return result.success
1586 
    if result.isex is not None:
1587 
      raise result.isex
1588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1589 
 
1590 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1591 
    """
1592 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1593 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1594 
 
1595 
    Parameters:
1596 
     - beginIndex
1597 
     - totalItems
1598 
     - brand
1599 
     - categories
1600 
    """
1601 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1602 
    return self.recv_getLatestArrivalsCatalogIds()
1603 
 
1604 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1605 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1606 
    args = getLatestArrivalsCatalogIds_args()
1607 
    args.beginIndex = beginIndex
1608 
    args.totalItems = totalItems
1609 
    args.brand = brand
1610 
    args.categories = categories
1611 
    args.write(self._oprot)
1612 
    self._oprot.writeMessageEnd()
1613 
    self._oprot.trans.flush()
1614 
 
1615 
  def recv_getLatestArrivalsCatalogIds(self, ):
1616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1617 
    if mtype == TMessageType.EXCEPTION:
1618 
      x = TApplicationException()
1619 
      x.read(self._iprot)
1620 
      self._iprot.readMessageEnd()
1621 
      raise x
1622 
    result = getLatestArrivalsCatalogIds_result()
1623 
    result.read(self._iprot)
1624 
    self._iprot.readMessageEnd()
1625 
    if result.success is not None:
1626 
      return result.success
1627 
    if result.cex is not None:
1628 
      raise result.cex
1629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1630 
 
1631 
  def getLatestArrivalsCount(self, ):
1632 
    """
1633 
    Get the total number of latest arrivals we are willing to show.
1634 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1635 
    """
1636 
    self.send_getLatestArrivalsCount()
1637 
    return self.recv_getLatestArrivalsCount()
1638 
 
1639 
  def send_getLatestArrivalsCount(self, ):
1640 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1641 
    args = getLatestArrivalsCount_args()
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getLatestArrivalsCount(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getLatestArrivalsCount_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
1656 
    if result.success is not None:
1657 
      return result.success
1658 
    if result.cex is not None:
1659 
      raise result.cex
1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1661 
 
1662 
  def generateNewEntityID(self, ):
1663 
    self.send_generateNewEntityID()
1664 
    return self.recv_generateNewEntityID()
1665 
 
1666 
  def send_generateNewEntityID(self, ):
1667 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1668 
    args = generateNewEntityID_args()
1669 
    args.write(self._oprot)
1670 
    self._oprot.writeMessageEnd()
1671 
    self._oprot.trans.flush()
1672 
 
1673 
  def recv_generateNewEntityID(self, ):
1674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1675 
    if mtype == TMessageType.EXCEPTION:
1676 
      x = TApplicationException()
1677 
      x.read(self._iprot)
1678 
      self._iprot.readMessageEnd()
1679 
      raise x
1680 
    result = generateNewEntityID_result()
1681 
    result.read(self._iprot)
1682 
    self._iprot.readMessageEnd()
1683 
    if result.success is not None:
1684 
      return result.success
1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1686 
 
1687 
  def addCategory(self, category):
1688 
    """
1689 
    All category related functions
1690 
 
1691 
    Parameters:
1692 
     - category
1693 
    """
1694 
    self.send_addCategory(category)
1695 
    return self.recv_addCategory()
1696 
 
1697 
  def send_addCategory(self, category):
1698 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1699 
    args = addCategory_args()
1700 
    args.category = category
1701 
    args.write(self._oprot)
1702 
    self._oprot.writeMessageEnd()
1703 
    self._oprot.trans.flush()
1704 
 
1705 
  def recv_addCategory(self, ):
1706 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1707 
    if mtype == TMessageType.EXCEPTION:
1708 
      x = TApplicationException()
1709 
      x.read(self._iprot)
1710 
      self._iprot.readMessageEnd()
1711 
      raise x
1712 
    result = addCategory_result()
1713 
    result.read(self._iprot)
1714 
    self._iprot.readMessageEnd()
1715 
    if result.success is not None:
1716 
      return result.success
1717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1718 
 
1719 
  def getCategory(self, id):
1720 
    """
1721 
    Parameters:
1722 
     - id
1723 
    """
1724 
    self.send_getCategory(id)
1725 
    return self.recv_getCategory()
1726 
 
1727 
  def send_getCategory(self, id):
1728 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1729 
    args = getCategory_args()
1730 
    args.id = id
1731 
    args.write(self._oprot)
1732 
    self._oprot.writeMessageEnd()
1733 
    self._oprot.trans.flush()
1734 
 
1735 
  def recv_getCategory(self, ):
1736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1737 
    if mtype == TMessageType.EXCEPTION:
1738 
      x = TApplicationException()
1739 
      x.read(self._iprot)
1740 
      self._iprot.readMessageEnd()
1741 
      raise x
1742 
    result = getCategory_result()
1743 
    result.read(self._iprot)
1744 
    self._iprot.readMessageEnd()
1745 
    if result.success is not None:
1746 
      return result.success
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1748 
 
1749 
  def getAllCategories(self, ):
1750 
    self.send_getAllCategories()
1751 
    return self.recv_getAllCategories()
1752 
 
1753 
  def send_getAllCategories(self, ):
1754 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1755 
    args = getAllCategories_args()
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getAllCategories(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getAllCategories_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1773 
 
1774 
  def getAllSimilarItems(self, itemId):
1775 
    """
1776 
    Returns the list of similar items.
1777 
 
1778 
    Parameters:
1779 
     - itemId
1780 
    """
1781 
    self.send_getAllSimilarItems(itemId)
1782 
    return self.recv_getAllSimilarItems()
1783 
 
1784 
  def send_getAllSimilarItems(self, itemId):
1785 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1786 
    args = getAllSimilarItems_args()
1787 
    args.itemId = itemId
1788 
    args.write(self._oprot)
1789 
    self._oprot.writeMessageEnd()
1790 
    self._oprot.trans.flush()
1791 
 
1792 
  def recv_getAllSimilarItems(self, ):
1793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1794 
    if mtype == TMessageType.EXCEPTION:
1795 
      x = TApplicationException()
1796 
      x.read(self._iprot)
1797 
      self._iprot.readMessageEnd()
1798 
      raise x
1799 
    result = getAllSimilarItems_result()
1800 
    result.read(self._iprot)
1801 
    self._iprot.readMessageEnd()
1802 
    if result.success is not None:
1803 
      return result.success
1804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1805 
 
1806 
  def addSimilarItem(self, itemId, catalogItemId):
1807 
    """
1808 
    Adds similar item.
1809 
 
1810 
    Parameters:
1811 
     - itemId
1812 
     - catalogItemId
1813 
    """
1814 
    self.send_addSimilarItem(itemId, catalogItemId)
1815 
    return self.recv_addSimilarItem()
1816 
 
1817 
  def send_addSimilarItem(self, itemId, catalogItemId):
1818 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1819 
    args = addSimilarItem_args()
1820 
    args.itemId = itemId
1821 
    args.catalogItemId = catalogItemId
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_addSimilarItem(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = addSimilarItem_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.success is not None:
1837 
      return result.success
1838 
    if result.cex is not None:
1839 
      raise result.cex
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1841 
 
6512 kshitij.so 1842 
  def addTag(self, displayName, itemId):
1843 
    """
1844 
    Tag Related
1845 
 
1846 
    Parameters:
1847 
     - displayName
1848 
     - itemId
1849 
    """
1850 
    self.send_addTag(displayName, itemId)
1851 
    return self.recv_addTag()
1852 
 
1853 
  def send_addTag(self, displayName, itemId):
1854 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1855 
    args = addTag_args()
1856 
    args.displayName = displayName
1857 
    args.itemId = itemId
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_addTag(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = addTag_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    if result.success is not None:
1873 
      return result.success
1874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1875 
 
1876 
  def deleteEntityTag(self, displayName, itemId):
1877 
    """
1878 
    Parameters:
1879 
     - displayName
1880 
     - itemId
1881 
    """
1882 
    self.send_deleteEntityTag(displayName, itemId)
1883 
    return self.recv_deleteEntityTag()
1884 
 
1885 
  def send_deleteEntityTag(self, displayName, itemId):
1886 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1887 
    args = deleteEntityTag_args()
1888 
    args.displayName = displayName
1889 
    args.itemId = itemId
1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
1894 
  def recv_deleteEntityTag(self, ):
1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
1901 
    result = deleteEntityTag_result()
1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success is not None:
1905 
      return result.success
1906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1907 
 
1908 
  def deleteTag(self, displayName):
1909 
    """
1910 
    Parameters:
1911 
     - displayName
1912 
    """
1913 
    self.send_deleteTag(displayName)
1914 
    return self.recv_deleteTag()
1915 
 
1916 
  def send_deleteTag(self, displayName):
1917 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1918 
    args = deleteTag_args()
1919 
    args.displayName = displayName
1920 
    args.write(self._oprot)
1921 
    self._oprot.writeMessageEnd()
1922 
    self._oprot.trans.flush()
1923 
 
1924 
  def recv_deleteTag(self, ):
1925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1926 
    if mtype == TMessageType.EXCEPTION:
1927 
      x = TApplicationException()
1928 
      x.read(self._iprot)
1929 
      self._iprot.readMessageEnd()
1930 
      raise x
1931 
    result = deleteTag_result()
1932 
    result.read(self._iprot)
1933 
    self._iprot.readMessageEnd()
1934 
    if result.success is not None:
1935 
      return result.success
1936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1937 
 
1938 
  def getAllTags(self, ):
1939 
    self.send_getAllTags()
1940 
    return self.recv_getAllTags()
1941 
 
1942 
  def send_getAllTags(self, ):
1943 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1944 
    args = getAllTags_args()
1945 
    args.write(self._oprot)
1946 
    self._oprot.writeMessageEnd()
1947 
    self._oprot.trans.flush()
1948 
 
1949 
  def recv_getAllTags(self, ):
1950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1951 
    if mtype == TMessageType.EXCEPTION:
1952 
      x = TApplicationException()
1953 
      x.read(self._iprot)
1954 
      self._iprot.readMessageEnd()
1955 
      raise x
1956 
    result = getAllTags_result()
1957 
    result.read(self._iprot)
1958 
    self._iprot.readMessageEnd()
1959 
    if result.success is not None:
1960 
      return result.success
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
1962 
 
1963 
  def getAllEntitiesByTagName(self, displayName):
1964 
    """
1965 
    Parameters:
1966 
     - displayName
1967 
    """
1968 
    self.send_getAllEntitiesByTagName(displayName)
1969 
    return self.recv_getAllEntitiesByTagName()
1970 
 
1971 
  def send_getAllEntitiesByTagName(self, displayName):
1972 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
1973 
    args = getAllEntitiesByTagName_args()
1974 
    args.displayName = displayName
1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
1979 
  def recv_getAllEntitiesByTagName(self, ):
1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
1986 
    result = getAllEntitiesByTagName_result()
1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
1989 
    if result.success is not None:
1990 
      return result.success
1991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
1992 
 
6845 amit.gupta 1993 
  def getAllEntityTags(self, ):
1994 
    self.send_getAllEntityTags()
1995 
    return self.recv_getAllEntityTags()
1996 
 
1997 
  def send_getAllEntityTags(self, ):
1998 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
1999 
    args = getAllEntityTags_args()
2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getAllEntityTags(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getAllEntityTags_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
2014 
    if result.success is not None:
2015 
      return result.success
2016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2017 
 
6850 kshitij.so 2018 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2019 
    """
2020 
    Parameters:
2021 
     - bannerName
2022 
     - imageName
2023 
     - link
2024 
     - priority
2025 
     - isActive
2026 
     - hasMap
2027 
    """
2028 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2029 
    return self.recv_addBanner()
2030 
 
2031 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2032 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2033 
    args = addBanner_args()
2034 
    args.bannerName = bannerName
2035 
    args.imageName = imageName
2036 
    args.link = link
2037 
    args.priority = priority
2038 
    args.isActive = isActive
2039 
    args.hasMap = hasMap
2040 
    args.write(self._oprot)
2041 
    self._oprot.writeMessageEnd()
2042 
    self._oprot.trans.flush()
2043 
 
2044 
  def recv_addBanner(self, ):
2045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2046 
    if mtype == TMessageType.EXCEPTION:
2047 
      x = TApplicationException()
2048 
      x.read(self._iprot)
2049 
      self._iprot.readMessageEnd()
2050 
      raise x
2051 
    result = addBanner_result()
2052 
    result.read(self._iprot)
2053 
    self._iprot.readMessageEnd()
2054 
    if result.success is not None:
2055 
      return result.success
2056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2057 
 
2058 
  def getAllBanners(self, ):
2059 
    self.send_getAllBanners()
2060 
    return self.recv_getAllBanners()
2061 
 
2062 
  def send_getAllBanners(self, ):
2063 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2064 
    args = getAllBanners_args()
2065 
    args.write(self._oprot)
2066 
    self._oprot.writeMessageEnd()
2067 
    self._oprot.trans.flush()
2068 
 
2069 
  def recv_getAllBanners(self, ):
2070 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2071 
    if mtype == TMessageType.EXCEPTION:
2072 
      x = TApplicationException()
2073 
      x.read(self._iprot)
2074 
      self._iprot.readMessageEnd()
2075 
      raise x
2076 
    result = getAllBanners_result()
2077 
    result.read(self._iprot)
2078 
    self._iprot.readMessageEnd()
2079 
    if result.success is not None:
2080 
      return result.success
2081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2082 
 
2083 
  def deleteBanner(self, bannerName):
2084 
    """
2085 
    Parameters:
2086 
     - bannerName
2087 
    """
2088 
    self.send_deleteBanner(bannerName)
2089 
    return self.recv_deleteBanner()
2090 
 
2091 
  def send_deleteBanner(self, bannerName):
2092 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2093 
    args = deleteBanner_args()
2094 
    args.bannerName = bannerName
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_deleteBanner(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = deleteBanner_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success is not None:
2110 
      return result.success
2111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2112 
 
2113 
  def getBannerDetails(self, bannerName):
2114 
    """
2115 
    Parameters:
2116 
     - bannerName
2117 
    """
2118 
    self.send_getBannerDetails(bannerName)
2119 
    return self.recv_getBannerDetails()
2120 
 
2121 
  def send_getBannerDetails(self, bannerName):
2122 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2123 
    args = getBannerDetails_args()
2124 
    args.bannerName = bannerName
2125 
    args.write(self._oprot)
2126 
    self._oprot.writeMessageEnd()
2127 
    self._oprot.trans.flush()
2128 
 
2129 
  def recv_getBannerDetails(self, ):
2130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2131 
    if mtype == TMessageType.EXCEPTION:
2132 
      x = TApplicationException()
2133 
      x.read(self._iprot)
2134 
      self._iprot.readMessageEnd()
2135 
      raise x
2136 
    result = getBannerDetails_result()
2137 
    result.read(self._iprot)
2138 
    self._iprot.readMessageEnd()
2139 
    if result.success is not None:
2140 
      return result.success
2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2142 
 
2143 
  def getActiveBanners(self, ):
2144 
    self.send_getActiveBanners()
2145 
    return self.recv_getActiveBanners()
2146 
 
2147 
  def send_getActiveBanners(self, ):
2148 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2149 
    args = getActiveBanners_args()
2150 
    args.write(self._oprot)
2151 
    self._oprot.writeMessageEnd()
2152 
    self._oprot.trans.flush()
2153 
 
2154 
  def recv_getActiveBanners(self, ):
2155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2156 
    if mtype == TMessageType.EXCEPTION:
2157 
      x = TApplicationException()
2158 
      x.read(self._iprot)
2159 
      self._iprot.readMessageEnd()
2160 
      raise x
2161 
    result = getActiveBanners_result()
2162 
    result.read(self._iprot)
2163 
    self._iprot.readMessageEnd()
2164 
    if result.success is not None:
2165 
      return result.success
2166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2167 
 
6849 kshitij.so 2168 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2169 
    """
2170 
    Parameters:
2171 
     - bannerName
2172 
     - mapLink
2173 
     - coordinates
2174 
    """
2175 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2176 
    return self.recv_addBannerMap()
2177 
 
2178 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2179 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2180 
    args = addBannerMap_args()
2181 
    args.bannerName = bannerName
2182 
    args.mapLink = mapLink
2183 
    args.coordinates = coordinates
2184 
    args.write(self._oprot)
2185 
    self._oprot.writeMessageEnd()
2186 
    self._oprot.trans.flush()
2187 
 
2188 
  def recv_addBannerMap(self, ):
2189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2190 
    if mtype == TMessageType.EXCEPTION:
2191 
      x = TApplicationException()
2192 
      x.read(self._iprot)
2193 
      self._iprot.readMessageEnd()
2194 
      raise x
2195 
    result = addBannerMap_result()
2196 
    result.read(self._iprot)
2197 
    self._iprot.readMessageEnd()
2198 
    if result.success is not None:
2199 
      return result.success
2200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2201 
 
2202 
  def deleteBannerMap(self, bannerName):
2203 
    """
2204 
    Parameters:
2205 
     - bannerName
2206 
    """
2207 
    self.send_deleteBannerMap(bannerName)
2208 
    return self.recv_deleteBannerMap()
2209 
 
2210 
  def send_deleteBannerMap(self, bannerName):
2211 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2212 
    args = deleteBannerMap_args()
2213 
    args.bannerName = bannerName
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_deleteBannerMap(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = deleteBannerMap_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
2228 
    if result.success is not None:
2229 
      return result.success
2230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2231 
 
2232 
  def getBannerMapDetails(self, bannerName):
2233 
    """
2234 
    Parameters:
2235 
     - bannerName
2236 
    """
2237 
    self.send_getBannerMapDetails(bannerName)
2238 
    return self.recv_getBannerMapDetails()
2239 
 
2240 
  def send_getBannerMapDetails(self, bannerName):
2241 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2242 
    args = getBannerMapDetails_args()
2243 
    args.bannerName = bannerName
2244 
    args.write(self._oprot)
2245 
    self._oprot.writeMessageEnd()
2246 
    self._oprot.trans.flush()
2247 
 
2248 
  def recv_getBannerMapDetails(self, ):
2249 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2250 
    if mtype == TMessageType.EXCEPTION:
2251 
      x = TApplicationException()
2252 
      x.read(self._iprot)
2253 
      self._iprot.readMessageEnd()
2254 
      raise x
2255 
    result = getBannerMapDetails_result()
2256 
    result.read(self._iprot)
2257 
    self._iprot.readMessageEnd()
2258 
    if result.success is not None:
2259 
      return result.success
2260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2261 
 
5944 mandeep.dh 2262 
  def deleteSimilarItem(self, itemId, catalogItemId):
2263 
    """
2264 
    Delete similar item.
2265 
 
2266 
    Parameters:
2267 
     - itemId
2268 
     - catalogItemId
2269 
    """
2270 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2271 
    return self.recv_deleteSimilarItem()
2272 
 
2273 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2274 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2275 
    args = deleteSimilarItem_args()
2276 
    args.itemId = itemId
2277 
    args.catalogItemId = catalogItemId
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_deleteSimilarItem(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = deleteSimilarItem_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
2292 
    if result.success is not None:
2293 
      return result.success
2294 
    if result.cex is not None:
2295 
      raise result.cex
2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2297 
 
2298 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2299 
    """
2300 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2301 
    If yes, returns the itemId else returns 0
2302 
 
2303 
    Parameters:
2304 
     - brand
2305 
     - modelNumber
2306 
     - modelName
2307 
     - color
2308 
    """
2309 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2310 
    return self.recv_checkSimilarItem()
2311 
 
2312 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2313 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2314 
    args = checkSimilarItem_args()
2315 
    args.brand = brand
2316 
    args.modelNumber = modelNumber
2317 
    args.modelName = modelName
2318 
    args.color = color
2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
2323 
  def recv_checkSimilarItem(self, ):
2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
2330 
    result = checkSimilarItem_result()
2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
2333 
    if result.success is not None:
2334 
      return result.success
2335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2336 
 
2337 
  def validateRiskyStatus(self, itemId):
2338 
    """
2339 
    Check wether item is risky and change status if inventory is not available for risky items
2340 
 
2341 
    Parameters:
2342 
     - itemId
2343 
    """
2344 
    self.send_validateRiskyStatus(itemId)
2345 
    self.recv_validateRiskyStatus()
2346 
 
2347 
  def send_validateRiskyStatus(self, itemId):
2348 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2349 
    args = validateRiskyStatus_args()
2350 
    args.itemId = itemId
2351 
    args.write(self._oprot)
2352 
    self._oprot.writeMessageEnd()
2353 
    self._oprot.trans.flush()
2354 
 
2355 
  def recv_validateRiskyStatus(self, ):
2356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2357 
    if mtype == TMessageType.EXCEPTION:
2358 
      x = TApplicationException()
2359 
      x.read(self._iprot)
2360 
      self._iprot.readMessageEnd()
2361 
      raise x
2362 
    result = validateRiskyStatus_result()
2363 
    result.read(self._iprot)
2364 
    self._iprot.readMessageEnd()
2365 
    return
2366 
 
2367 
  def changeItemRiskyFlag(self, itemId, risky):
2368 
    """
2369 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2370 
 
2371 
    Parameters:
2372 
     - itemId
2373 
     - risky
2374 
    """
2375 
    self.send_changeItemRiskyFlag(itemId, risky)
2376 
    self.recv_changeItemRiskyFlag()
2377 
 
2378 
  def send_changeItemRiskyFlag(self, itemId, risky):
2379 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2380 
    args = changeItemRiskyFlag_args()
2381 
    args.itemId = itemId
2382 
    args.risky = risky
2383 
    args.write(self._oprot)
2384 
    self._oprot.writeMessageEnd()
2385 
    self._oprot.trans.flush()
2386 
 
2387 
  def recv_changeItemRiskyFlag(self, ):
2388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2389 
    if mtype == TMessageType.EXCEPTION:
2390 
      x = TApplicationException()
2391 
      x.read(self._iprot)
2392 
      self._iprot.readMessageEnd()
2393 
      raise x
2394 
    result = changeItemRiskyFlag_result()
2395 
    result.read(self._iprot)
2396 
    self._iprot.readMessageEnd()
2397 
    return
2398 
 
2399 
  def getItemsByRiskyFlag(self, ):
2400 
    """
2401 
    Returns list of items marked as risky.
2402 
    """
2403 
    self.send_getItemsByRiskyFlag()
2404 
    return self.recv_getItemsByRiskyFlag()
2405 
 
2406 
  def send_getItemsByRiskyFlag(self, ):
2407 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2408 
    args = getItemsByRiskyFlag_args()
2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_getItemsByRiskyFlag(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = getItemsByRiskyFlag_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
2423 
    if result.success is not None:
2424 
      return result.success
2425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2426 
 
2427 
  def getItemsForMasterSheet(self, category, brand):
2428 
    """
2429 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2430 
 
2431 
    Parameters:
2432 
     - category
2433 
     - brand
2434 
    """
2435 
    self.send_getItemsForMasterSheet(category, brand)
2436 
    return self.recv_getItemsForMasterSheet()
2437 
 
2438 
  def send_getItemsForMasterSheet(self, category, brand):
2439 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2440 
    args = getItemsForMasterSheet_args()
2441 
    args.category = category
2442 
    args.brand = brand
2443 
    args.write(self._oprot)
2444 
    self._oprot.writeMessageEnd()
2445 
    self._oprot.trans.flush()
2446 
 
2447 
  def recv_getItemsForMasterSheet(self, ):
2448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2449 
    if mtype == TMessageType.EXCEPTION:
2450 
      x = TApplicationException()
2451 
      x.read(self._iprot)
2452 
      self._iprot.readMessageEnd()
2453 
      raise x
2454 
    result = getItemsForMasterSheet_result()
2455 
    result.read(self._iprot)
2456 
    self._iprot.readMessageEnd()
2457 
    if result.success is not None:
2458 
      return result.success
2459 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2460 
 
2461 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2462 
    """
2463 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2464 
 
2465 
    Parameters:
2466 
     - beginIndex
2467 
     - totalItems
2468 
     - itemId
2469 
    """
2470 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2471 
    return self.recv_getSimilarItemsCatalogIds()
2472 
 
2473 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2474 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2475 
    args = getSimilarItemsCatalogIds_args()
2476 
    args.beginIndex = beginIndex
2477 
    args.totalItems = totalItems
2478 
    args.itemId = itemId
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_getSimilarItemsCatalogIds(self, ):
2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
2490 
    result = getSimilarItemsCatalogIds_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
2493 
    if result.success is not None:
2494 
      return result.success
2495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2496 
 
2497 
  def addProductNotification(self, itemId, email):
2498 
    """
2499 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2500 
 
2501 
    Parameters:
2502 
     - itemId
2503 
     - email
2504 
    """
2505 
    self.send_addProductNotification(itemId, email)
2506 
    return self.recv_addProductNotification()
2507 
 
2508 
  def send_addProductNotification(self, itemId, email):
2509 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2510 
    args = addProductNotification_args()
2511 
    args.itemId = itemId
2512 
    args.email = email
2513 
    args.write(self._oprot)
2514 
    self._oprot.writeMessageEnd()
2515 
    self._oprot.trans.flush()
2516 
 
2517 
  def recv_addProductNotification(self, ):
2518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2519 
    if mtype == TMessageType.EXCEPTION:
2520 
      x = TApplicationException()
2521 
      x.read(self._iprot)
2522 
      self._iprot.readMessageEnd()
2523 
      raise x
2524 
    result = addProductNotification_result()
2525 
    result.read(self._iprot)
2526 
    self._iprot.readMessageEnd()
2527 
    if result.success is not None:
2528 
      return result.success
2529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2530 
 
2531 
  def sendProductNotifications(self, ):
2532 
    """
2533 
    Send the product notifications to the users for items which has stock.
2534 
    """
2535 
    self.send_sendProductNotifications()
2536 
    return self.recv_sendProductNotifications()
2537 
 
2538 
  def send_sendProductNotifications(self, ):
2539 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2540 
    args = sendProductNotifications_args()
2541 
    args.write(self._oprot)
2542 
    self._oprot.writeMessageEnd()
2543 
    self._oprot.trans.flush()
2544 
 
2545 
  def recv_sendProductNotifications(self, ):
2546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2547 
    if mtype == TMessageType.EXCEPTION:
2548 
      x = TApplicationException()
2549 
      x.read(self._iprot)
2550 
      self._iprot.readMessageEnd()
2551 
      raise x
2552 
    result = sendProductNotifications_result()
2553 
    result.read(self._iprot)
2554 
    self._iprot.readMessageEnd()
2555 
    if result.success is not None:
2556 
      return result.success
2557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2558 
 
2559 
  def getAllBrandsByCategory(self, categoryId):
2560 
    """
2561 
    Returns list of brand names for a given category Id
2562 
 
2563 
    Parameters:
2564 
     - categoryId
2565 
    """
2566 
    self.send_getAllBrandsByCategory(categoryId)
2567 
    return self.recv_getAllBrandsByCategory()
2568 
 
2569 
  def send_getAllBrandsByCategory(self, categoryId):
2570 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2571 
    args = getAllBrandsByCategory_args()
2572 
    args.categoryId = categoryId
2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_getAllBrandsByCategory(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = getAllBrandsByCategory_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.success is not None:
2588 
      return result.success
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2590 
 
2591 
  def getAllBrands(self, ):
2592 
    """
2593 
    Returns list of brand names
2594 
    """
2595 
    self.send_getAllBrands()
2596 
    return self.recv_getAllBrands()
2597 
 
2598 
  def send_getAllBrands(self, ):
2599 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2600 
    args = getAllBrands_args()
2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
2605 
  def recv_getAllBrands(self, ):
2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
2612 
    result = getAllBrands_result()
2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
2615 
    if result.success is not None:
2616 
      return result.success
2617 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2618 
 
2619 
  def getAllSources(self, ):
2620 
    """
2621 
    Return list of all sources
2622 
    """
2623 
    self.send_getAllSources()
2624 
    return self.recv_getAllSources()
2625 
 
2626 
  def send_getAllSources(self, ):
2627 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2628 
    args = getAllSources_args()
2629 
    args.write(self._oprot)
2630 
    self._oprot.writeMessageEnd()
2631 
    self._oprot.trans.flush()
2632 
 
2633 
  def recv_getAllSources(self, ):
2634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2635 
    if mtype == TMessageType.EXCEPTION:
2636 
      x = TApplicationException()
2637 
      x.read(self._iprot)
2638 
      self._iprot.readMessageEnd()
2639 
      raise x
2640 
    result = getAllSources_result()
2641 
    result.read(self._iprot)
2642 
    self._iprot.readMessageEnd()
2643 
    if result.success is not None:
2644 
      return result.success
2645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2646 
 
2647 
  def getItemPricingBySource(self, itemId, sourceId):
2648 
    """
2649 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2650 
 
2651 
    Parameters:
2652 
     - itemId
2653 
     - sourceId
2654 
    """
2655 
    self.send_getItemPricingBySource(itemId, sourceId)
2656 
    return self.recv_getItemPricingBySource()
2657 
 
2658 
  def send_getItemPricingBySource(self, itemId, sourceId):
2659 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2660 
    args = getItemPricingBySource_args()
2661 
    args.itemId = itemId
2662 
    args.sourceId = sourceId
2663 
    args.write(self._oprot)
2664 
    self._oprot.writeMessageEnd()
2665 
    self._oprot.trans.flush()
2666 
 
2667 
  def recv_getItemPricingBySource(self, ):
2668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2669 
    if mtype == TMessageType.EXCEPTION:
2670 
      x = TApplicationException()
2671 
      x.read(self._iprot)
2672 
      self._iprot.readMessageEnd()
2673 
      raise x
2674 
    result = getItemPricingBySource_result()
2675 
    result.read(self._iprot)
2676 
    self._iprot.readMessageEnd()
2677 
    if result.success is not None:
2678 
      return result.success
2679 
    if result.cex is not None:
2680 
      raise result.cex
2681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2682 
 
2683 
  def addSourceItemPricing(self, sourceItemPricing):
2684 
    """
2685 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2686 
    If item is not found or source is not found, it will throw exception.
2687 
 
2688 
    Parameters:
2689 
     - sourceItemPricing
2690 
    """
2691 
    self.send_addSourceItemPricing(sourceItemPricing)
2692 
    self.recv_addSourceItemPricing()
2693 
 
2694 
  def send_addSourceItemPricing(self, sourceItemPricing):
2695 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2696 
    args = addSourceItemPricing_args()
2697 
    args.sourceItemPricing = sourceItemPricing
2698 
    args.write(self._oprot)
2699 
    self._oprot.writeMessageEnd()
2700 
    self._oprot.trans.flush()
2701 
 
2702 
  def recv_addSourceItemPricing(self, ):
2703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2704 
    if mtype == TMessageType.EXCEPTION:
2705 
      x = TApplicationException()
2706 
      x.read(self._iprot)
2707 
      self._iprot.readMessageEnd()
2708 
      raise x
2709 
    result = addSourceItemPricing_result()
2710 
    result.read(self._iprot)
2711 
    self._iprot.readMessageEnd()
2712 
    if result.cex is not None:
2713 
      raise result.cex
2714 
    return
2715 
 
2716 
  def getAllSourcePricing(self, itemId):
2717 
    """
2718 
    Returns the list of source pricing information of an item.
2719 
    Raises an exception if item not found corresponding to itemId
2720 
 
2721 
    Parameters:
2722 
     - itemId
2723 
    """
2724 
    self.send_getAllSourcePricing(itemId)
2725 
    return self.recv_getAllSourcePricing()
2726 
 
2727 
  def send_getAllSourcePricing(self, itemId):
2728 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2729 
    args = getAllSourcePricing_args()
2730 
    args.itemId = itemId
2731 
    args.write(self._oprot)
2732 
    self._oprot.writeMessageEnd()
2733 
    self._oprot.trans.flush()
2734 
 
2735 
  def recv_getAllSourcePricing(self, ):
2736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2737 
    if mtype == TMessageType.EXCEPTION:
2738 
      x = TApplicationException()
2739 
      x.read(self._iprot)
2740 
      self._iprot.readMessageEnd()
2741 
      raise x
2742 
    result = getAllSourcePricing_result()
2743 
    result.read(self._iprot)
2744 
    self._iprot.readMessageEnd()
2745 
    if result.success is not None:
2746 
      return result.success
2747 
    if result.cex is not None:
2748 
      raise result.cex
2749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2750 
 
2751 
  def getItemForSource(self, item_id, sourceId):
2752 
    """
2753 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2754 
 
2755 
    Parameters:
2756 
     - item_id
2757 
     - sourceId
2758 
    """
2759 
    self.send_getItemForSource(item_id, sourceId)
2760 
    return self.recv_getItemForSource()
2761 
 
2762 
  def send_getItemForSource(self, item_id, sourceId):
2763 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2764 
    args = getItemForSource_args()
2765 
    args.item_id = item_id
2766 
    args.sourceId = sourceId
2767 
    args.write(self._oprot)
2768 
    self._oprot.writeMessageEnd()
2769 
    self._oprot.trans.flush()
2770 
 
2771 
  def recv_getItemForSource(self, ):
2772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2773 
    if mtype == TMessageType.EXCEPTION:
2774 
      x = TApplicationException()
2775 
      x.read(self._iprot)
2776 
      self._iprot.readMessageEnd()
2777 
      raise x
2778 
    result = getItemForSource_result()
2779 
    result.read(self._iprot)
2780 
    self._iprot.readMessageEnd()
2781 
    if result.success is not None:
2782 
      return result.success
2783 
    if result.cex is not None:
2784 
      raise result.cex
2785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2786 
 
2787 
  def searchItemsInRange(self, searchTerms, offset, limit):
2788 
    """
2789 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2790 
 
2791 
    Parameters:
2792 
     - searchTerms
2793 
     - offset
2794 
     - limit
2795 
    """
2796 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2797 
    return self.recv_searchItemsInRange()
2798 
 
2799 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2800 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2801 
    args = searchItemsInRange_args()
2802 
    args.searchTerms = searchTerms
2803 
    args.offset = offset
2804 
    args.limit = limit
2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
2809 
  def recv_searchItemsInRange(self, ):
2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
2816 
    result = searchItemsInRange_result()
2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
2819 
    if result.success is not None:
2820 
      return result.success
2821 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2822 
 
2823 
  def getSearchResultCount(self, searchTerms):
2824 
    """
2825 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2826 
 
2827 
    Parameters:
2828 
     - searchTerms
2829 
    """
2830 
    self.send_getSearchResultCount(searchTerms)
2831 
    return self.recv_getSearchResultCount()
2832 
 
2833 
  def send_getSearchResultCount(self, searchTerms):
2834 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2835 
    args = getSearchResultCount_args()
2836 
    args.searchTerms = searchTerms
2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
2841 
  def recv_getSearchResultCount(self, ):
2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
2848 
    result = getSearchResultCount_result()
2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
2851 
    if result.success is not None:
2852 
      return result.success
2853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2854 
 
2855 
  def getProductNotifications(self, startDateTime):
2856 
    """
2857 
    Returns a list of product notifications added after a supplied datetime
2858 
 
2859 
    Parameters:
2860 
     - startDateTime
2861 
    """
2862 
    self.send_getProductNotifications(startDateTime)
2863 
    return self.recv_getProductNotifications()
2864 
 
2865 
  def send_getProductNotifications(self, startDateTime):
2866 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2867 
    args = getProductNotifications_args()
2868 
    args.startDateTime = startDateTime
2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
2873 
  def recv_getProductNotifications(self, ):
2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
2880 
    result = getProductNotifications_result()
2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
2883 
    if result.success is not None:
2884 
      return result.success
2885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2886 
 
2887 
  def getProductNotificationRequestCount(self, startDateTime):
2888 
    """
2889 
    Returns a list of count of requests for product notification against each item
2890 
 
2891 
    Parameters:
2892 
     - startDateTime
2893 
    """
2894 
    self.send_getProductNotificationRequestCount(startDateTime)
2895 
    return self.recv_getProductNotificationRequestCount()
2896 
 
2897 
  def send_getProductNotificationRequestCount(self, startDateTime):
2898 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2899 
    args = getProductNotificationRequestCount_args()
2900 
    args.startDateTime = startDateTime
2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
2905 
  def recv_getProductNotificationRequestCount(self, ):
2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
2912 
    result = getProductNotificationRequestCount_result()
2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
2915 
    if result.success is not None:
2916 
      return result.success
2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2918 
 
2919 
  def addAuthorizationLog(self, itemId, username, reason):
2920 
    """
2921 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2922 
 
2923 
    Parameters:
2924 
     - itemId
2925 
     - username
2926 
     - reason
2927 
    """
2928 
    self.send_addAuthorizationLog(itemId, username, reason)
2929 
    return self.recv_addAuthorizationLog()
2930 
 
2931 
  def send_addAuthorizationLog(self, itemId, username, reason):
2932 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2933 
    args = addAuthorizationLog_args()
2934 
    args.itemId = itemId
2935 
    args.username = username
2936 
    args.reason = reason
2937 
    args.write(self._oprot)
2938 
    self._oprot.writeMessageEnd()
2939 
    self._oprot.trans.flush()
2940 
 
2941 
  def recv_addAuthorizationLog(self, ):
2942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2943 
    if mtype == TMessageType.EXCEPTION:
2944 
      x = TApplicationException()
2945 
      x.read(self._iprot)
2946 
      self._iprot.readMessageEnd()
2947 
      raise x
2948 
    result = addAuthorizationLog_result()
2949 
    result.read(self._iprot)
2950 
    self._iprot.readMessageEnd()
2951 
    if result.success is not None:
2952 
      return result.success
2953 
    if result.cex is not None:
2954 
      raise result.cex
2955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
2956 
 
2957 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2958 
    """
2959 
    Parameters:
2960 
     - catalog_item_id
2961 
     - voucherType
2962 
     - voucherAmount
2963 
    """
2964 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
2965 
    return self.recv_addupdateVoucherForItem()
2966 
 
2967 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
2968 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
2969 
    args = addupdateVoucherForItem_args()
2970 
    args.catalog_item_id = catalog_item_id
2971 
    args.voucherType = voucherType
2972 
    args.voucherAmount = voucherAmount
2973 
    args.write(self._oprot)
2974 
    self._oprot.writeMessageEnd()
2975 
    self._oprot.trans.flush()
2976 
 
2977 
  def recv_addupdateVoucherForItem(self, ):
2978 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2979 
    if mtype == TMessageType.EXCEPTION:
2980 
      x = TApplicationException()
2981 
      x.read(self._iprot)
2982 
      self._iprot.readMessageEnd()
2983 
      raise x
2984 
    result = addupdateVoucherForItem_result()
2985 
    result.read(self._iprot)
2986 
    self._iprot.readMessageEnd()
2987 
    if result.success is not None:
2988 
      return result.success
2989 
    if result.cex is not None:
2990 
      raise result.cex
2991 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
2992 
 
2993 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
2994 
    """
2995 
    Parameters:
2996 
     - catalog_item_id
2997 
     - voucherType
2998 
    """
2999 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3000 
    return self.recv_deleteVoucherForItem()
3001 
 
3002 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3003 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3004 
    args = deleteVoucherForItem_args()
3005 
    args.catalog_item_id = catalog_item_id
3006 
    args.voucherType = voucherType
3007 
    args.write(self._oprot)
3008 
    self._oprot.writeMessageEnd()
3009 
    self._oprot.trans.flush()
3010 
 
3011 
  def recv_deleteVoucherForItem(self, ):
3012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3013 
    if mtype == TMessageType.EXCEPTION:
3014 
      x = TApplicationException()
3015 
      x.read(self._iprot)
3016 
      self._iprot.readMessageEnd()
3017 
      raise x
3018 
    result = deleteVoucherForItem_result()
3019 
    result.read(self._iprot)
3020 
    self._iprot.readMessageEnd()
3021 
    if result.success is not None:
3022 
      return result.success
3023 
    if result.cex is not None:
3024 
      raise result.cex
3025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3026 
 
3027 
  def getVoucherAmount(self, itemId, voucherType):
3028 
    """
3029 
    Parameters:
3030 
     - itemId
3031 
     - voucherType
3032 
    """
3033 
    self.send_getVoucherAmount(itemId, voucherType)
3034 
    return self.recv_getVoucherAmount()
3035 
 
3036 
  def send_getVoucherAmount(self, itemId, voucherType):
3037 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3038 
    args = getVoucherAmount_args()
3039 
    args.itemId = itemId
3040 
    args.voucherType = voucherType
3041 
    args.write(self._oprot)
3042 
    self._oprot.writeMessageEnd()
3043 
    self._oprot.trans.flush()
3044 
 
3045 
  def recv_getVoucherAmount(self, ):
3046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3047 
    if mtype == TMessageType.EXCEPTION:
3048 
      x = TApplicationException()
3049 
      x.read(self._iprot)
3050 
      self._iprot.readMessageEnd()
3051 
      raise x
3052 
    result = getVoucherAmount_result()
3053 
    result.read(self._iprot)
3054 
    self._iprot.readMessageEnd()
3055 
    if result.success is not None:
3056 
      return result.success
3057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3058 
 
3059 
  def getAllItemVouchers(self, itemId):
3060 
    """
3061 
    Parameters:
3062 
     - itemId
3063 
    """
3064 
    self.send_getAllItemVouchers(itemId)
3065 
    return self.recv_getAllItemVouchers()
3066 
 
3067 
  def send_getAllItemVouchers(self, itemId):
3068 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3069 
    args = getAllItemVouchers_args()
3070 
    args.itemId = itemId
3071 
    args.write(self._oprot)
3072 
    self._oprot.writeMessageEnd()
3073 
    self._oprot.trans.flush()
3074 
 
3075 
  def recv_getAllItemVouchers(self, ):
3076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3077 
    if mtype == TMessageType.EXCEPTION:
3078 
      x = TApplicationException()
3079 
      x.read(self._iprot)
3080 
      self._iprot.readMessageEnd()
3081 
      raise x
3082 
    result = getAllItemVouchers_result()
3083 
    result.read(self._iprot)
3084 
    self._iprot.readMessageEnd()
3085 
    if result.success is not None:
3086 
      return result.success
3087 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3088 
 
3089 
  def isValidCatalogItemId(self, catalog_item_id):
3090 
    """
3091 
    Parameters:
3092 
     - catalog_item_id
3093 
    """
3094 
    self.send_isValidCatalogItemId(catalog_item_id)
3095 
    return self.recv_isValidCatalogItemId()
3096 
 
3097 
  def send_isValidCatalogItemId(self, catalog_item_id):
3098 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3099 
    args = isValidCatalogItemId_args()
3100 
    args.catalog_item_id = catalog_item_id
3101 
    args.write(self._oprot)
3102 
    self._oprot.writeMessageEnd()
3103 
    self._oprot.trans.flush()
3104 
 
3105 
  def recv_isValidCatalogItemId(self, ):
3106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3107 
    if mtype == TMessageType.EXCEPTION:
3108 
      x = TApplicationException()
3109 
      x.read(self._iprot)
3110 
      self._iprot.readMessageEnd()
3111 
      raise x
3112 
    result = isValidCatalogItemId_result()
3113 
    result.read(self._iprot)
3114 
    self._iprot.readMessageEnd()
3115 
    if result.success is not None:
3116 
      return result.success
3117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3118 
 
7330 amit.gupta 3119 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3120 
    """
3121 
    Parameters:
3122 
     - itemId
7330 amit.gupta 3123 
     - stateId
6039 amit.gupta 3124 
     - price
3125 
    """
7330 amit.gupta 3126 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3127 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3128 
 
7330 amit.gupta 3129 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3130 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3131 
    args = getVatPercentageForItem_args()
3132 
    args.itemId = itemId
7330 amit.gupta 3133 
    args.stateId = stateId
6039 amit.gupta 3134 
    args.price = price
3135 
    args.write(self._oprot)
3136 
    self._oprot.writeMessageEnd()
3137 
    self._oprot.trans.flush()
3138 
 
3139 
  def recv_getVatPercentageForItem(self, ):
3140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3141 
    if mtype == TMessageType.EXCEPTION:
3142 
      x = TApplicationException()
3143 
      x.read(self._iprot)
3144 
      self._iprot.readMessageEnd()
3145 
      raise x
3146 
    result = getVatPercentageForItem_result()
3147 
    result.read(self._iprot)
3148 
    self._iprot.readMessageEnd()
3149 
    if result.success is not None:
3150 
      return result.success
7340 amit.gupta 3151 
    if result.cex is not None:
3152 
      raise result.cex
6039 amit.gupta 3153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3154 
 
3155 
  def getVatAmountForItem(self, itemId, price):
3156 
    """
3157 
    Parameters:
3158 
     - itemId
3159 
     - price
3160 
    """
3161 
    self.send_getVatAmountForItem(itemId, price)
3162 
    return self.recv_getVatAmountForItem()
3163 
 
3164 
  def send_getVatAmountForItem(self, itemId, price):
3165 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3166 
    args = getVatAmountForItem_args()
3167 
    args.itemId = itemId
3168 
    args.price = price
3169 
    args.write(self._oprot)
3170 
    self._oprot.writeMessageEnd()
3171 
    self._oprot.trans.flush()
3172 
 
3173 
  def recv_getVatAmountForItem(self, ):
3174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3175 
    if mtype == TMessageType.EXCEPTION:
3176 
      x = TApplicationException()
3177 
      x.read(self._iprot)
3178 
      self._iprot.readMessageEnd()
3179 
      raise x
3180 
    result = getVatAmountForItem_result()
3181 
    result.read(self._iprot)
3182 
    self._iprot.readMessageEnd()
3183 
    if result.success is not None:
3184 
      return result.success
3185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3186 
 
6531 vikram.rag 3187 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3188 
    """
3189 
    Parameters:
3190 
     - offset
3191 
     - limit
3192 
    """
3193 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3194 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3195 
 
6531 vikram.rag 3196 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3197 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3198 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3199 
    args.offset = offset
3200 
    args.limit = limit
3201 
    args.write(self._oprot)
3202 
    self._oprot.writeMessageEnd()
3203 
    self._oprot.trans.flush()
3204 
 
3205 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3207 
    if mtype == TMessageType.EXCEPTION:
3208 
      x = TApplicationException()
3209 
      x.read(self._iprot)
3210 
      self._iprot.readMessageEnd()
3211 
      raise x
3212 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3213 
    result.read(self._iprot)
3214 
    self._iprot.readMessageEnd()
3215 
    if result.success is not None:
3216 
      return result.success
3217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3218 
 
6821 amar.kumar 3219 
  def getAllAliveItems(self, ):
3220 
    self.send_getAllAliveItems()
3221 
    return self.recv_getAllAliveItems()
3222 
 
3223 
  def send_getAllAliveItems(self, ):
3224 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3225 
    args = getAllAliveItems_args()
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_getAllAliveItems(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = getAllAliveItems_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.success is not None:
3241 
      return result.success
3242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3243 
 
6921 anupam.sin 3244 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3245 
    """
3246 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3247 
 
6805 anupam.sin 3248 
    Parameters:
3249 
     - itemId
6921 anupam.sin 3250 
     - price
6805 anupam.sin 3251 
     - insurerId
3252 
     - quantity
3253 
    """
6921 anupam.sin 3254 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3255 
    return self.recv_getInsuranceAmount()
3256 
 
6921 anupam.sin 3257 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3258 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3259 
    args = getInsuranceAmount_args()
3260 
    args.itemId = itemId
6921 anupam.sin 3261 
    args.price = price
6805 anupam.sin 3262 
    args.insurerId = insurerId
3263 
    args.quantity = quantity
3264 
    args.write(self._oprot)
3265 
    self._oprot.writeMessageEnd()
3266 
    self._oprot.trans.flush()
3267 
 
3268 
  def recv_getInsuranceAmount(self, ):
3269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3270 
    if mtype == TMessageType.EXCEPTION:
3271 
      x = TApplicationException()
3272 
      x.read(self._iprot)
3273 
      self._iprot.readMessageEnd()
3274 
      raise x
3275 
    result = getInsuranceAmount_result()
3276 
    result.read(self._iprot)
3277 
    self._iprot.readMessageEnd()
3278 
    if result.success is not None:
3279 
      return result.success
3280 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3281 
 
3282 
  def getInsurer(self, insurerId):
3283 
    """
3284 
    Parameters:
3285 
     - insurerId
3286 
    """
3287 
    self.send_getInsurer(insurerId)
3288 
    return self.recv_getInsurer()
3289 
 
3290 
  def send_getInsurer(self, insurerId):
3291 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3292 
    args = getInsurer_args()
3293 
    args.insurerId = insurerId
3294 
    args.write(self._oprot)
3295 
    self._oprot.writeMessageEnd()
3296 
    self._oprot.trans.flush()
3297 
 
3298 
  def recv_getInsurer(self, ):
3299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3300 
    if mtype == TMessageType.EXCEPTION:
3301 
      x = TApplicationException()
3302 
      x.read(self._iprot)
3303 
      self._iprot.readMessageEnd()
3304 
      raise x
3305 
    result = getInsurer_result()
3306 
    result.read(self._iprot)
3307 
    self._iprot.readMessageEnd()
3308 
    if result.success is not None:
3309 
      return result.success
3310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3311 
 
6838 vikram.rag 3312 
  def getAllInsurers(self, ):
3313 
    self.send_getAllInsurers()
3314 
    return self.recv_getAllInsurers()
6805 anupam.sin 3315 
 
6838 vikram.rag 3316 
  def send_getAllInsurers(self, ):
3317 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3318 
    args = getAllInsurers_args()
3319 
    args.write(self._oprot)
3320 
    self._oprot.writeMessageEnd()
3321 
    self._oprot.trans.flush()
3322 
 
3323 
  def recv_getAllInsurers(self, ):
3324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3325 
    if mtype == TMessageType.EXCEPTION:
3326 
      x = TApplicationException()
3327 
      x.read(self._iprot)
3328 
      self._iprot.readMessageEnd()
3329 
      raise x
3330 
    result = getAllInsurers_result()
3331 
    result.read(self._iprot)
3332 
    self._iprot.readMessageEnd()
3333 
    if result.success is not None:
3334 
      return result.success
3335 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3336 
 
6962 rajveer 3337 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3338 
    """
3339 
    Parameters:
3340 
     - insurerId
3341 
     - amount
3342 
    """
3343 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3344 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3345 
 
6962 rajveer 3346 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3347 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3348 
    args = updateInsuranceDeclaredAmount_args()
3349 
    args.insurerId = insurerId
3350 
    args.amount = amount
3351 
    args.write(self._oprot)
3352 
    self._oprot.writeMessageEnd()
3353 
    self._oprot.trans.flush()
3354 
 
3355 
  def recv_updateInsuranceDeclaredAmount(self, ):
3356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3357 
    if mtype == TMessageType.EXCEPTION:
3358 
      x = TApplicationException()
3359 
      x.read(self._iprot)
3360 
      self._iprot.readMessageEnd()
3361 
      raise x
3362 
    result = updateInsuranceDeclaredAmount_result()
3363 
    result.read(self._iprot)
3364 
    self._iprot.readMessageEnd()
3365 
    return
3366 
 
7190 amar.kumar 3367 
  def getFreebieForItem(self, itemId):
3368 
    """
3369 
    Parameters:
3370 
     - itemId
3371 
    """
3372 
    self.send_getFreebieForItem(itemId)
3373 
    return self.recv_getFreebieForItem()
6962 rajveer 3374 
 
7190 amar.kumar 3375 
  def send_getFreebieForItem(self, itemId):
3376 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3377 
    args = getFreebieForItem_args()
3378 
    args.itemId = itemId
3379 
    args.write(self._oprot)
3380 
    self._oprot.writeMessageEnd()
3381 
    self._oprot.trans.flush()
3382 
 
3383 
  def recv_getFreebieForItem(self, ):
3384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3385 
    if mtype == TMessageType.EXCEPTION:
3386 
      x = TApplicationException()
3387 
      x.read(self._iprot)
3388 
      self._iprot.readMessageEnd()
3389 
      raise x
3390 
    result = getFreebieForItem_result()
3391 
    result.read(self._iprot)
3392 
    self._iprot.readMessageEnd()
3393 
    if result.success is not None:
3394 
      return result.success
3395 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3396 
 
3397 
  def addOrUpdateFreebieForItem(self, freebieItem):
3398 
    """
3399 
    Parameters:
3400 
     - freebieItem
3401 
    """
3402 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3403 
    self.recv_addOrUpdateFreebieForItem()
3404 
 
3405 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3406 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3407 
    args = addOrUpdateFreebieForItem_args()
3408 
    args.freebieItem = freebieItem
3409 
    args.write(self._oprot)
3410 
    self._oprot.writeMessageEnd()
3411 
    self._oprot.trans.flush()
3412 
 
3413 
  def recv_addOrUpdateFreebieForItem(self, ):
3414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3415 
    if mtype == TMessageType.EXCEPTION:
3416 
      x = TApplicationException()
3417 
      x.read(self._iprot)
3418 
      self._iprot.readMessageEnd()
3419 
      raise x
3420 
    result = addOrUpdateFreebieForItem_result()
3421 
    result.read(self._iprot)
3422 
    self._iprot.readMessageEnd()
3423 
    return
3424 
 
7272 amit.gupta 3425 
  def addOrUpdateBrandInfo(self, brandInfo):
3426 
    """
3427 
    Parameters:
3428 
     - brandInfo
3429 
    """
3430 
    self.send_addOrUpdateBrandInfo(brandInfo)
3431 
    self.recv_addOrUpdateBrandInfo()
3432 
 
3433 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3434 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3435 
    args = addOrUpdateBrandInfo_args()
3436 
    args.brandInfo = brandInfo
3437 
    args.write(self._oprot)
3438 
    self._oprot.writeMessageEnd()
3439 
    self._oprot.trans.flush()
3440 
 
3441 
  def recv_addOrUpdateBrandInfo(self, ):
3442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3443 
    if mtype == TMessageType.EXCEPTION:
3444 
      x = TApplicationException()
3445 
      x.read(self._iprot)
3446 
      self._iprot.readMessageEnd()
3447 
      raise x
3448 
    result = addOrUpdateBrandInfo_result()
3449 
    result.read(self._iprot)
3450 
    self._iprot.readMessageEnd()
3451 
    return
3452 
 
3453 
  def getBrandInfo(self, ):
3454 
    self.send_getBrandInfo()
3455 
    return self.recv_getBrandInfo()
3456 
 
3457 
  def send_getBrandInfo(self, ):
3458 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3459 
    args = getBrandInfo_args()
3460 
    args.write(self._oprot)
3461 
    self._oprot.writeMessageEnd()
3462 
    self._oprot.trans.flush()
3463 
 
3464 
  def recv_getBrandInfo(self, ):
3465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3466 
    if mtype == TMessageType.EXCEPTION:
3467 
      x = TApplicationException()
3468 
      x.read(self._iprot)
3469 
      self._iprot.readMessageEnd()
3470 
      raise x
3471 
    result = getBrandInfo_result()
3472 
    result.read(self._iprot)
3473 
    self._iprot.readMessageEnd()
3474 
    if result.success is not None:
3475 
      return result.success
3476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3477 
 
7256 rajveer 3478 
  def getStorePricing(self, itemId):
3479 
    """
3480 
    Parameters:
3481 
     - itemId
3482 
    """
3483 
    self.send_getStorePricing(itemId)
3484 
    return self.recv_getStorePricing()
7190 amar.kumar 3485 
 
7256 rajveer 3486 
  def send_getStorePricing(self, itemId):
3487 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3488 
    args = getStorePricing_args()
3489 
    args.itemId = itemId
3490 
    args.write(self._oprot)
3491 
    self._oprot.writeMessageEnd()
3492 
    self._oprot.trans.flush()
3493 
 
3494 
  def recv_getStorePricing(self, ):
3495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3496 
    if mtype == TMessageType.EXCEPTION:
3497 
      x = TApplicationException()
3498 
      x.read(self._iprot)
3499 
      self._iprot.readMessageEnd()
3500 
      raise x
3501 
    result = getStorePricing_result()
3502 
    result.read(self._iprot)
3503 
    self._iprot.readMessageEnd()
3504 
    if result.success is not None:
3505 
      return result.success
3506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3507 
 
7306 rajveer 3508 
  def getStorePricings(self, itemIds):
3509 
    """
3510 
    Parameters:
3511 
     - itemIds
3512 
    """
3513 
    self.send_getStorePricings(itemIds)
3514 
    return self.recv_getStorePricings()
3515 
 
3516 
  def send_getStorePricings(self, itemIds):
3517 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3518 
    args = getStorePricings_args()
3519 
    args.itemIds = itemIds
3520 
    args.write(self._oprot)
3521 
    self._oprot.writeMessageEnd()
3522 
    self._oprot.trans.flush()
3523 
 
3524 
  def recv_getStorePricings(self, ):
3525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3526 
    if mtype == TMessageType.EXCEPTION:
3527 
      x = TApplicationException()
3528 
      x.read(self._iprot)
3529 
      self._iprot.readMessageEnd()
3530 
      raise x
3531 
    result = getStorePricings_result()
3532 
    result.read(self._iprot)
3533 
    self._iprot.readMessageEnd()
3534 
    if result.success is not None:
3535 
      return result.success
3536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3537 
 
7265 rajveer 3538 
  def updateStorePricing(self, sp):
3539 
    """
3540 
    Parameters:
3541 
     - sp
3542 
    """
3543 
    self.send_updateStorePricing(sp)
3544 
    self.recv_updateStorePricing()
7256 rajveer 3545 
 
7265 rajveer 3546 
  def send_updateStorePricing(self, sp):
3547 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3548 
    args = updateStorePricing_args()
3549 
    args.sp = sp
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_updateStorePricing(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = updateStorePricing_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
3564 
    return
3565 
 
7281 kshitij.so 3566 
  def getAllAmazonListedItems(self, ):
3567 
    self.send_getAllAmazonListedItems()
3568 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3569 
 
7281 kshitij.so 3570 
  def send_getAllAmazonListedItems(self, ):
3571 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3572 
    args = getAllAmazonListedItems_args()
3573 
    args.write(self._oprot)
3574 
    self._oprot.writeMessageEnd()
3575 
    self._oprot.trans.flush()
3576 
 
3577 
  def recv_getAllAmazonListedItems(self, ):
3578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3579 
    if mtype == TMessageType.EXCEPTION:
3580 
      x = TApplicationException()
3581 
      x.read(self._iprot)
3582 
      self._iprot.readMessageEnd()
3583 
      raise x
3584 
    result = getAllAmazonListedItems_result()
3585 
    result.read(self._iprot)
3586 
    self._iprot.readMessageEnd()
3587 
    if result.success is not None:
3588 
      return result.success
3589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3590 
 
3591 
  def getAmazonItemDetails(self, itemId):
3592 
    """
3593 
    Parameters:
3594 
     - itemId
3595 
    """
3596 
    self.send_getAmazonItemDetails(itemId)
3597 
    return self.recv_getAmazonItemDetails()
3598 
 
3599 
  def send_getAmazonItemDetails(self, itemId):
3600 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3601 
    args = getAmazonItemDetails_args()
3602 
    args.itemId = itemId
3603 
    args.write(self._oprot)
3604 
    self._oprot.writeMessageEnd()
3605 
    self._oprot.trans.flush()
3606 
 
3607 
  def recv_getAmazonItemDetails(self, ):
3608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3609 
    if mtype == TMessageType.EXCEPTION:
3610 
      x = TApplicationException()
3611 
      x.read(self._iprot)
3612 
      self._iprot.readMessageEnd()
3613 
      raise x
3614 
    result = getAmazonItemDetails_result()
3615 
    result.read(self._iprot)
3616 
    self._iprot.readMessageEnd()
3617 
    if result.success is not None:
3618 
      return result.success
3619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3620 
 
3621 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3622 
    """
3623 
    Parameters:
3624 
     - itemId
3625 
     - fbaPrice
3626 
     - sellingPrice
3627 
     - isFba
3628 
     - isNonFba
3629 
     - isInventoryOverride
3630 
    """
3631 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride)
3632 
    self.recv_updateAmazonItemDetails()
3633 
 
3634 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride):
3635 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3636 
    args = updateAmazonItemDetails_args()
3637 
    args.itemId = itemId
3638 
    args.fbaPrice = fbaPrice
3639 
    args.sellingPrice = sellingPrice
3640 
    args.isFba = isFba
3641 
    args.isNonFba = isNonFba
3642 
    args.isInventoryOverride = isInventoryOverride
3643 
    args.write(self._oprot)
3644 
    self._oprot.writeMessageEnd()
3645 
    self._oprot.trans.flush()
3646 
 
3647 
  def recv_updateAmazonItemDetails(self, ):
3648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3649 
    if mtype == TMessageType.EXCEPTION:
3650 
      x = TApplicationException()
3651 
      x.read(self._iprot)
3652 
      self._iprot.readMessageEnd()
3653 
      raise x
3654 
    result = updateAmazonItemDetails_result()
3655 
    result.read(self._iprot)
3656 
    self._iprot.readMessageEnd()
3657 
    return
3658 
 
3659 
  def addAmazonItem(self, amazonlisted):
3660 
    """
3661 
    Parameters:
3662 
     - amazonlisted
3663 
    """
3664 
    self.send_addAmazonItem(amazonlisted)
3665 
    self.recv_addAmazonItem()
3666 
 
3667 
  def send_addAmazonItem(self, amazonlisted):
3668 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3669 
    args = addAmazonItem_args()
3670 
    args.amazonlisted = amazonlisted
3671 
    args.write(self._oprot)
3672 
    self._oprot.writeMessageEnd()
3673 
    self._oprot.trans.flush()
3674 
 
3675 
  def recv_addAmazonItem(self, ):
3676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3677 
    if mtype == TMessageType.EXCEPTION:
3678 
      x = TApplicationException()
3679 
      x.read(self._iprot)
3680 
      self._iprot.readMessageEnd()
3681 
      raise x
3682 
    result = addAmazonItem_result()
3683 
    result.read(self._iprot)
3684 
    self._iprot.readMessageEnd()
3685 
    return
3686 
 
7291 vikram.rag 3687 
  def getAsinItems(self, ):
3688 
    self.send_getAsinItems()
3689 
    return self.recv_getAsinItems()
7281 kshitij.so 3690 
 
7291 vikram.rag 3691 
  def send_getAsinItems(self, ):
3692 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3693 
    args = getAsinItems_args()
3694 
    args.write(self._oprot)
3695 
    self._oprot.writeMessageEnd()
3696 
    self._oprot.trans.flush()
3697 
 
3698 
  def recv_getAsinItems(self, ):
3699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3700 
    if mtype == TMessageType.EXCEPTION:
3701 
      x = TApplicationException()
3702 
      x.read(self._iprot)
3703 
      self._iprot.readMessageEnd()
3704 
      raise x
3705 
    result = getAsinItems_result()
3706 
    result.read(self._iprot)
3707 
    self._iprot.readMessageEnd()
3708 
    if result.success is not None:
3709 
      return result.success
3710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3711 
 
3712 
  def getAllFbaListedItems(self, ):
3713 
    self.send_getAllFbaListedItems()
3714 
    return self.recv_getAllFbaListedItems()
3715 
 
3716 
  def send_getAllFbaListedItems(self, ):
3717 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3718 
    args = getAllFbaListedItems_args()
3719 
    args.write(self._oprot)
3720 
    self._oprot.writeMessageEnd()
3721 
    self._oprot.trans.flush()
3722 
 
3723 
  def recv_getAllFbaListedItems(self, ):
3724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3725 
    if mtype == TMessageType.EXCEPTION:
3726 
      x = TApplicationException()
3727 
      x.read(self._iprot)
3728 
      self._iprot.readMessageEnd()
3729 
      raise x
3730 
    result = getAllFbaListedItems_result()
3731 
    result.read(self._iprot)
3732 
    self._iprot.readMessageEnd()
3733 
    if result.success is not None:
3734 
      return result.success
3735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3736 
 
3737 
  def getAllNonFbaListedItems(self, ):
3738 
    self.send_getAllNonFbaListedItems()
3739 
    return self.recv_getAllNonFbaListedItems()
3740 
 
3741 
  def send_getAllNonFbaListedItems(self, ):
3742 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3743 
    args = getAllNonFbaListedItems_args()
3744 
    args.write(self._oprot)
3745 
    self._oprot.writeMessageEnd()
3746 
    self._oprot.trans.flush()
3747 
 
3748 
  def recv_getAllNonFbaListedItems(self, ):
3749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3750 
    if mtype == TMessageType.EXCEPTION:
3751 
      x = TApplicationException()
3752 
      x.read(self._iprot)
3753 
      self._iprot.readMessageEnd()
3754 
      raise x
3755 
    result = getAllNonFbaListedItems_result()
3756 
    result.read(self._iprot)
3757 
    self._iprot.readMessageEnd()
3758 
    if result.success is not None:
3759 
      return result.success
3760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3761 
 
3762 
 
5944 mandeep.dh 3763 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3764 
  def __init__(self, handler):
3765 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3766 
    self._processMap["addItem"] = Processor.process_addItem
3767 
    self._processMap["updateItem"] = Processor.process_updateItem
3768 
    self._processMap["isActive"] = Processor.process_isActive
3769 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3770 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3771 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3772 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3773 
    self._processMap["getItem"] = Processor.process_getItem
3774 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3775 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3776 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3777 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3778 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3779 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3780 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3781 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3782 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3783 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3784 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3785 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3786 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3787 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3788 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3789 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3790 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3791 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3792 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3793 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3794 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3795 
    self._processMap["addCategory"] = Processor.process_addCategory
3796 
    self._processMap["getCategory"] = Processor.process_getCategory
3797 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3798 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3799 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3800 
    self._processMap["addTag"] = Processor.process_addTag
3801 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3802 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3803 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3804 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3805 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3806 
    self._processMap["addBanner"] = Processor.process_addBanner
3807 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3808 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3809 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3810 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3811 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3812 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3813 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3814 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3815 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3816 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3817 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3818 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3819 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3820 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3821 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3822 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3823 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3824 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3825 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3826 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3827 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3828 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3829 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3830 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3831 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3832 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3833 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3834 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3835 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3836 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3837 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3838 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3839 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3840 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3841 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3842 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3843 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3844 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3845 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3846 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3847 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3848 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3849 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3850 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3851 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3852 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3853 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3854 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3855 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3856 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3857 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3858 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3859 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3860 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3861 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
5944 mandeep.dh 3862 
 
3863 
  def process(self, iprot, oprot):
3864 
    (name, type, seqid) = iprot.readMessageBegin()
3865 
    if name not in self._processMap:
3866 
      iprot.skip(TType.STRUCT)
3867 
      iprot.readMessageEnd()
3868 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3869 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3870 
      x.write(oprot)
3871 
      oprot.writeMessageEnd()
3872 
      oprot.trans.flush()
3873 
      return
3874 
    else:
3875 
      self._processMap[name](self, seqid, iprot, oprot)
3876 
    return True
3877 
 
3878 
  def process_addItem(self, seqid, iprot, oprot):
3879 
    args = addItem_args()
3880 
    args.read(iprot)
3881 
    iprot.readMessageEnd()
3882 
    result = addItem_result()
3883 
    try:
3884 
      result.success = self._handler.addItem(args.item)
3885 
    except CatalogServiceException, cex:
3886 
      result.cex = cex
3887 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3888 
    result.write(oprot)
3889 
    oprot.writeMessageEnd()
3890 
    oprot.trans.flush()
3891 
 
3892 
  def process_updateItem(self, seqid, iprot, oprot):
3893 
    args = updateItem_args()
3894 
    args.read(iprot)
3895 
    iprot.readMessageEnd()
3896 
    result = updateItem_result()
3897 
    try:
3898 
      result.success = self._handler.updateItem(args.item)
3899 
    except CatalogServiceException, cex:
3900 
      result.cex = cex
3901 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3902 
    result.write(oprot)
3903 
    oprot.writeMessageEnd()
3904 
    oprot.trans.flush()
3905 
 
3906 
  def process_isActive(self, seqid, iprot, oprot):
3907 
    args = isActive_args()
3908 
    args.read(iprot)
3909 
    iprot.readMessageEnd()
3910 
    result = isActive_result()
3911 
    try:
3912 
      result.success = self._handler.isActive(args.itemId)
3913 
    except CatalogServiceException, isex:
3914 
      result.isex = isex
3915 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
3916 
    result.write(oprot)
3917 
    oprot.writeMessageEnd()
3918 
    oprot.trans.flush()
3919 
 
3920 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
3921 
    args = getItemStatusDescription_args()
3922 
    args.read(iprot)
3923 
    iprot.readMessageEnd()
3924 
    result = getItemStatusDescription_result()
3925 
    try:
3926 
      result.success = self._handler.getItemStatusDescription(args.itemId)
3927 
    except CatalogServiceException, isex:
3928 
      result.isex = isex
3929 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
3930 
    result.write(oprot)
3931 
    oprot.writeMessageEnd()
3932 
    oprot.trans.flush()
3933 
 
3934 
  def process_startItemOn(self, seqid, iprot, oprot):
3935 
    args = startItemOn_args()
3936 
    args.read(iprot)
3937 
    iprot.readMessageEnd()
3938 
    result = startItemOn_result()
3939 
    try:
3940 
      self._handler.startItemOn(args.item_id, args.timestamp)
3941 
    except CatalogServiceException, cex:
3942 
      result.cex = cex
3943 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
3944 
    result.write(oprot)
3945 
    oprot.writeMessageEnd()
3946 
    oprot.trans.flush()
3947 
 
3948 
  def process_retireItemOn(self, seqid, iprot, oprot):
3949 
    args = retireItemOn_args()
3950 
    args.read(iprot)
3951 
    iprot.readMessageEnd()
3952 
    result = retireItemOn_result()
3953 
    try:
3954 
      self._handler.retireItemOn(args.item_id, args.timestamp)
3955 
    except CatalogServiceException, cex:
3956 
      result.cex = cex
3957 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
3958 
    result.write(oprot)
3959 
    oprot.writeMessageEnd()
3960 
    oprot.trans.flush()
3961 
 
3962 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3963 
    args = changeItemStatus_args()
3964 
    args.read(iprot)
3965 
    iprot.readMessageEnd()
3966 
    result = changeItemStatus_result()
3967 
    try:
3968 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
3969 
    except CatalogServiceException, cex:
3970 
      result.cex = cex
3971 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3972 
    result.write(oprot)
3973 
    oprot.writeMessageEnd()
3974 
    oprot.trans.flush()
3975 
 
3976 
  def process_getItem(self, seqid, iprot, oprot):
3977 
    args = getItem_args()
3978 
    args.read(iprot)
3979 
    iprot.readMessageEnd()
3980 
    result = getItem_result()
3981 
    try:
3982 
      result.success = self._handler.getItem(args.item_id)
3983 
    except CatalogServiceException, cex:
3984 
      result.cex = cex
3985 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
3986 
    result.write(oprot)
3987 
    oprot.writeMessageEnd()
3988 
    oprot.trans.flush()
3989 
 
3990 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
3991 
    args = getItemsByCatalogId_args()
3992 
    args.read(iprot)
3993 
    iprot.readMessageEnd()
3994 
    result = getItemsByCatalogId_result()
3995 
    try:
3996 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
3997 
    except CatalogServiceException, cex:
3998 
      result.cex = cex
3999 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4000 
    result.write(oprot)
4001 
    oprot.writeMessageEnd()
4002 
    oprot.trans.flush()
4003 
 
4004 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4005 
    args = getValidItemsByCatalogId_args()
4006 
    args.read(iprot)
4007 
    iprot.readMessageEnd()
4008 
    result = getValidItemsByCatalogId_result()
4009 
    try:
4010 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4011 
    except CatalogServiceException, cex:
4012 
      result.cex = cex
4013 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4014 
    result.write(oprot)
4015 
    oprot.writeMessageEnd()
4016 
    oprot.trans.flush()
4017 
 
4018 
  def process_getAllItems(self, seqid, iprot, oprot):
4019 
    args = getAllItems_args()
4020 
    args.read(iprot)
4021 
    iprot.readMessageEnd()
4022 
    result = getAllItems_result()
4023 
    try:
4024 
      result.success = self._handler.getAllItems(args.isActive)
4025 
    except CatalogServiceException, cex:
4026 
      result.cex = cex
4027 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4028 
    result.write(oprot)
4029 
    oprot.writeMessageEnd()
4030 
    oprot.trans.flush()
4031 
 
4032 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4033 
    args = getAllItemsByStatus_args()
4034 
    args.read(iprot)
4035 
    iprot.readMessageEnd()
4036 
    result = getAllItemsByStatus_result()
4037 
    try:
4038 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4039 
    except CatalogServiceException, cex:
4040 
      result.cex = cex
4041 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4042 
    result.write(oprot)
4043 
    oprot.writeMessageEnd()
4044 
    oprot.trans.flush()
4045 
 
4046 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4047 
    args = markItemAsContentComplete_args()
4048 
    args.read(iprot)
4049 
    iprot.readMessageEnd()
4050 
    result = markItemAsContentComplete_result()
4051 
    try:
4052 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4053 
    except CatalogServiceException, cex:
4054 
      result.cex = cex
4055 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4056 
    result.write(oprot)
4057 
    oprot.writeMessageEnd()
4058 
    oprot.trans.flush()
4059 
 
4060 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4061 
    args = getAllItemsInRange_args()
4062 
    args.read(iprot)
4063 
    iprot.readMessageEnd()
4064 
    result = getAllItemsInRange_result()
4065 
    try:
4066 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4067 
    except CatalogServiceException, cex:
4068 
      result.cex = cex
4069 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4070 
    result.write(oprot)
4071 
    oprot.writeMessageEnd()
4072 
    oprot.trans.flush()
4073 
 
4074 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4075 
    args = getAllItemsByStatusInRange_args()
4076 
    args.read(iprot)
4077 
    iprot.readMessageEnd()
4078 
    result = getAllItemsByStatusInRange_result()
4079 
    try:
4080 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4081 
    except CatalogServiceException, cex:
4082 
      result.cex = cex
4083 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4084 
    result.write(oprot)
4085 
    oprot.writeMessageEnd()
4086 
    oprot.trans.flush()
4087 
 
4088 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4089 
    args = getItemCountByStatus_args()
4090 
    args.read(iprot)
4091 
    iprot.readMessageEnd()
4092 
    result = getItemCountByStatus_result()
4093 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4094 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4095 
    result.write(oprot)
4096 
    oprot.writeMessageEnd()
4097 
    oprot.trans.flush()
4098 
 
4099 
  def process_getBestSellers(self, seqid, iprot, oprot):
4100 
    args = getBestSellers_args()
4101 
    args.read(iprot)
4102 
    iprot.readMessageEnd()
4103 
    result = getBestSellers_result()
4104 
    try:
4105 
      result.success = self._handler.getBestSellers()
4106 
    except CatalogServiceException, isex:
4107 
      result.isex = isex
4108 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4109 
    result.write(oprot)
4110 
    oprot.writeMessageEnd()
4111 
    oprot.trans.flush()
4112 
 
4113 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4114 
    args = getBestSellersCatalogIds_args()
4115 
    args.read(iprot)
4116 
    iprot.readMessageEnd()
4117 
    result = getBestSellersCatalogIds_result()
4118 
    try:
4119 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4120 
    except CatalogServiceException, cex:
4121 
      result.cex = cex
4122 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4123 
    result.write(oprot)
4124 
    oprot.writeMessageEnd()
4125 
    oprot.trans.flush()
4126 
 
4127 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4128 
    args = getBestSellersCount_args()
4129 
    args.read(iprot)
4130 
    iprot.readMessageEnd()
4131 
    result = getBestSellersCount_result()
4132 
    try:
4133 
      result.success = self._handler.getBestSellersCount()
4134 
    except CatalogServiceException, cex:
4135 
      result.cex = cex
4136 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4137 
    result.write(oprot)
4138 
    oprot.writeMessageEnd()
4139 
    oprot.trans.flush()
4140 
 
4141 
  def process_getBestDeals(self, seqid, iprot, oprot):
4142 
    args = getBestDeals_args()
4143 
    args.read(iprot)
4144 
    iprot.readMessageEnd()
4145 
    result = getBestDeals_result()
4146 
    try:
4147 
      result.success = self._handler.getBestDeals()
4148 
    except CatalogServiceException, isex:
4149 
      result.isex = isex
4150 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4151 
    result.write(oprot)
4152 
    oprot.writeMessageEnd()
4153 
    oprot.trans.flush()
4154 
 
4155 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4156 
    args = getBestDealsCatalogIds_args()
4157 
    args.read(iprot)
4158 
    iprot.readMessageEnd()
4159 
    result = getBestDealsCatalogIds_result()
4160 
    try:
4161 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4162 
    except CatalogServiceException, cex:
4163 
      result.cex = cex
4164 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4165 
    result.write(oprot)
4166 
    oprot.writeMessageEnd()
4167 
    oprot.trans.flush()
4168 
 
4169 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4170 
    args = getBestDealsCount_args()
4171 
    args.read(iprot)
4172 
    iprot.readMessageEnd()
4173 
    result = getBestDealsCount_result()
4174 
    try:
4175 
      result.success = self._handler.getBestDealsCount()
4176 
    except CatalogServiceException, cex:
4177 
      result.cex = cex
4178 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4179 
    result.write(oprot)
4180 
    oprot.writeMessageEnd()
4181 
    oprot.trans.flush()
4182 
 
4183 
  def process_getComingSoon(self, seqid, iprot, oprot):
4184 
    args = getComingSoon_args()
4185 
    args.read(iprot)
4186 
    iprot.readMessageEnd()
4187 
    result = getComingSoon_result()
4188 
    try:
4189 
      result.success = self._handler.getComingSoon()
4190 
    except CatalogServiceException, isex:
4191 
      result.isex = isex
4192 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4193 
    result.write(oprot)
4194 
    oprot.writeMessageEnd()
4195 
    oprot.trans.flush()
4196 
 
4197 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4198 
    args = getComingSoonCatalogIds_args()
4199 
    args.read(iprot)
4200 
    iprot.readMessageEnd()
4201 
    result = getComingSoonCatalogIds_result()
4202 
    try:
4203 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4204 
    except CatalogServiceException, cex:
4205 
      result.cex = cex
4206 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4207 
    result.write(oprot)
4208 
    oprot.writeMessageEnd()
4209 
    oprot.trans.flush()
4210 
 
4211 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4212 
    args = getComingSoonCount_args()
4213 
    args.read(iprot)
4214 
    iprot.readMessageEnd()
4215 
    result = getComingSoonCount_result()
4216 
    try:
4217 
      result.success = self._handler.getComingSoonCount()
4218 
    except CatalogServiceException, cex:
4219 
      result.cex = cex
4220 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4221 
    result.write(oprot)
4222 
    oprot.writeMessageEnd()
4223 
    oprot.trans.flush()
4224 
 
4225 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4226 
    args = getLatestArrivals_args()
4227 
    args.read(iprot)
4228 
    iprot.readMessageEnd()
4229 
    result = getLatestArrivals_result()
4230 
    try:
4231 
      result.success = self._handler.getLatestArrivals()
4232 
    except CatalogServiceException, isex:
4233 
      result.isex = isex
4234 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4235 
    result.write(oprot)
4236 
    oprot.writeMessageEnd()
4237 
    oprot.trans.flush()
4238 
 
4239 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4240 
    args = getLatestArrivalsCatalogIds_args()
4241 
    args.read(iprot)
4242 
    iprot.readMessageEnd()
4243 
    result = getLatestArrivalsCatalogIds_result()
4244 
    try:
4245 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4246 
    except CatalogServiceException, cex:
4247 
      result.cex = cex
4248 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4249 
    result.write(oprot)
4250 
    oprot.writeMessageEnd()
4251 
    oprot.trans.flush()
4252 
 
4253 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4254 
    args = getLatestArrivalsCount_args()
4255 
    args.read(iprot)
4256 
    iprot.readMessageEnd()
4257 
    result = getLatestArrivalsCount_result()
4258 
    try:
4259 
      result.success = self._handler.getLatestArrivalsCount()
4260 
    except CatalogServiceException, cex:
4261 
      result.cex = cex
4262 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4263 
    result.write(oprot)
4264 
    oprot.writeMessageEnd()
4265 
    oprot.trans.flush()
4266 
 
4267 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4268 
    args = generateNewEntityID_args()
4269 
    args.read(iprot)
4270 
    iprot.readMessageEnd()
4271 
    result = generateNewEntityID_result()
4272 
    result.success = self._handler.generateNewEntityID()
4273 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4274 
    result.write(oprot)
4275 
    oprot.writeMessageEnd()
4276 
    oprot.trans.flush()
4277 
 
4278 
  def process_addCategory(self, seqid, iprot, oprot):
4279 
    args = addCategory_args()
4280 
    args.read(iprot)
4281 
    iprot.readMessageEnd()
4282 
    result = addCategory_result()
4283 
    result.success = self._handler.addCategory(args.category)
4284 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4285 
    result.write(oprot)
4286 
    oprot.writeMessageEnd()
4287 
    oprot.trans.flush()
4288 
 
4289 
  def process_getCategory(self, seqid, iprot, oprot):
4290 
    args = getCategory_args()
4291 
    args.read(iprot)
4292 
    iprot.readMessageEnd()
4293 
    result = getCategory_result()
4294 
    result.success = self._handler.getCategory(args.id)
4295 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4296 
    result.write(oprot)
4297 
    oprot.writeMessageEnd()
4298 
    oprot.trans.flush()
4299 
 
4300 
  def process_getAllCategories(self, seqid, iprot, oprot):
4301 
    args = getAllCategories_args()
4302 
    args.read(iprot)
4303 
    iprot.readMessageEnd()
4304 
    result = getAllCategories_result()
4305 
    result.success = self._handler.getAllCategories()
4306 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4307 
    result.write(oprot)
4308 
    oprot.writeMessageEnd()
4309 
    oprot.trans.flush()
4310 
 
4311 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4312 
    args = getAllSimilarItems_args()
4313 
    args.read(iprot)
4314 
    iprot.readMessageEnd()
4315 
    result = getAllSimilarItems_result()
4316 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4317 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4318 
    result.write(oprot)
4319 
    oprot.writeMessageEnd()
4320 
    oprot.trans.flush()
4321 
 
4322 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4323 
    args = addSimilarItem_args()
4324 
    args.read(iprot)
4325 
    iprot.readMessageEnd()
4326 
    result = addSimilarItem_result()
4327 
    try:
4328 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4329 
    except CatalogServiceException, cex:
4330 
      result.cex = cex
4331 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4332 
    result.write(oprot)
4333 
    oprot.writeMessageEnd()
4334 
    oprot.trans.flush()
4335 
 
6512 kshitij.so 4336 
  def process_addTag(self, seqid, iprot, oprot):
4337 
    args = addTag_args()
4338 
    args.read(iprot)
4339 
    iprot.readMessageEnd()
4340 
    result = addTag_result()
4341 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4342 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4343 
    result.write(oprot)
4344 
    oprot.writeMessageEnd()
4345 
    oprot.trans.flush()
4346 
 
4347 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4348 
    args = deleteEntityTag_args()
4349 
    args.read(iprot)
4350 
    iprot.readMessageEnd()
4351 
    result = deleteEntityTag_result()
4352 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4353 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4354 
    result.write(oprot)
4355 
    oprot.writeMessageEnd()
4356 
    oprot.trans.flush()
4357 
 
4358 
  def process_deleteTag(self, seqid, iprot, oprot):
4359 
    args = deleteTag_args()
4360 
    args.read(iprot)
4361 
    iprot.readMessageEnd()
4362 
    result = deleteTag_result()
4363 
    result.success = self._handler.deleteTag(args.displayName)
4364 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4365 
    result.write(oprot)
4366 
    oprot.writeMessageEnd()
4367 
    oprot.trans.flush()
4368 
 
4369 
  def process_getAllTags(self, seqid, iprot, oprot):
4370 
    args = getAllTags_args()
4371 
    args.read(iprot)
4372 
    iprot.readMessageEnd()
4373 
    result = getAllTags_result()
4374 
    result.success = self._handler.getAllTags()
4375 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4376 
    result.write(oprot)
4377 
    oprot.writeMessageEnd()
4378 
    oprot.trans.flush()
4379 
 
4380 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4381 
    args = getAllEntitiesByTagName_args()
4382 
    args.read(iprot)
4383 
    iprot.readMessageEnd()
4384 
    result = getAllEntitiesByTagName_result()
4385 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4386 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4387 
    result.write(oprot)
4388 
    oprot.writeMessageEnd()
4389 
    oprot.trans.flush()
4390 
 
6845 amit.gupta 4391 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4392 
    args = getAllEntityTags_args()
4393 
    args.read(iprot)
4394 
    iprot.readMessageEnd()
4395 
    result = getAllEntityTags_result()
4396 
    result.success = self._handler.getAllEntityTags()
4397 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4398 
    result.write(oprot)
4399 
    oprot.writeMessageEnd()
4400 
    oprot.trans.flush()
4401 
 
6850 kshitij.so 4402 
  def process_addBanner(self, seqid, iprot, oprot):
4403 
    args = addBanner_args()
4404 
    args.read(iprot)
4405 
    iprot.readMessageEnd()
4406 
    result = addBanner_result()
4407 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4408 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4409 
    result.write(oprot)
4410 
    oprot.writeMessageEnd()
4411 
    oprot.trans.flush()
4412 
 
4413 
  def process_getAllBanners(self, seqid, iprot, oprot):
4414 
    args = getAllBanners_args()
4415 
    args.read(iprot)
4416 
    iprot.readMessageEnd()
4417 
    result = getAllBanners_result()
4418 
    result.success = self._handler.getAllBanners()
4419 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4420 
    result.write(oprot)
4421 
    oprot.writeMessageEnd()
4422 
    oprot.trans.flush()
4423 
 
4424 
  def process_deleteBanner(self, seqid, iprot, oprot):
4425 
    args = deleteBanner_args()
4426 
    args.read(iprot)
4427 
    iprot.readMessageEnd()
4428 
    result = deleteBanner_result()
4429 
    result.success = self._handler.deleteBanner(args.bannerName)
4430 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4431 
    result.write(oprot)
4432 
    oprot.writeMessageEnd()
4433 
    oprot.trans.flush()
4434 
 
4435 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4436 
    args = getBannerDetails_args()
4437 
    args.read(iprot)
4438 
    iprot.readMessageEnd()
4439 
    result = getBannerDetails_result()
4440 
    result.success = self._handler.getBannerDetails(args.bannerName)
4441 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4442 
    result.write(oprot)
4443 
    oprot.writeMessageEnd()
4444 
    oprot.trans.flush()
4445 
 
4446 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4447 
    args = getActiveBanners_args()
4448 
    args.read(iprot)
4449 
    iprot.readMessageEnd()
4450 
    result = getActiveBanners_result()
4451 
    result.success = self._handler.getActiveBanners()
4452 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4453 
    result.write(oprot)
4454 
    oprot.writeMessageEnd()
4455 
    oprot.trans.flush()
4456 
 
6849 kshitij.so 4457 
  def process_addBannerMap(self, seqid, iprot, oprot):
4458 
    args = addBannerMap_args()
4459 
    args.read(iprot)
4460 
    iprot.readMessageEnd()
4461 
    result = addBannerMap_result()
4462 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4463 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4464 
    result.write(oprot)
4465 
    oprot.writeMessageEnd()
4466 
    oprot.trans.flush()
4467 
 
4468 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4469 
    args = deleteBannerMap_args()
4470 
    args.read(iprot)
4471 
    iprot.readMessageEnd()
4472 
    result = deleteBannerMap_result()
4473 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4474 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4475 
    result.write(oprot)
4476 
    oprot.writeMessageEnd()
4477 
    oprot.trans.flush()
4478 
 
4479 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4480 
    args = getBannerMapDetails_args()
4481 
    args.read(iprot)
4482 
    iprot.readMessageEnd()
4483 
    result = getBannerMapDetails_result()
4484 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4485 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4486 
    result.write(oprot)
4487 
    oprot.writeMessageEnd()
4488 
    oprot.trans.flush()
4489 
 
5944 mandeep.dh 4490 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4491 
    args = deleteSimilarItem_args()
4492 
    args.read(iprot)
4493 
    iprot.readMessageEnd()
4494 
    result = deleteSimilarItem_result()
4495 
    try:
4496 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4497 
    except CatalogServiceException, cex:
4498 
      result.cex = cex
4499 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4500 
    result.write(oprot)
4501 
    oprot.writeMessageEnd()
4502 
    oprot.trans.flush()
4503 
 
4504 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4505 
    args = checkSimilarItem_args()
4506 
    args.read(iprot)
4507 
    iprot.readMessageEnd()
4508 
    result = checkSimilarItem_result()
4509 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4510 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4511 
    result.write(oprot)
4512 
    oprot.writeMessageEnd()
4513 
    oprot.trans.flush()
4514 
 
4515 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4516 
    args = validateRiskyStatus_args()
4517 
    args.read(iprot)
4518 
    iprot.readMessageEnd()
4519 
    result = validateRiskyStatus_result()
4520 
    self._handler.validateRiskyStatus(args.itemId)
4521 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4522 
    result.write(oprot)
4523 
    oprot.writeMessageEnd()
4524 
    oprot.trans.flush()
4525 
 
4526 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4527 
    args = changeItemRiskyFlag_args()
4528 
    args.read(iprot)
4529 
    iprot.readMessageEnd()
4530 
    result = changeItemRiskyFlag_result()
4531 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4532 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4533 
    result.write(oprot)
4534 
    oprot.writeMessageEnd()
4535 
    oprot.trans.flush()
4536 
 
4537 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4538 
    args = getItemsByRiskyFlag_args()
4539 
    args.read(iprot)
4540 
    iprot.readMessageEnd()
4541 
    result = getItemsByRiskyFlag_result()
4542 
    result.success = self._handler.getItemsByRiskyFlag()
4543 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4544 
    result.write(oprot)
4545 
    oprot.writeMessageEnd()
4546 
    oprot.trans.flush()
4547 
 
4548 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4549 
    args = getItemsForMasterSheet_args()
4550 
    args.read(iprot)
4551 
    iprot.readMessageEnd()
4552 
    result = getItemsForMasterSheet_result()
4553 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4554 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4555 
    result.write(oprot)
4556 
    oprot.writeMessageEnd()
4557 
    oprot.trans.flush()
4558 
 
4559 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4560 
    args = getSimilarItemsCatalogIds_args()
4561 
    args.read(iprot)
4562 
    iprot.readMessageEnd()
4563 
    result = getSimilarItemsCatalogIds_result()
4564 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4565 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4566 
    result.write(oprot)
4567 
    oprot.writeMessageEnd()
4568 
    oprot.trans.flush()
4569 
 
4570 
  def process_addProductNotification(self, seqid, iprot, oprot):
4571 
    args = addProductNotification_args()
4572 
    args.read(iprot)
4573 
    iprot.readMessageEnd()
4574 
    result = addProductNotification_result()
4575 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4576 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4577 
    result.write(oprot)
4578 
    oprot.writeMessageEnd()
4579 
    oprot.trans.flush()
4580 
 
4581 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4582 
    args = sendProductNotifications_args()
4583 
    args.read(iprot)
4584 
    iprot.readMessageEnd()
4585 
    result = sendProductNotifications_result()
4586 
    result.success = self._handler.sendProductNotifications()
4587 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4588 
    result.write(oprot)
4589 
    oprot.writeMessageEnd()
4590 
    oprot.trans.flush()
4591 
 
4592 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4593 
    args = getAllBrandsByCategory_args()
4594 
    args.read(iprot)
4595 
    iprot.readMessageEnd()
4596 
    result = getAllBrandsByCategory_result()
4597 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4598 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4599 
    result.write(oprot)
4600 
    oprot.writeMessageEnd()
4601 
    oprot.trans.flush()
4602 
 
4603 
  def process_getAllBrands(self, seqid, iprot, oprot):
4604 
    args = getAllBrands_args()
4605 
    args.read(iprot)
4606 
    iprot.readMessageEnd()
4607 
    result = getAllBrands_result()
4608 
    result.success = self._handler.getAllBrands()
4609 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4610 
    result.write(oprot)
4611 
    oprot.writeMessageEnd()
4612 
    oprot.trans.flush()
4613 
 
4614 
  def process_getAllSources(self, seqid, iprot, oprot):
4615 
    args = getAllSources_args()
4616 
    args.read(iprot)
4617 
    iprot.readMessageEnd()
4618 
    result = getAllSources_result()
4619 
    result.success = self._handler.getAllSources()
4620 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4621 
    result.write(oprot)
4622 
    oprot.writeMessageEnd()
4623 
    oprot.trans.flush()
4624 
 
4625 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4626 
    args = getItemPricingBySource_args()
4627 
    args.read(iprot)
4628 
    iprot.readMessageEnd()
4629 
    result = getItemPricingBySource_result()
4630 
    try:
4631 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4632 
    except CatalogServiceException, cex:
4633 
      result.cex = cex
4634 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4635 
    result.write(oprot)
4636 
    oprot.writeMessageEnd()
4637 
    oprot.trans.flush()
4638 
 
4639 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4640 
    args = addSourceItemPricing_args()
4641 
    args.read(iprot)
4642 
    iprot.readMessageEnd()
4643 
    result = addSourceItemPricing_result()
4644 
    try:
4645 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4646 
    except CatalogServiceException, cex:
4647 
      result.cex = cex
4648 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4649 
    result.write(oprot)
4650 
    oprot.writeMessageEnd()
4651 
    oprot.trans.flush()
4652 
 
4653 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4654 
    args = getAllSourcePricing_args()
4655 
    args.read(iprot)
4656 
    iprot.readMessageEnd()
4657 
    result = getAllSourcePricing_result()
4658 
    try:
4659 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4660 
    except CatalogServiceException, cex:
4661 
      result.cex = cex
4662 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4663 
    result.write(oprot)
4664 
    oprot.writeMessageEnd()
4665 
    oprot.trans.flush()
4666 
 
4667 
  def process_getItemForSource(self, seqid, iprot, oprot):
4668 
    args = getItemForSource_args()
4669 
    args.read(iprot)
4670 
    iprot.readMessageEnd()
4671 
    result = getItemForSource_result()
4672 
    try:
4673 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4674 
    except CatalogServiceException, cex:
4675 
      result.cex = cex
4676 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4677 
    result.write(oprot)
4678 
    oprot.writeMessageEnd()
4679 
    oprot.trans.flush()
4680 
 
4681 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4682 
    args = searchItemsInRange_args()
4683 
    args.read(iprot)
4684 
    iprot.readMessageEnd()
4685 
    result = searchItemsInRange_result()
4686 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4687 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4688 
    result.write(oprot)
4689 
    oprot.writeMessageEnd()
4690 
    oprot.trans.flush()
4691 
 
4692 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4693 
    args = getSearchResultCount_args()
4694 
    args.read(iprot)
4695 
    iprot.readMessageEnd()
4696 
    result = getSearchResultCount_result()
4697 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4698 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4699 
    result.write(oprot)
4700 
    oprot.writeMessageEnd()
4701 
    oprot.trans.flush()
4702 
 
4703 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4704 
    args = getProductNotifications_args()
4705 
    args.read(iprot)
4706 
    iprot.readMessageEnd()
4707 
    result = getProductNotifications_result()
4708 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4709 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4710 
    result.write(oprot)
4711 
    oprot.writeMessageEnd()
4712 
    oprot.trans.flush()
4713 
 
4714 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4715 
    args = getProductNotificationRequestCount_args()
4716 
    args.read(iprot)
4717 
    iprot.readMessageEnd()
4718 
    result = getProductNotificationRequestCount_result()
4719 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4720 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4721 
    result.write(oprot)
4722 
    oprot.writeMessageEnd()
4723 
    oprot.trans.flush()
4724 
 
4725 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4726 
    args = addAuthorizationLog_args()
4727 
    args.read(iprot)
4728 
    iprot.readMessageEnd()
4729 
    result = addAuthorizationLog_result()
4730 
    try:
4731 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4732 
    except CatalogServiceException, cex:
4733 
      result.cex = cex
4734 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4735 
    result.write(oprot)
4736 
    oprot.writeMessageEnd()
4737 
    oprot.trans.flush()
4738 
 
4739 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4740 
    args = addupdateVoucherForItem_args()
4741 
    args.read(iprot)
4742 
    iprot.readMessageEnd()
4743 
    result = addupdateVoucherForItem_result()
4744 
    try:
4745 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4746 
    except CatalogServiceException, cex:
4747 
      result.cex = cex
4748 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4749 
    result.write(oprot)
4750 
    oprot.writeMessageEnd()
4751 
    oprot.trans.flush()
4752 
 
4753 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4754 
    args = deleteVoucherForItem_args()
4755 
    args.read(iprot)
4756 
    iprot.readMessageEnd()
4757 
    result = deleteVoucherForItem_result()
4758 
    try:
4759 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4760 
    except CatalogServiceException, cex:
4761 
      result.cex = cex
4762 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4763 
    result.write(oprot)
4764 
    oprot.writeMessageEnd()
4765 
    oprot.trans.flush()
4766 
 
4767 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4768 
    args = getVoucherAmount_args()
4769 
    args.read(iprot)
4770 
    iprot.readMessageEnd()
4771 
    result = getVoucherAmount_result()
4772 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4773 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4774 
    result.write(oprot)
4775 
    oprot.writeMessageEnd()
4776 
    oprot.trans.flush()
4777 
 
4778 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4779 
    args = getAllItemVouchers_args()
4780 
    args.read(iprot)
4781 
    iprot.readMessageEnd()
4782 
    result = getAllItemVouchers_result()
4783 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4784 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4785 
    result.write(oprot)
4786 
    oprot.writeMessageEnd()
4787 
    oprot.trans.flush()
4788 
 
4789 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4790 
    args = isValidCatalogItemId_args()
4791 
    args.read(iprot)
4792 
    iprot.readMessageEnd()
4793 
    result = isValidCatalogItemId_result()
4794 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4795 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4796 
    result.write(oprot)
4797 
    oprot.writeMessageEnd()
4798 
    oprot.trans.flush()
4799 
 
6039 amit.gupta 4800 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4801 
    args = getVatPercentageForItem_args()
4802 
    args.read(iprot)
4803 
    iprot.readMessageEnd()
4804 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4805 
    try:
4806 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4807 
    except CatalogServiceException, cex:
4808 
      result.cex = cex
6039 amit.gupta 4809 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4810 
    result.write(oprot)
4811 
    oprot.writeMessageEnd()
4812 
    oprot.trans.flush()
5944 mandeep.dh 4813 
 
6039 amit.gupta 4814 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4815 
    args = getVatAmountForItem_args()
4816 
    args.read(iprot)
4817 
    iprot.readMessageEnd()
4818 
    result = getVatAmountForItem_result()
4819 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4820 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4821 
    result.write(oprot)
4822 
    oprot.writeMessageEnd()
4823 
    oprot.trans.flush()
4824 
 
6531 vikram.rag 4825 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4826 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4827 
    args.read(iprot)
4828 
    iprot.readMessageEnd()
4829 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4830 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4831 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4832 
    result.write(oprot)
4833 
    oprot.writeMessageEnd()
4834 
    oprot.trans.flush()
6039 amit.gupta 4835 
 
6821 amar.kumar 4836 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4837 
    args = getAllAliveItems_args()
4838 
    args.read(iprot)
4839 
    iprot.readMessageEnd()
4840 
    result = getAllAliveItems_result()
4841 
    result.success = self._handler.getAllAliveItems()
4842 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4843 
    result.write(oprot)
4844 
    oprot.writeMessageEnd()
4845 
    oprot.trans.flush()
4846 
 
6805 anupam.sin 4847 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4848 
    args = getInsuranceAmount_args()
4849 
    args.read(iprot)
4850 
    iprot.readMessageEnd()
4851 
    result = getInsuranceAmount_result()
6921 anupam.sin 4852 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4853 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4854 
    result.write(oprot)
4855 
    oprot.writeMessageEnd()
4856 
    oprot.trans.flush()
6531 vikram.rag 4857 
 
6805 anupam.sin 4858 
  def process_getInsurer(self, seqid, iprot, oprot):
4859 
    args = getInsurer_args()
4860 
    args.read(iprot)
4861 
    iprot.readMessageEnd()
4862 
    result = getInsurer_result()
4863 
    result.success = self._handler.getInsurer(args.insurerId)
4864 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4865 
    result.write(oprot)
4866 
    oprot.writeMessageEnd()
4867 
    oprot.trans.flush()
4868 
 
6838 vikram.rag 4869 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4870 
    args = getAllInsurers_args()
4871 
    args.read(iprot)
4872 
    iprot.readMessageEnd()
4873 
    result = getAllInsurers_result()
4874 
    result.success = self._handler.getAllInsurers()
4875 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4876 
    result.write(oprot)
4877 
    oprot.writeMessageEnd()
4878 
    oprot.trans.flush()
6805 anupam.sin 4879 
 
6962 rajveer 4880 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4881 
    args = updateInsuranceDeclaredAmount_args()
4882 
    args.read(iprot)
4883 
    iprot.readMessageEnd()
4884 
    result = updateInsuranceDeclaredAmount_result()
4885 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4886 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4887 
    result.write(oprot)
4888 
    oprot.writeMessageEnd()
4889 
    oprot.trans.flush()
6838 vikram.rag 4890 
 
7190 amar.kumar 4891 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4892 
    args = getFreebieForItem_args()
4893 
    args.read(iprot)
4894 
    iprot.readMessageEnd()
4895 
    result = getFreebieForItem_result()
4896 
    result.success = self._handler.getFreebieForItem(args.itemId)
4897 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
4898 
    result.write(oprot)
4899 
    oprot.writeMessageEnd()
4900 
    oprot.trans.flush()
6962 rajveer 4901 
 
7190 amar.kumar 4902 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
4903 
    args = addOrUpdateFreebieForItem_args()
4904 
    args.read(iprot)
4905 
    iprot.readMessageEnd()
4906 
    result = addOrUpdateFreebieForItem_result()
4907 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
4908 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
4909 
    result.write(oprot)
4910 
    oprot.writeMessageEnd()
4911 
    oprot.trans.flush()
4912 
 
7272 amit.gupta 4913 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
4914 
    args = addOrUpdateBrandInfo_args()
4915 
    args.read(iprot)
4916 
    iprot.readMessageEnd()
4917 
    result = addOrUpdateBrandInfo_result()
4918 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
4919 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
4920 
    result.write(oprot)
4921 
    oprot.writeMessageEnd()
4922 
    oprot.trans.flush()
4923 
 
4924 
  def process_getBrandInfo(self, seqid, iprot, oprot):
4925 
    args = getBrandInfo_args()
4926 
    args.read(iprot)
4927 
    iprot.readMessageEnd()
4928 
    result = getBrandInfo_result()
4929 
    result.success = self._handler.getBrandInfo()
4930 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
4931 
    result.write(oprot)
4932 
    oprot.writeMessageEnd()
4933 
    oprot.trans.flush()
4934 
 
7256 rajveer 4935 
  def process_getStorePricing(self, seqid, iprot, oprot):
4936 
    args = getStorePricing_args()
4937 
    args.read(iprot)
4938 
    iprot.readMessageEnd()
4939 
    result = getStorePricing_result()
4940 
    result.success = self._handler.getStorePricing(args.itemId)
4941 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
4942 
    result.write(oprot)
4943 
    oprot.writeMessageEnd()
4944 
    oprot.trans.flush()
7190 amar.kumar 4945 
 
7306 rajveer 4946 
  def process_getStorePricings(self, seqid, iprot, oprot):
4947 
    args = getStorePricings_args()
4948 
    args.read(iprot)
4949 
    iprot.readMessageEnd()
4950 
    result = getStorePricings_result()
4951 
    result.success = self._handler.getStorePricings(args.itemIds)
4952 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
4953 
    result.write(oprot)
4954 
    oprot.writeMessageEnd()
4955 
    oprot.trans.flush()
4956 
 
7265 rajveer 4957 
  def process_updateStorePricing(self, seqid, iprot, oprot):
4958 
    args = updateStorePricing_args()
4959 
    args.read(iprot)
4960 
    iprot.readMessageEnd()
4961 
    result = updateStorePricing_result()
4962 
    self._handler.updateStorePricing(args.sp)
4963 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
4964 
    result.write(oprot)
4965 
    oprot.writeMessageEnd()
4966 
    oprot.trans.flush()
7256 rajveer 4967 
 
7281 kshitij.so 4968 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
4969 
    args = getAllAmazonListedItems_args()
4970 
    args.read(iprot)
4971 
    iprot.readMessageEnd()
4972 
    result = getAllAmazonListedItems_result()
4973 
    result.success = self._handler.getAllAmazonListedItems()
4974 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
4975 
    result.write(oprot)
4976 
    oprot.writeMessageEnd()
4977 
    oprot.trans.flush()
7265 rajveer 4978 
 
7281 kshitij.so 4979 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
4980 
    args = getAmazonItemDetails_args()
4981 
    args.read(iprot)
4982 
    iprot.readMessageEnd()
4983 
    result = getAmazonItemDetails_result()
4984 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
4985 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
4986 
    result.write(oprot)
4987 
    oprot.writeMessageEnd()
4988 
    oprot.trans.flush()
4989 
 
4990 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
4991 
    args = updateAmazonItemDetails_args()
4992 
    args.read(iprot)
4993 
    iprot.readMessageEnd()
4994 
    result = updateAmazonItemDetails_result()
4995 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride)
4996 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
4997 
    result.write(oprot)
4998 
    oprot.writeMessageEnd()
4999 
    oprot.trans.flush()
5000 
 
5001 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5002 
    args = addAmazonItem_args()
5003 
    args.read(iprot)
5004 
    iprot.readMessageEnd()
5005 
    result = addAmazonItem_result()
5006 
    self._handler.addAmazonItem(args.amazonlisted)
5007 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5008 
    result.write(oprot)
5009 
    oprot.writeMessageEnd()
5010 
    oprot.trans.flush()
5011 
 
7291 vikram.rag 5012 
  def process_getAsinItems(self, seqid, iprot, oprot):
5013 
    args = getAsinItems_args()
5014 
    args.read(iprot)
5015 
    iprot.readMessageEnd()
5016 
    result = getAsinItems_result()
5017 
    result.success = self._handler.getAsinItems()
5018 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5019 
    result.write(oprot)
5020 
    oprot.writeMessageEnd()
5021 
    oprot.trans.flush()
7281 kshitij.so 5022 
 
7291 vikram.rag 5023 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5024 
    args = getAllFbaListedItems_args()
5025 
    args.read(iprot)
5026 
    iprot.readMessageEnd()
5027 
    result = getAllFbaListedItems_result()
5028 
    result.success = self._handler.getAllFbaListedItems()
5029 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5030 
    result.write(oprot)
5031 
    oprot.writeMessageEnd()
5032 
    oprot.trans.flush()
5033 
 
5034 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5035 
    args = getAllNonFbaListedItems_args()
5036 
    args.read(iprot)
5037 
    iprot.readMessageEnd()
5038 
    result = getAllNonFbaListedItems_result()
5039 
    result.success = self._handler.getAllNonFbaListedItems()
5040 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5041 
    result.write(oprot)
5042 
    oprot.writeMessageEnd()
5043 
    oprot.trans.flush()
5044 
 
5045 
 
5944 mandeep.dh 5046 
# HELPER FUNCTIONS AND STRUCTURES
5047 
 
5048 
class addItem_args:
5049 
  """
5050 
  Attributes:
5051 
   - item
5052 
  """
5053 
 
5054 
  thrift_spec = (
5055 
    None, # 0
5056 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5057 
  )
5058 
 
5059 
  def __init__(self, item=None,):
5060 
    self.item = item
5061 
 
5062 
  def read(self, iprot):
5063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5065 
      return
5066 
    iprot.readStructBegin()
5067 
    while True:
5068 
      (fname, ftype, fid) = iprot.readFieldBegin()
5069 
      if ftype == TType.STOP:
5070 
        break
5071 
      if fid == 1:
5072 
        if ftype == TType.STRUCT:
5073 
          self.item = Item()
5074 
          self.item.read(iprot)
5075 
        else:
5076 
          iprot.skip(ftype)
5077 
      else:
5078 
        iprot.skip(ftype)
5079 
      iprot.readFieldEnd()
5080 
    iprot.readStructEnd()
5081 
 
5082 
  def write(self, oprot):
5083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5085 
      return
5086 
    oprot.writeStructBegin('addItem_args')
5087 
    if self.item is not None:
5088 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5089 
      self.item.write(oprot)
5090 
      oprot.writeFieldEnd()
5091 
    oprot.writeFieldStop()
5092 
    oprot.writeStructEnd()
5093 
 
5094 
  def validate(self):
5095 
    return
5096 
 
5097 
 
5098 
  def __repr__(self):
5099 
    L = ['%s=%r' % (key, value)
5100 
      for key, value in self.__dict__.iteritems()]
5101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5102 
 
5103 
  def __eq__(self, other):
5104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5105 
 
5106 
  def __ne__(self, other):
5107 
    return not (self == other)
5108 
 
5109 
class addItem_result:
5110 
  """
5111 
  Attributes:
5112 
   - success
5113 
   - cex
5114 
  """
5115 
 
5116 
  thrift_spec = (
5117 
    (0, TType.I64, 'success', None, None, ), # 0
5118 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5119 
  )
5120 
 
5121 
  def __init__(self, success=None, cex=None,):
5122 
    self.success = success
5123 
    self.cex = cex
5124 
 
5125 
  def read(self, iprot):
5126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5128 
      return
5129 
    iprot.readStructBegin()
5130 
    while True:
5131 
      (fname, ftype, fid) = iprot.readFieldBegin()
5132 
      if ftype == TType.STOP:
5133 
        break
5134 
      if fid == 0:
5135 
        if ftype == TType.I64:
5136 
          self.success = iprot.readI64();
5137 
        else:
5138 
          iprot.skip(ftype)
5139 
      elif fid == 1:
5140 
        if ftype == TType.STRUCT:
5141 
          self.cex = CatalogServiceException()
5142 
          self.cex.read(iprot)
5143 
        else:
5144 
          iprot.skip(ftype)
5145 
      else:
5146 
        iprot.skip(ftype)
5147 
      iprot.readFieldEnd()
5148 
    iprot.readStructEnd()
5149 
 
5150 
  def write(self, oprot):
5151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5153 
      return
5154 
    oprot.writeStructBegin('addItem_result')
5155 
    if self.success is not None:
5156 
      oprot.writeFieldBegin('success', TType.I64, 0)
5157 
      oprot.writeI64(self.success)
5158 
      oprot.writeFieldEnd()
5159 
    if self.cex is not None:
5160 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5161 
      self.cex.write(oprot)
5162 
      oprot.writeFieldEnd()
5163 
    oprot.writeFieldStop()
5164 
    oprot.writeStructEnd()
5165 
 
5166 
  def validate(self):
5167 
    return
5168 
 
5169 
 
5170 
  def __repr__(self):
5171 
    L = ['%s=%r' % (key, value)
5172 
      for key, value in self.__dict__.iteritems()]
5173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5174 
 
5175 
  def __eq__(self, other):
5176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5177 
 
5178 
  def __ne__(self, other):
5179 
    return not (self == other)
5180 
 
5181 
class updateItem_args:
5182 
  """
5183 
  Attributes:
5184 
   - item
5185 
  """
5186 
 
5187 
  thrift_spec = (
5188 
    None, # 0
5189 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5190 
  )
5191 
 
5192 
  def __init__(self, item=None,):
5193 
    self.item = item
5194 
 
5195 
  def read(self, iprot):
5196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5198 
      return
5199 
    iprot.readStructBegin()
5200 
    while True:
5201 
      (fname, ftype, fid) = iprot.readFieldBegin()
5202 
      if ftype == TType.STOP:
5203 
        break
5204 
      if fid == 1:
5205 
        if ftype == TType.STRUCT:
5206 
          self.item = Item()
5207 
          self.item.read(iprot)
5208 
        else:
5209 
          iprot.skip(ftype)
5210 
      else:
5211 
        iprot.skip(ftype)
5212 
      iprot.readFieldEnd()
5213 
    iprot.readStructEnd()
5214 
 
5215 
  def write(self, oprot):
5216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5218 
      return
5219 
    oprot.writeStructBegin('updateItem_args')
5220 
    if self.item is not None:
5221 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5222 
      self.item.write(oprot)
5223 
      oprot.writeFieldEnd()
5224 
    oprot.writeFieldStop()
5225 
    oprot.writeStructEnd()
5226 
 
5227 
  def validate(self):
5228 
    return
5229 
 
5230 
 
5231 
  def __repr__(self):
5232 
    L = ['%s=%r' % (key, value)
5233 
      for key, value in self.__dict__.iteritems()]
5234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5235 
 
5236 
  def __eq__(self, other):
5237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5238 
 
5239 
  def __ne__(self, other):
5240 
    return not (self == other)
5241 
 
5242 
class updateItem_result:
5243 
  """
5244 
  Attributes:
5245 
   - success
5246 
   - cex
5247 
  """
5248 
 
5249 
  thrift_spec = (
5250 
    (0, TType.I64, 'success', None, None, ), # 0
5251 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5252 
  )
5253 
 
5254 
  def __init__(self, success=None, cex=None,):
5255 
    self.success = success
5256 
    self.cex = cex
5257 
 
5258 
  def read(self, iprot):
5259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5261 
      return
5262 
    iprot.readStructBegin()
5263 
    while True:
5264 
      (fname, ftype, fid) = iprot.readFieldBegin()
5265 
      if ftype == TType.STOP:
5266 
        break
5267 
      if fid == 0:
5268 
        if ftype == TType.I64:
5269 
          self.success = iprot.readI64();
5270 
        else:
5271 
          iprot.skip(ftype)
5272 
      elif fid == 1:
5273 
        if ftype == TType.STRUCT:
5274 
          self.cex = CatalogServiceException()
5275 
          self.cex.read(iprot)
5276 
        else:
5277 
          iprot.skip(ftype)
5278 
      else:
5279 
        iprot.skip(ftype)
5280 
      iprot.readFieldEnd()
5281 
    iprot.readStructEnd()
5282 
 
5283 
  def write(self, oprot):
5284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5286 
      return
5287 
    oprot.writeStructBegin('updateItem_result')
5288 
    if self.success is not None:
5289 
      oprot.writeFieldBegin('success', TType.I64, 0)
5290 
      oprot.writeI64(self.success)
5291 
      oprot.writeFieldEnd()
5292 
    if self.cex is not None:
5293 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5294 
      self.cex.write(oprot)
5295 
      oprot.writeFieldEnd()
5296 
    oprot.writeFieldStop()
5297 
    oprot.writeStructEnd()
5298 
 
5299 
  def validate(self):
5300 
    return
5301 
 
5302 
 
5303 
  def __repr__(self):
5304 
    L = ['%s=%r' % (key, value)
5305 
      for key, value in self.__dict__.iteritems()]
5306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5307 
 
5308 
  def __eq__(self, other):
5309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5310 
 
5311 
  def __ne__(self, other):
5312 
    return not (self == other)
5313 
 
5314 
class isActive_args:
5315 
  """
5316 
  Attributes:
5317 
   - itemId
5318 
  """
5319 
 
5320 
  thrift_spec = (
5321 
    None, # 0
5322 
    (1, TType.I64, 'itemId', None, None, ), # 1
5323 
  )
5324 
 
5325 
  def __init__(self, itemId=None,):
5326 
    self.itemId = itemId
5327 
 
5328 
  def read(self, iprot):
5329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5331 
      return
5332 
    iprot.readStructBegin()
5333 
    while True:
5334 
      (fname, ftype, fid) = iprot.readFieldBegin()
5335 
      if ftype == TType.STOP:
5336 
        break
5337 
      if fid == 1:
5338 
        if ftype == TType.I64:
5339 
          self.itemId = iprot.readI64();
5340 
        else:
5341 
          iprot.skip(ftype)
5342 
      else:
5343 
        iprot.skip(ftype)
5344 
      iprot.readFieldEnd()
5345 
    iprot.readStructEnd()
5346 
 
5347 
  def write(self, oprot):
5348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5350 
      return
5351 
    oprot.writeStructBegin('isActive_args')
5352 
    if self.itemId is not None:
5353 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5354 
      oprot.writeI64(self.itemId)
5355 
      oprot.writeFieldEnd()
5356 
    oprot.writeFieldStop()
5357 
    oprot.writeStructEnd()
5358 
 
5359 
  def validate(self):
5360 
    return
5361 
 
5362 
 
5363 
  def __repr__(self):
5364 
    L = ['%s=%r' % (key, value)
5365 
      for key, value in self.__dict__.iteritems()]
5366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5367 
 
5368 
  def __eq__(self, other):
5369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5370 
 
5371 
  def __ne__(self, other):
5372 
    return not (self == other)
5373 
 
5374 
class isActive_result:
5375 
  """
5376 
  Attributes:
5377 
   - success
5378 
   - isex
5379 
  """
5380 
 
5381 
  thrift_spec = (
5382 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5383 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5384 
  )
5385 
 
5386 
  def __init__(self, success=None, isex=None,):
5387 
    self.success = success
5388 
    self.isex = isex
5389 
 
5390 
  def read(self, iprot):
5391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5393 
      return
5394 
    iprot.readStructBegin()
5395 
    while True:
5396 
      (fname, ftype, fid) = iprot.readFieldBegin()
5397 
      if ftype == TType.STOP:
5398 
        break
5399 
      if fid == 0:
5400 
        if ftype == TType.STRUCT:
5401 
          self.success = ItemShippingInfo()
5402 
          self.success.read(iprot)
5403 
        else:
5404 
          iprot.skip(ftype)
5405 
      elif fid == 1:
5406 
        if ftype == TType.STRUCT:
5407 
          self.isex = CatalogServiceException()
5408 
          self.isex.read(iprot)
5409 
        else:
5410 
          iprot.skip(ftype)
5411 
      else:
5412 
        iprot.skip(ftype)
5413 
      iprot.readFieldEnd()
5414 
    iprot.readStructEnd()
5415 
 
5416 
  def write(self, oprot):
5417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5419 
      return
5420 
    oprot.writeStructBegin('isActive_result')
5421 
    if self.success is not None:
5422 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5423 
      self.success.write(oprot)
5424 
      oprot.writeFieldEnd()
5425 
    if self.isex is not None:
5426 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5427 
      self.isex.write(oprot)
5428 
      oprot.writeFieldEnd()
5429 
    oprot.writeFieldStop()
5430 
    oprot.writeStructEnd()
5431 
 
5432 
  def validate(self):
5433 
    return
5434 
 
5435 
 
5436 
  def __repr__(self):
5437 
    L = ['%s=%r' % (key, value)
5438 
      for key, value in self.__dict__.iteritems()]
5439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5440 
 
5441 
  def __eq__(self, other):
5442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5443 
 
5444 
  def __ne__(self, other):
5445 
    return not (self == other)
5446 
 
5447 
class getItemStatusDescription_args:
5448 
  """
5449 
  Attributes:
5450 
   - itemId
5451 
  """
5452 
 
5453 
  thrift_spec = (
5454 
    None, # 0
5455 
    (1, TType.I64, 'itemId', None, None, ), # 1
5456 
  )
5457 
 
5458 
  def __init__(self, itemId=None,):
5459 
    self.itemId = itemId
5460 
 
5461 
  def read(self, iprot):
5462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5464 
      return
5465 
    iprot.readStructBegin()
5466 
    while True:
5467 
      (fname, ftype, fid) = iprot.readFieldBegin()
5468 
      if ftype == TType.STOP:
5469 
        break
5470 
      if fid == 1:
5471 
        if ftype == TType.I64:
5472 
          self.itemId = iprot.readI64();
5473 
        else:
5474 
          iprot.skip(ftype)
5475 
      else:
5476 
        iprot.skip(ftype)
5477 
      iprot.readFieldEnd()
5478 
    iprot.readStructEnd()
5479 
 
5480 
  def write(self, oprot):
5481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5483 
      return
5484 
    oprot.writeStructBegin('getItemStatusDescription_args')
5485 
    if self.itemId is not None:
5486 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5487 
      oprot.writeI64(self.itemId)
5488 
      oprot.writeFieldEnd()
5489 
    oprot.writeFieldStop()
5490 
    oprot.writeStructEnd()
5491 
 
5492 
  def validate(self):
5493 
    return
5494 
 
5495 
 
5496 
  def __repr__(self):
5497 
    L = ['%s=%r' % (key, value)
5498 
      for key, value in self.__dict__.iteritems()]
5499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5500 
 
5501 
  def __eq__(self, other):
5502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5503 
 
5504 
  def __ne__(self, other):
5505 
    return not (self == other)
5506 
 
5507 
class getItemStatusDescription_result:
5508 
  """
5509 
  Attributes:
5510 
   - success
5511 
   - isex
5512 
  """
5513 
 
5514 
  thrift_spec = (
5515 
    (0, TType.STRING, 'success', None, None, ), # 0
5516 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5517 
  )
5518 
 
5519 
  def __init__(self, success=None, isex=None,):
5520 
    self.success = success
5521 
    self.isex = isex
5522 
 
5523 
  def read(self, iprot):
5524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5526 
      return
5527 
    iprot.readStructBegin()
5528 
    while True:
5529 
      (fname, ftype, fid) = iprot.readFieldBegin()
5530 
      if ftype == TType.STOP:
5531 
        break
5532 
      if fid == 0:
5533 
        if ftype == TType.STRING:
5534 
          self.success = iprot.readString();
5535 
        else:
5536 
          iprot.skip(ftype)
5537 
      elif fid == 1:
5538 
        if ftype == TType.STRUCT:
5539 
          self.isex = CatalogServiceException()
5540 
          self.isex.read(iprot)
5541 
        else:
5542 
          iprot.skip(ftype)
5543 
      else:
5544 
        iprot.skip(ftype)
5545 
      iprot.readFieldEnd()
5546 
    iprot.readStructEnd()
5547 
 
5548 
  def write(self, oprot):
5549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5551 
      return
5552 
    oprot.writeStructBegin('getItemStatusDescription_result')
5553 
    if self.success is not None:
5554 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5555 
      oprot.writeString(self.success)
5556 
      oprot.writeFieldEnd()
5557 
    if self.isex is not None:
5558 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5559 
      self.isex.write(oprot)
5560 
      oprot.writeFieldEnd()
5561 
    oprot.writeFieldStop()
5562 
    oprot.writeStructEnd()
5563 
 
5564 
  def validate(self):
5565 
    return
5566 
 
5567 
 
5568 
  def __repr__(self):
5569 
    L = ['%s=%r' % (key, value)
5570 
      for key, value in self.__dict__.iteritems()]
5571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5572 
 
5573 
  def __eq__(self, other):
5574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5575 
 
5576 
  def __ne__(self, other):
5577 
    return not (self == other)
5578 
 
5579 
class startItemOn_args:
5580 
  """
5581 
  Attributes:
5582 
   - item_id
5583 
   - timestamp
5584 
  """
5585 
 
5586 
  thrift_spec = (
5587 
    None, # 0
5588 
    (1, TType.I64, 'item_id', None, None, ), # 1
5589 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5590 
  )
5591 
 
5592 
  def __init__(self, item_id=None, timestamp=None,):
5593 
    self.item_id = item_id
5594 
    self.timestamp = timestamp
5595 
 
5596 
  def read(self, iprot):
5597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5599 
      return
5600 
    iprot.readStructBegin()
5601 
    while True:
5602 
      (fname, ftype, fid) = iprot.readFieldBegin()
5603 
      if ftype == TType.STOP:
5604 
        break
5605 
      if fid == 1:
5606 
        if ftype == TType.I64:
5607 
          self.item_id = iprot.readI64();
5608 
        else:
5609 
          iprot.skip(ftype)
5610 
      elif fid == 2:
5611 
        if ftype == TType.I64:
5612 
          self.timestamp = iprot.readI64();
5613 
        else:
5614 
          iprot.skip(ftype)
5615 
      else:
5616 
        iprot.skip(ftype)
5617 
      iprot.readFieldEnd()
5618 
    iprot.readStructEnd()
5619 
 
5620 
  def write(self, oprot):
5621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5623 
      return
5624 
    oprot.writeStructBegin('startItemOn_args')
5625 
    if self.item_id is not None:
5626 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5627 
      oprot.writeI64(self.item_id)
5628 
      oprot.writeFieldEnd()
5629 
    if self.timestamp is not None:
5630 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5631 
      oprot.writeI64(self.timestamp)
5632 
      oprot.writeFieldEnd()
5633 
    oprot.writeFieldStop()
5634 
    oprot.writeStructEnd()
5635 
 
5636 
  def validate(self):
5637 
    return
5638 
 
5639 
 
5640 
  def __repr__(self):
5641 
    L = ['%s=%r' % (key, value)
5642 
      for key, value in self.__dict__.iteritems()]
5643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5644 
 
5645 
  def __eq__(self, other):
5646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5647 
 
5648 
  def __ne__(self, other):
5649 
    return not (self == other)
5650 
 
5651 
class startItemOn_result:
5652 
  """
5653 
  Attributes:
5654 
   - cex
5655 
  """
5656 
 
5657 
  thrift_spec = (
5658 
    None, # 0
5659 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5660 
  )
5661 
 
5662 
  def __init__(self, cex=None,):
5663 
    self.cex = cex
5664 
 
5665 
  def read(self, iprot):
5666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5668 
      return
5669 
    iprot.readStructBegin()
5670 
    while True:
5671 
      (fname, ftype, fid) = iprot.readFieldBegin()
5672 
      if ftype == TType.STOP:
5673 
        break
5674 
      if fid == 1:
5675 
        if ftype == TType.STRUCT:
5676 
          self.cex = CatalogServiceException()
5677 
          self.cex.read(iprot)
5678 
        else:
5679 
          iprot.skip(ftype)
5680 
      else:
5681 
        iprot.skip(ftype)
5682 
      iprot.readFieldEnd()
5683 
    iprot.readStructEnd()
5684 
 
5685 
  def write(self, oprot):
5686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5688 
      return
5689 
    oprot.writeStructBegin('startItemOn_result')
5690 
    if self.cex is not None:
5691 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5692 
      self.cex.write(oprot)
5693 
      oprot.writeFieldEnd()
5694 
    oprot.writeFieldStop()
5695 
    oprot.writeStructEnd()
5696 
 
5697 
  def validate(self):
5698 
    return
5699 
 
5700 
 
5701 
  def __repr__(self):
5702 
    L = ['%s=%r' % (key, value)
5703 
      for key, value in self.__dict__.iteritems()]
5704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5705 
 
5706 
  def __eq__(self, other):
5707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5708 
 
5709 
  def __ne__(self, other):
5710 
    return not (self == other)
5711 
 
5712 
class retireItemOn_args:
5713 
  """
5714 
  Attributes:
5715 
   - item_id
5716 
   - timestamp
5717 
  """
5718 
 
5719 
  thrift_spec = (
5720 
    None, # 0
5721 
    (1, TType.I64, 'item_id', None, None, ), # 1
5722 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5723 
  )
5724 
 
5725 
  def __init__(self, item_id=None, timestamp=None,):
5726 
    self.item_id = item_id
5727 
    self.timestamp = timestamp
5728 
 
5729 
  def read(self, iprot):
5730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5732 
      return
5733 
    iprot.readStructBegin()
5734 
    while True:
5735 
      (fname, ftype, fid) = iprot.readFieldBegin()
5736 
      if ftype == TType.STOP:
5737 
        break
5738 
      if fid == 1:
5739 
        if ftype == TType.I64:
5740 
          self.item_id = iprot.readI64();
5741 
        else:
5742 
          iprot.skip(ftype)
5743 
      elif fid == 2:
5744 
        if ftype == TType.I64:
5745 
          self.timestamp = iprot.readI64();
5746 
        else:
5747 
          iprot.skip(ftype)
5748 
      else:
5749 
        iprot.skip(ftype)
5750 
      iprot.readFieldEnd()
5751 
    iprot.readStructEnd()
5752 
 
5753 
  def write(self, oprot):
5754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5756 
      return
5757 
    oprot.writeStructBegin('retireItemOn_args')
5758 
    if self.item_id is not None:
5759 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5760 
      oprot.writeI64(self.item_id)
5761 
      oprot.writeFieldEnd()
5762 
    if self.timestamp is not None:
5763 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5764 
      oprot.writeI64(self.timestamp)
5765 
      oprot.writeFieldEnd()
5766 
    oprot.writeFieldStop()
5767 
    oprot.writeStructEnd()
5768 
 
5769 
  def validate(self):
5770 
    return
5771 
 
5772 
 
5773 
  def __repr__(self):
5774 
    L = ['%s=%r' % (key, value)
5775 
      for key, value in self.__dict__.iteritems()]
5776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5777 
 
5778 
  def __eq__(self, other):
5779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5780 
 
5781 
  def __ne__(self, other):
5782 
    return not (self == other)
5783 
 
5784 
class retireItemOn_result:
5785 
  """
5786 
  Attributes:
5787 
   - cex
5788 
  """
5789 
 
5790 
  thrift_spec = (
5791 
    None, # 0
5792 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5793 
  )
5794 
 
5795 
  def __init__(self, cex=None,):
5796 
    self.cex = cex
5797 
 
5798 
  def read(self, iprot):
5799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5801 
      return
5802 
    iprot.readStructBegin()
5803 
    while True:
5804 
      (fname, ftype, fid) = iprot.readFieldBegin()
5805 
      if ftype == TType.STOP:
5806 
        break
5807 
      if fid == 1:
5808 
        if ftype == TType.STRUCT:
5809 
          self.cex = CatalogServiceException()
5810 
          self.cex.read(iprot)
5811 
        else:
5812 
          iprot.skip(ftype)
5813 
      else:
5814 
        iprot.skip(ftype)
5815 
      iprot.readFieldEnd()
5816 
    iprot.readStructEnd()
5817 
 
5818 
  def write(self, oprot):
5819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5821 
      return
5822 
    oprot.writeStructBegin('retireItemOn_result')
5823 
    if self.cex is not None:
5824 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5825 
      self.cex.write(oprot)
5826 
      oprot.writeFieldEnd()
5827 
    oprot.writeFieldStop()
5828 
    oprot.writeStructEnd()
5829 
 
5830 
  def validate(self):
5831 
    return
5832 
 
5833 
 
5834 
  def __repr__(self):
5835 
    L = ['%s=%r' % (key, value)
5836 
      for key, value in self.__dict__.iteritems()]
5837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5838 
 
5839 
  def __eq__(self, other):
5840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5841 
 
5842 
  def __ne__(self, other):
5843 
    return not (self == other)
5844 
 
5845 
class changeItemStatus_args:
5846 
  """
5847 
  Attributes:
5848 
   - item_id
5849 
   - timestamp
5850 
   - newstatus
5851 
  """
5852 
 
5853 
  thrift_spec = (
5854 
    None, # 0
5855 
    (1, TType.I64, 'item_id', None, None, ), # 1
5856 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5857 
    (3, TType.I32, 'newstatus', None, None, ), # 3
5858 
  )
5859 
 
5860 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
5861 
    self.item_id = item_id
5862 
    self.timestamp = timestamp
5863 
    self.newstatus = newstatus
5864 
 
5865 
  def read(self, iprot):
5866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5868 
      return
5869 
    iprot.readStructBegin()
5870 
    while True:
5871 
      (fname, ftype, fid) = iprot.readFieldBegin()
5872 
      if ftype == TType.STOP:
5873 
        break
5874 
      if fid == 1:
5875 
        if ftype == TType.I64:
5876 
          self.item_id = iprot.readI64();
5877 
        else:
5878 
          iprot.skip(ftype)
5879 
      elif fid == 2:
5880 
        if ftype == TType.I64:
5881 
          self.timestamp = iprot.readI64();
5882 
        else:
5883 
          iprot.skip(ftype)
5884 
      elif fid == 3:
5885 
        if ftype == TType.I32:
5886 
          self.newstatus = iprot.readI32();
5887 
        else:
5888 
          iprot.skip(ftype)
5889 
      else:
5890 
        iprot.skip(ftype)
5891 
      iprot.readFieldEnd()
5892 
    iprot.readStructEnd()
5893 
 
5894 
  def write(self, oprot):
5895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5897 
      return
5898 
    oprot.writeStructBegin('changeItemStatus_args')
5899 
    if self.item_id is not None:
5900 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5901 
      oprot.writeI64(self.item_id)
5902 
      oprot.writeFieldEnd()
5903 
    if self.timestamp is not None:
5904 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5905 
      oprot.writeI64(self.timestamp)
5906 
      oprot.writeFieldEnd()
5907 
    if self.newstatus is not None:
5908 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
5909 
      oprot.writeI32(self.newstatus)
5910 
      oprot.writeFieldEnd()
5911 
    oprot.writeFieldStop()
5912 
    oprot.writeStructEnd()
5913 
 
5914 
  def validate(self):
5915 
    return
5916 
 
5917 
 
5918 
  def __repr__(self):
5919 
    L = ['%s=%r' % (key, value)
5920 
      for key, value in self.__dict__.iteritems()]
5921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5922 
 
5923 
  def __eq__(self, other):
5924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5925 
 
5926 
  def __ne__(self, other):
5927 
    return not (self == other)
5928 
 
5929 
class changeItemStatus_result:
5930 
  """
5931 
  Attributes:
5932 
   - cex
5933 
  """
5934 
 
5935 
  thrift_spec = (
5936 
    None, # 0
5937 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5938 
  )
5939 
 
5940 
  def __init__(self, cex=None,):
5941 
    self.cex = cex
5942 
 
5943 
  def read(self, iprot):
5944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5946 
      return
5947 
    iprot.readStructBegin()
5948 
    while True:
5949 
      (fname, ftype, fid) = iprot.readFieldBegin()
5950 
      if ftype == TType.STOP:
5951 
        break
5952 
      if fid == 1:
5953 
        if ftype == TType.STRUCT:
5954 
          self.cex = CatalogServiceException()
5955 
          self.cex.read(iprot)
5956 
        else:
5957 
          iprot.skip(ftype)
5958 
      else:
5959 
        iprot.skip(ftype)
5960 
      iprot.readFieldEnd()
5961 
    iprot.readStructEnd()
5962 
 
5963 
  def write(self, oprot):
5964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5966 
      return
5967 
    oprot.writeStructBegin('changeItemStatus_result')
5968 
    if self.cex is not None:
5969 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5970 
      self.cex.write(oprot)
5971 
      oprot.writeFieldEnd()
5972 
    oprot.writeFieldStop()
5973 
    oprot.writeStructEnd()
5974 
 
5975 
  def validate(self):
5976 
    return
5977 
 
5978 
 
5979 
  def __repr__(self):
5980 
    L = ['%s=%r' % (key, value)
5981 
      for key, value in self.__dict__.iteritems()]
5982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5983 
 
5984 
  def __eq__(self, other):
5985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5986 
 
5987 
  def __ne__(self, other):
5988 
    return not (self == other)
5989 
 
5990 
class getItem_args:
5991 
  """
5992 
  Attributes:
5993 
   - item_id
5994 
  """
5995 
 
5996 
  thrift_spec = (
5997 
    None, # 0
5998 
    (1, TType.I64, 'item_id', None, None, ), # 1
5999 
  )
6000 
 
6001 
  def __init__(self, item_id=None,):
6002 
    self.item_id = item_id
6003 
 
6004 
  def read(self, iprot):
6005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6007 
      return
6008 
    iprot.readStructBegin()
6009 
    while True:
6010 
      (fname, ftype, fid) = iprot.readFieldBegin()
6011 
      if ftype == TType.STOP:
6012 
        break
6013 
      if fid == 1:
6014 
        if ftype == TType.I64:
6015 
          self.item_id = iprot.readI64();
6016 
        else:
6017 
          iprot.skip(ftype)
6018 
      else:
6019 
        iprot.skip(ftype)
6020 
      iprot.readFieldEnd()
6021 
    iprot.readStructEnd()
6022 
 
6023 
  def write(self, oprot):
6024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6026 
      return
6027 
    oprot.writeStructBegin('getItem_args')
6028 
    if self.item_id is not None:
6029 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6030 
      oprot.writeI64(self.item_id)
6031 
      oprot.writeFieldEnd()
6032 
    oprot.writeFieldStop()
6033 
    oprot.writeStructEnd()
6034 
 
6035 
  def validate(self):
6036 
    return
6037 
 
6038 
 
6039 
  def __repr__(self):
6040 
    L = ['%s=%r' % (key, value)
6041 
      for key, value in self.__dict__.iteritems()]
6042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6043 
 
6044 
  def __eq__(self, other):
6045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6046 
 
6047 
  def __ne__(self, other):
6048 
    return not (self == other)
6049 
 
6050 
class getItem_result:
6051 
  """
6052 
  Attributes:
6053 
   - success
6054 
   - cex
6055 
  """
6056 
 
6057 
  thrift_spec = (
6058 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6059 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6060 
  )
6061 
 
6062 
  def __init__(self, success=None, cex=None,):
6063 
    self.success = success
6064 
    self.cex = cex
6065 
 
6066 
  def read(self, iprot):
6067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6069 
      return
6070 
    iprot.readStructBegin()
6071 
    while True:
6072 
      (fname, ftype, fid) = iprot.readFieldBegin()
6073 
      if ftype == TType.STOP:
6074 
        break
6075 
      if fid == 0:
6076 
        if ftype == TType.STRUCT:
6077 
          self.success = Item()
6078 
          self.success.read(iprot)
6079 
        else:
6080 
          iprot.skip(ftype)
6081 
      elif fid == 1:
6082 
        if ftype == TType.STRUCT:
6083 
          self.cex = CatalogServiceException()
6084 
          self.cex.read(iprot)
6085 
        else:
6086 
          iprot.skip(ftype)
6087 
      else:
6088 
        iprot.skip(ftype)
6089 
      iprot.readFieldEnd()
6090 
    iprot.readStructEnd()
6091 
 
6092 
  def write(self, oprot):
6093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6095 
      return
6096 
    oprot.writeStructBegin('getItem_result')
6097 
    if self.success is not None:
6098 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6099 
      self.success.write(oprot)
6100 
      oprot.writeFieldEnd()
6101 
    if self.cex is not None:
6102 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6103 
      self.cex.write(oprot)
6104 
      oprot.writeFieldEnd()
6105 
    oprot.writeFieldStop()
6106 
    oprot.writeStructEnd()
6107 
 
6108 
  def validate(self):
6109 
    return
6110 
 
6111 
 
6112 
  def __repr__(self):
6113 
    L = ['%s=%r' % (key, value)
6114 
      for key, value in self.__dict__.iteritems()]
6115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6116 
 
6117 
  def __eq__(self, other):
6118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6119 
 
6120 
  def __ne__(self, other):
6121 
    return not (self == other)
6122 
 
6123 
class getItemsByCatalogId_args:
6124 
  """
6125 
  Attributes:
6126 
   - catalog_item_id
6127 
  """
6128 
 
6129 
  thrift_spec = (
6130 
    None, # 0
6131 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6132 
  )
6133 
 
6134 
  def __init__(self, catalog_item_id=None,):
6135 
    self.catalog_item_id = catalog_item_id
6136 
 
6137 
  def read(self, iprot):
6138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6140 
      return
6141 
    iprot.readStructBegin()
6142 
    while True:
6143 
      (fname, ftype, fid) = iprot.readFieldBegin()
6144 
      if ftype == TType.STOP:
6145 
        break
6146 
      if fid == 1:
6147 
        if ftype == TType.I64:
6148 
          self.catalog_item_id = iprot.readI64();
6149 
        else:
6150 
          iprot.skip(ftype)
6151 
      else:
6152 
        iprot.skip(ftype)
6153 
      iprot.readFieldEnd()
6154 
    iprot.readStructEnd()
6155 
 
6156 
  def write(self, oprot):
6157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6159 
      return
6160 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6161 
    if self.catalog_item_id is not None:
6162 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6163 
      oprot.writeI64(self.catalog_item_id)
6164 
      oprot.writeFieldEnd()
6165 
    oprot.writeFieldStop()
6166 
    oprot.writeStructEnd()
6167 
 
6168 
  def validate(self):
6169 
    return
6170 
 
6171 
 
6172 
  def __repr__(self):
6173 
    L = ['%s=%r' % (key, value)
6174 
      for key, value in self.__dict__.iteritems()]
6175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6176 
 
6177 
  def __eq__(self, other):
6178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6179 
 
6180 
  def __ne__(self, other):
6181 
    return not (self == other)
6182 
 
6183 
class getItemsByCatalogId_result:
6184 
  """
6185 
  Attributes:
6186 
   - success
6187 
   - cex
6188 
  """
6189 
 
6190 
  thrift_spec = (
6191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6192 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6193 
  )
6194 
 
6195 
  def __init__(self, success=None, cex=None,):
6196 
    self.success = success
6197 
    self.cex = cex
6198 
 
6199 
  def read(self, iprot):
6200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6202 
      return
6203 
    iprot.readStructBegin()
6204 
    while True:
6205 
      (fname, ftype, fid) = iprot.readFieldBegin()
6206 
      if ftype == TType.STOP:
6207 
        break
6208 
      if fid == 0:
6209 
        if ftype == TType.LIST:
6210 
          self.success = []
6211 
          (_etype19, _size16) = iprot.readListBegin()
6212 
          for _i20 in xrange(_size16):
6213 
            _elem21 = Item()
6214 
            _elem21.read(iprot)
6215 
            self.success.append(_elem21)
6216 
          iprot.readListEnd()
6217 
        else:
6218 
          iprot.skip(ftype)
6219 
      elif fid == 1:
6220 
        if ftype == TType.STRUCT:
6221 
          self.cex = CatalogServiceException()
6222 
          self.cex.read(iprot)
6223 
        else:
6224 
          iprot.skip(ftype)
6225 
      else:
6226 
        iprot.skip(ftype)
6227 
      iprot.readFieldEnd()
6228 
    iprot.readStructEnd()
6229 
 
6230 
  def write(self, oprot):
6231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6233 
      return
6234 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6235 
    if self.success is not None:
6236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6237 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6238 
      for iter22 in self.success:
6239 
        iter22.write(oprot)
6240 
      oprot.writeListEnd()
6241 
      oprot.writeFieldEnd()
6242 
    if self.cex is not None:
6243 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6244 
      self.cex.write(oprot)
6245 
      oprot.writeFieldEnd()
6246 
    oprot.writeFieldStop()
6247 
    oprot.writeStructEnd()
6248 
 
6249 
  def validate(self):
6250 
    return
6251 
 
6252 
 
6253 
  def __repr__(self):
6254 
    L = ['%s=%r' % (key, value)
6255 
      for key, value in self.__dict__.iteritems()]
6256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6257 
 
6258 
  def __eq__(self, other):
6259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6260 
 
6261 
  def __ne__(self, other):
6262 
    return not (self == other)
6263 
 
6264 
class getValidItemsByCatalogId_args:
6265 
  """
6266 
  Attributes:
6267 
   - catalog_item_id
6268 
  """
6269 
 
6270 
  thrift_spec = (
6271 
    None, # 0
6272 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6273 
  )
6274 
 
6275 
  def __init__(self, catalog_item_id=None,):
6276 
    self.catalog_item_id = catalog_item_id
6277 
 
6278 
  def read(self, iprot):
6279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6281 
      return
6282 
    iprot.readStructBegin()
6283 
    while True:
6284 
      (fname, ftype, fid) = iprot.readFieldBegin()
6285 
      if ftype == TType.STOP:
6286 
        break
6287 
      if fid == 1:
6288 
        if ftype == TType.I64:
6289 
          self.catalog_item_id = iprot.readI64();
6290 
        else:
6291 
          iprot.skip(ftype)
6292 
      else:
6293 
        iprot.skip(ftype)
6294 
      iprot.readFieldEnd()
6295 
    iprot.readStructEnd()
6296 
 
6297 
  def write(self, oprot):
6298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6300 
      return
6301 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6302 
    if self.catalog_item_id is not None:
6303 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6304 
      oprot.writeI64(self.catalog_item_id)
6305 
      oprot.writeFieldEnd()
6306 
    oprot.writeFieldStop()
6307 
    oprot.writeStructEnd()
6308 
 
6309 
  def validate(self):
6310 
    return
6311 
 
6312 
 
6313 
  def __repr__(self):
6314 
    L = ['%s=%r' % (key, value)
6315 
      for key, value in self.__dict__.iteritems()]
6316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6317 
 
6318 
  def __eq__(self, other):
6319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6320 
 
6321 
  def __ne__(self, other):
6322 
    return not (self == other)
6323 
 
6324 
class getValidItemsByCatalogId_result:
6325 
  """
6326 
  Attributes:
6327 
   - success
6328 
   - cex
6329 
  """
6330 
 
6331 
  thrift_spec = (
6332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6333 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6334 
  )
6335 
 
6336 
  def __init__(self, success=None, cex=None,):
6337 
    self.success = success
6338 
    self.cex = cex
6339 
 
6340 
  def read(self, iprot):
6341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6343 
      return
6344 
    iprot.readStructBegin()
6345 
    while True:
6346 
      (fname, ftype, fid) = iprot.readFieldBegin()
6347 
      if ftype == TType.STOP:
6348 
        break
6349 
      if fid == 0:
6350 
        if ftype == TType.LIST:
6351 
          self.success = []
6352 
          (_etype26, _size23) = iprot.readListBegin()
6353 
          for _i27 in xrange(_size23):
6354 
            _elem28 = Item()
6355 
            _elem28.read(iprot)
6356 
            self.success.append(_elem28)
6357 
          iprot.readListEnd()
6358 
        else:
6359 
          iprot.skip(ftype)
6360 
      elif fid == 1:
6361 
        if ftype == TType.STRUCT:
6362 
          self.cex = CatalogServiceException()
6363 
          self.cex.read(iprot)
6364 
        else:
6365 
          iprot.skip(ftype)
6366 
      else:
6367 
        iprot.skip(ftype)
6368 
      iprot.readFieldEnd()
6369 
    iprot.readStructEnd()
6370 
 
6371 
  def write(self, oprot):
6372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6374 
      return
6375 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6376 
    if self.success is not None:
6377 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6378 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6379 
      for iter29 in self.success:
6380 
        iter29.write(oprot)
6381 
      oprot.writeListEnd()
6382 
      oprot.writeFieldEnd()
6383 
    if self.cex is not None:
6384 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6385 
      self.cex.write(oprot)
6386 
      oprot.writeFieldEnd()
6387 
    oprot.writeFieldStop()
6388 
    oprot.writeStructEnd()
6389 
 
6390 
  def validate(self):
6391 
    return
6392 
 
6393 
 
6394 
  def __repr__(self):
6395 
    L = ['%s=%r' % (key, value)
6396 
      for key, value in self.__dict__.iteritems()]
6397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6398 
 
6399 
  def __eq__(self, other):
6400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6401 
 
6402 
  def __ne__(self, other):
6403 
    return not (self == other)
6404 
 
6405 
class getAllItems_args:
6406 
  """
6407 
  Attributes:
6408 
   - isActive
6409 
  """
6410 
 
6411 
  thrift_spec = (
6412 
    None, # 0
6413 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6414 
  )
6415 
 
6416 
  def __init__(self, isActive=None,):
6417 
    self.isActive = isActive
6418 
 
6419 
  def read(self, iprot):
6420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6422 
      return
6423 
    iprot.readStructBegin()
6424 
    while True:
6425 
      (fname, ftype, fid) = iprot.readFieldBegin()
6426 
      if ftype == TType.STOP:
6427 
        break
6428 
      if fid == 1:
6429 
        if ftype == TType.BOOL:
6430 
          self.isActive = iprot.readBool();
6431 
        else:
6432 
          iprot.skip(ftype)
6433 
      else:
6434 
        iprot.skip(ftype)
6435 
      iprot.readFieldEnd()
6436 
    iprot.readStructEnd()
6437 
 
6438 
  def write(self, oprot):
6439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6441 
      return
6442 
    oprot.writeStructBegin('getAllItems_args')
6443 
    if self.isActive is not None:
6444 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6445 
      oprot.writeBool(self.isActive)
6446 
      oprot.writeFieldEnd()
6447 
    oprot.writeFieldStop()
6448 
    oprot.writeStructEnd()
6449 
 
6450 
  def validate(self):
6451 
    return
6452 
 
6453 
 
6454 
  def __repr__(self):
6455 
    L = ['%s=%r' % (key, value)
6456 
      for key, value in self.__dict__.iteritems()]
6457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6458 
 
6459 
  def __eq__(self, other):
6460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6461 
 
6462 
  def __ne__(self, other):
6463 
    return not (self == other)
6464 
 
6465 
class getAllItems_result:
6466 
  """
6467 
  Attributes:
6468 
   - success
6469 
   - cex
6470 
  """
6471 
 
6472 
  thrift_spec = (
6473 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6474 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6475 
  )
6476 
 
6477 
  def __init__(self, success=None, cex=None,):
6478 
    self.success = success
6479 
    self.cex = cex
6480 
 
6481 
  def read(self, iprot):
6482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6484 
      return
6485 
    iprot.readStructBegin()
6486 
    while True:
6487 
      (fname, ftype, fid) = iprot.readFieldBegin()
6488 
      if ftype == TType.STOP:
6489 
        break
6490 
      if fid == 0:
6491 
        if ftype == TType.LIST:
6492 
          self.success = []
6493 
          (_etype33, _size30) = iprot.readListBegin()
6494 
          for _i34 in xrange(_size30):
6495 
            _elem35 = Item()
6496 
            _elem35.read(iprot)
6497 
            self.success.append(_elem35)
6498 
          iprot.readListEnd()
6499 
        else:
6500 
          iprot.skip(ftype)
6501 
      elif fid == 1:
6502 
        if ftype == TType.STRUCT:
6503 
          self.cex = CatalogServiceException()
6504 
          self.cex.read(iprot)
6505 
        else:
6506 
          iprot.skip(ftype)
6507 
      else:
6508 
        iprot.skip(ftype)
6509 
      iprot.readFieldEnd()
6510 
    iprot.readStructEnd()
6511 
 
6512 
  def write(self, oprot):
6513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6515 
      return
6516 
    oprot.writeStructBegin('getAllItems_result')
6517 
    if self.success is not None:
6518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6520 
      for iter36 in self.success:
6521 
        iter36.write(oprot)
6522 
      oprot.writeListEnd()
6523 
      oprot.writeFieldEnd()
6524 
    if self.cex is not None:
6525 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6526 
      self.cex.write(oprot)
6527 
      oprot.writeFieldEnd()
6528 
    oprot.writeFieldStop()
6529 
    oprot.writeStructEnd()
6530 
 
6531 
  def validate(self):
6532 
    return
6533 
 
6534 
 
6535 
  def __repr__(self):
6536 
    L = ['%s=%r' % (key, value)
6537 
      for key, value in self.__dict__.iteritems()]
6538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6539 
 
6540 
  def __eq__(self, other):
6541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6542 
 
6543 
  def __ne__(self, other):
6544 
    return not (self == other)
6545 
 
6546 
class getAllItemsByStatus_args:
6547 
  """
6548 
  Attributes:
6549 
   - itemStatus
6550 
  """
6551 
 
6552 
  thrift_spec = (
6553 
    None, # 0
6554 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6555 
  )
6556 
 
6557 
  def __init__(self, itemStatus=None,):
6558 
    self.itemStatus = itemStatus
6559 
 
6560 
  def read(self, iprot):
6561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6563 
      return
6564 
    iprot.readStructBegin()
6565 
    while True:
6566 
      (fname, ftype, fid) = iprot.readFieldBegin()
6567 
      if ftype == TType.STOP:
6568 
        break
6569 
      if fid == 1:
6570 
        if ftype == TType.I32:
6571 
          self.itemStatus = iprot.readI32();
6572 
        else:
6573 
          iprot.skip(ftype)
6574 
      else:
6575 
        iprot.skip(ftype)
6576 
      iprot.readFieldEnd()
6577 
    iprot.readStructEnd()
6578 
 
6579 
  def write(self, oprot):
6580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6582 
      return
6583 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6584 
    if self.itemStatus is not None:
6585 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6586 
      oprot.writeI32(self.itemStatus)
6587 
      oprot.writeFieldEnd()
6588 
    oprot.writeFieldStop()
6589 
    oprot.writeStructEnd()
6590 
 
6591 
  def validate(self):
6592 
    return
6593 
 
6594 
 
6595 
  def __repr__(self):
6596 
    L = ['%s=%r' % (key, value)
6597 
      for key, value in self.__dict__.iteritems()]
6598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6599 
 
6600 
  def __eq__(self, other):
6601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6602 
 
6603 
  def __ne__(self, other):
6604 
    return not (self == other)
6605 
 
6606 
class getAllItemsByStatus_result:
6607 
  """
6608 
  Attributes:
6609 
   - success
6610 
   - cex
6611 
  """
6612 
 
6613 
  thrift_spec = (
6614 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6615 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6616 
  )
6617 
 
6618 
  def __init__(self, success=None, cex=None,):
6619 
    self.success = success
6620 
    self.cex = cex
6621 
 
6622 
  def read(self, iprot):
6623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6625 
      return
6626 
    iprot.readStructBegin()
6627 
    while True:
6628 
      (fname, ftype, fid) = iprot.readFieldBegin()
6629 
      if ftype == TType.STOP:
6630 
        break
6631 
      if fid == 0:
6632 
        if ftype == TType.LIST:
6633 
          self.success = []
6634 
          (_etype40, _size37) = iprot.readListBegin()
6635 
          for _i41 in xrange(_size37):
6636 
            _elem42 = Item()
6637 
            _elem42.read(iprot)
6638 
            self.success.append(_elem42)
6639 
          iprot.readListEnd()
6640 
        else:
6641 
          iprot.skip(ftype)
6642 
      elif fid == 1:
6643 
        if ftype == TType.STRUCT:
6644 
          self.cex = CatalogServiceException()
6645 
          self.cex.read(iprot)
6646 
        else:
6647 
          iprot.skip(ftype)
6648 
      else:
6649 
        iprot.skip(ftype)
6650 
      iprot.readFieldEnd()
6651 
    iprot.readStructEnd()
6652 
 
6653 
  def write(self, oprot):
6654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6656 
      return
6657 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6658 
    if self.success is not None:
6659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6661 
      for iter43 in self.success:
6662 
        iter43.write(oprot)
6663 
      oprot.writeListEnd()
6664 
      oprot.writeFieldEnd()
6665 
    if self.cex is not None:
6666 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6667 
      self.cex.write(oprot)
6668 
      oprot.writeFieldEnd()
6669 
    oprot.writeFieldStop()
6670 
    oprot.writeStructEnd()
6671 
 
6672 
  def validate(self):
6673 
    return
6674 
 
6675 
 
6676 
  def __repr__(self):
6677 
    L = ['%s=%r' % (key, value)
6678 
      for key, value in self.__dict__.iteritems()]
6679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6680 
 
6681 
  def __eq__(self, other):
6682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6683 
 
6684 
  def __ne__(self, other):
6685 
    return not (self == other)
6686 
 
6687 
class markItemAsContentComplete_args:
6688 
  """
6689 
  Attributes:
6690 
   - entityId
6691 
   - category
6692 
   - brand
6693 
   - modelName
6694 
   - modelNumber
6695 
  """
6696 
 
6697 
  thrift_spec = (
6698 
    None, # 0
6699 
    (1, TType.I64, 'entityId', None, None, ), # 1
6700 
    (2, TType.I64, 'category', None, None, ), # 2
6701 
    (3, TType.STRING, 'brand', None, None, ), # 3
6702 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6703 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6704 
  )
6705 
 
6706 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6707 
    self.entityId = entityId
6708 
    self.category = category
6709 
    self.brand = brand
6710 
    self.modelName = modelName
6711 
    self.modelNumber = modelNumber
6712 
 
6713 
  def read(self, iprot):
6714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6716 
      return
6717 
    iprot.readStructBegin()
6718 
    while True:
6719 
      (fname, ftype, fid) = iprot.readFieldBegin()
6720 
      if ftype == TType.STOP:
6721 
        break
6722 
      if fid == 1:
6723 
        if ftype == TType.I64:
6724 
          self.entityId = iprot.readI64();
6725 
        else:
6726 
          iprot.skip(ftype)
6727 
      elif fid == 2:
6728 
        if ftype == TType.I64:
6729 
          self.category = iprot.readI64();
6730 
        else:
6731 
          iprot.skip(ftype)
6732 
      elif fid == 3:
6733 
        if ftype == TType.STRING:
6734 
          self.brand = iprot.readString();
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      elif fid == 4:
6738 
        if ftype == TType.STRING:
6739 
          self.modelName = iprot.readString();
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      elif fid == 5:
6743 
        if ftype == TType.STRING:
6744 
          self.modelNumber = iprot.readString();
6745 
        else:
6746 
          iprot.skip(ftype)
6747 
      else:
6748 
        iprot.skip(ftype)
6749 
      iprot.readFieldEnd()
6750 
    iprot.readStructEnd()
6751 
 
6752 
  def write(self, oprot):
6753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6755 
      return
6756 
    oprot.writeStructBegin('markItemAsContentComplete_args')
6757 
    if self.entityId is not None:
6758 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
6759 
      oprot.writeI64(self.entityId)
6760 
      oprot.writeFieldEnd()
6761 
    if self.category is not None:
6762 
      oprot.writeFieldBegin('category', TType.I64, 2)
6763 
      oprot.writeI64(self.category)
6764 
      oprot.writeFieldEnd()
6765 
    if self.brand is not None:
6766 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
6767 
      oprot.writeString(self.brand)
6768 
      oprot.writeFieldEnd()
6769 
    if self.modelName is not None:
6770 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
6771 
      oprot.writeString(self.modelName)
6772 
      oprot.writeFieldEnd()
6773 
    if self.modelNumber is not None:
6774 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
6775 
      oprot.writeString(self.modelNumber)
6776 
      oprot.writeFieldEnd()
6777 
    oprot.writeFieldStop()
6778 
    oprot.writeStructEnd()
6779 
 
6780 
  def validate(self):
6781 
    return
6782 
 
6783 
 
6784 
  def __repr__(self):
6785 
    L = ['%s=%r' % (key, value)
6786 
      for key, value in self.__dict__.iteritems()]
6787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6788 
 
6789 
  def __eq__(self, other):
6790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6791 
 
6792 
  def __ne__(self, other):
6793 
    return not (self == other)
6794 
 
6795 
class markItemAsContentComplete_result:
6796 
  """
6797 
  Attributes:
6798 
   - success
6799 
   - cex
6800 
  """
6801 
 
6802 
  thrift_spec = (
6803 
    (0, TType.BOOL, 'success', None, None, ), # 0
6804 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6805 
  )
6806 
 
6807 
  def __init__(self, success=None, cex=None,):
6808 
    self.success = success
6809 
    self.cex = cex
6810 
 
6811 
  def read(self, iprot):
6812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6814 
      return
6815 
    iprot.readStructBegin()
6816 
    while True:
6817 
      (fname, ftype, fid) = iprot.readFieldBegin()
6818 
      if ftype == TType.STOP:
6819 
        break
6820 
      if fid == 0:
6821 
        if ftype == TType.BOOL:
6822 
          self.success = iprot.readBool();
6823 
        else:
6824 
          iprot.skip(ftype)
6825 
      elif fid == 1:
6826 
        if ftype == TType.STRUCT:
6827 
          self.cex = CatalogServiceException()
6828 
          self.cex.read(iprot)
6829 
        else:
6830 
          iprot.skip(ftype)
6831 
      else:
6832 
        iprot.skip(ftype)
6833 
      iprot.readFieldEnd()
6834 
    iprot.readStructEnd()
6835 
 
6836 
  def write(self, oprot):
6837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6839 
      return
6840 
    oprot.writeStructBegin('markItemAsContentComplete_result')
6841 
    if self.success is not None:
6842 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6843 
      oprot.writeBool(self.success)
6844 
      oprot.writeFieldEnd()
6845 
    if self.cex is not None:
6846 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6847 
      self.cex.write(oprot)
6848 
      oprot.writeFieldEnd()
6849 
    oprot.writeFieldStop()
6850 
    oprot.writeStructEnd()
6851 
 
6852 
  def validate(self):
6853 
    return
6854 
 
6855 
 
6856 
  def __repr__(self):
6857 
    L = ['%s=%r' % (key, value)
6858 
      for key, value in self.__dict__.iteritems()]
6859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6860 
 
6861 
  def __eq__(self, other):
6862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6863 
 
6864 
  def __ne__(self, other):
6865 
    return not (self == other)
6866 
 
6867 
class getAllItemsInRange_args:
6868 
  """
6869 
  Attributes:
6870 
   - offset
6871 
   - limit
6872 
  """
6873 
 
6874 
  thrift_spec = (
6875 
    None, # 0
6876 
    (1, TType.I64, 'offset', None, None, ), # 1
6877 
    (2, TType.I64, 'limit', None, None, ), # 2
6878 
  )
6879 
 
6880 
  def __init__(self, offset=None, limit=None,):
6881 
    self.offset = offset
6882 
    self.limit = limit
6883 
 
6884 
  def read(self, iprot):
6885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6887 
      return
6888 
    iprot.readStructBegin()
6889 
    while True:
6890 
      (fname, ftype, fid) = iprot.readFieldBegin()
6891 
      if ftype == TType.STOP:
6892 
        break
6893 
      if fid == 1:
6894 
        if ftype == TType.I64:
6895 
          self.offset = iprot.readI64();
6896 
        else:
6897 
          iprot.skip(ftype)
6898 
      elif fid == 2:
6899 
        if ftype == TType.I64:
6900 
          self.limit = iprot.readI64();
6901 
        else:
6902 
          iprot.skip(ftype)
6903 
      else:
6904 
        iprot.skip(ftype)
6905 
      iprot.readFieldEnd()
6906 
    iprot.readStructEnd()
6907 
 
6908 
  def write(self, oprot):
6909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6911 
      return
6912 
    oprot.writeStructBegin('getAllItemsInRange_args')
6913 
    if self.offset is not None:
6914 
      oprot.writeFieldBegin('offset', TType.I64, 1)
6915 
      oprot.writeI64(self.offset)
6916 
      oprot.writeFieldEnd()
6917 
    if self.limit is not None:
6918 
      oprot.writeFieldBegin('limit', TType.I64, 2)
6919 
      oprot.writeI64(self.limit)
6920 
      oprot.writeFieldEnd()
6921 
    oprot.writeFieldStop()
6922 
    oprot.writeStructEnd()
6923 
 
6924 
  def validate(self):
6925 
    return
6926 
 
6927 
 
6928 
  def __repr__(self):
6929 
    L = ['%s=%r' % (key, value)
6930 
      for key, value in self.__dict__.iteritems()]
6931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6932 
 
6933 
  def __eq__(self, other):
6934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6935 
 
6936 
  def __ne__(self, other):
6937 
    return not (self == other)
6938 
 
6939 
class getAllItemsInRange_result:
6940 
  """
6941 
  Attributes:
6942 
   - success
6943 
   - cex
6944 
  """
6945 
 
6946 
  thrift_spec = (
6947 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6948 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6949 
  )
6950 
 
6951 
  def __init__(self, success=None, cex=None,):
6952 
    self.success = success
6953 
    self.cex = cex
6954 
 
6955 
  def read(self, iprot):
6956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6958 
      return
6959 
    iprot.readStructBegin()
6960 
    while True:
6961 
      (fname, ftype, fid) = iprot.readFieldBegin()
6962 
      if ftype == TType.STOP:
6963 
        break
6964 
      if fid == 0:
6965 
        if ftype == TType.LIST:
6966 
          self.success = []
6967 
          (_etype47, _size44) = iprot.readListBegin()
6968 
          for _i48 in xrange(_size44):
6969 
            _elem49 = Item()
6970 
            _elem49.read(iprot)
6971 
            self.success.append(_elem49)
6972 
          iprot.readListEnd()
6973 
        else:
6974 
          iprot.skip(ftype)
6975 
      elif fid == 1:
6976 
        if ftype == TType.STRUCT:
6977 
          self.cex = CatalogServiceException()
6978 
          self.cex.read(iprot)
6979 
        else:
6980 
          iprot.skip(ftype)
6981 
      else:
6982 
        iprot.skip(ftype)
6983 
      iprot.readFieldEnd()
6984 
    iprot.readStructEnd()
6985 
 
6986 
  def write(self, oprot):
6987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6989 
      return
6990 
    oprot.writeStructBegin('getAllItemsInRange_result')
6991 
    if self.success is not None:
6992 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6993 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6994 
      for iter50 in self.success:
6995 
        iter50.write(oprot)
6996 
      oprot.writeListEnd()
6997 
      oprot.writeFieldEnd()
6998 
    if self.cex is not None:
6999 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7000 
      self.cex.write(oprot)
7001 
      oprot.writeFieldEnd()
7002 
    oprot.writeFieldStop()
7003 
    oprot.writeStructEnd()
7004 
 
7005 
  def validate(self):
7006 
    return
7007 
 
7008 
 
7009 
  def __repr__(self):
7010 
    L = ['%s=%r' % (key, value)
7011 
      for key, value in self.__dict__.iteritems()]
7012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7013 
 
7014 
  def __eq__(self, other):
7015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7016 
 
7017 
  def __ne__(self, other):
7018 
    return not (self == other)
7019 
 
7020 
class getAllItemsByStatusInRange_args:
7021 
  """
7022 
  Attributes:
7023 
   - itemStatus
7024 
   - offset
7025 
   - limit
7026 
  """
7027 
 
7028 
  thrift_spec = (
7029 
    None, # 0
7030 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7031 
    (2, TType.I64, 'offset', None, None, ), # 2
7032 
    (3, TType.I64, 'limit', None, None, ), # 3
7033 
  )
7034 
 
7035 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7036 
    self.itemStatus = itemStatus
7037 
    self.offset = offset
7038 
    self.limit = limit
7039 
 
7040 
  def read(self, iprot):
7041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7043 
      return
7044 
    iprot.readStructBegin()
7045 
    while True:
7046 
      (fname, ftype, fid) = iprot.readFieldBegin()
7047 
      if ftype == TType.STOP:
7048 
        break
7049 
      if fid == 1:
7050 
        if ftype == TType.I32:
7051 
          self.itemStatus = iprot.readI32();
7052 
        else:
7053 
          iprot.skip(ftype)
7054 
      elif fid == 2:
7055 
        if ftype == TType.I64:
7056 
          self.offset = iprot.readI64();
7057 
        else:
7058 
          iprot.skip(ftype)
7059 
      elif fid == 3:
7060 
        if ftype == TType.I64:
7061 
          self.limit = iprot.readI64();
7062 
        else:
7063 
          iprot.skip(ftype)
7064 
      else:
7065 
        iprot.skip(ftype)
7066 
      iprot.readFieldEnd()
7067 
    iprot.readStructEnd()
7068 
 
7069 
  def write(self, oprot):
7070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7072 
      return
7073 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7074 
    if self.itemStatus is not None:
7075 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7076 
      oprot.writeI32(self.itemStatus)
7077 
      oprot.writeFieldEnd()
7078 
    if self.offset is not None:
7079 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7080 
      oprot.writeI64(self.offset)
7081 
      oprot.writeFieldEnd()
7082 
    if self.limit is not None:
7083 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7084 
      oprot.writeI64(self.limit)
7085 
      oprot.writeFieldEnd()
7086 
    oprot.writeFieldStop()
7087 
    oprot.writeStructEnd()
7088 
 
7089 
  def validate(self):
7090 
    return
7091 
 
7092 
 
7093 
  def __repr__(self):
7094 
    L = ['%s=%r' % (key, value)
7095 
      for key, value in self.__dict__.iteritems()]
7096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7097 
 
7098 
  def __eq__(self, other):
7099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7100 
 
7101 
  def __ne__(self, other):
7102 
    return not (self == other)
7103 
 
7104 
class getAllItemsByStatusInRange_result:
7105 
  """
7106 
  Attributes:
7107 
   - success
7108 
   - cex
7109 
  """
7110 
 
7111 
  thrift_spec = (
7112 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7113 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7114 
  )
7115 
 
7116 
  def __init__(self, success=None, cex=None,):
7117 
    self.success = success
7118 
    self.cex = cex
7119 
 
7120 
  def read(self, iprot):
7121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7123 
      return
7124 
    iprot.readStructBegin()
7125 
    while True:
7126 
      (fname, ftype, fid) = iprot.readFieldBegin()
7127 
      if ftype == TType.STOP:
7128 
        break
7129 
      if fid == 0:
7130 
        if ftype == TType.LIST:
7131 
          self.success = []
7132 
          (_etype54, _size51) = iprot.readListBegin()
7133 
          for _i55 in xrange(_size51):
7134 
            _elem56 = Item()
7135 
            _elem56.read(iprot)
7136 
            self.success.append(_elem56)
7137 
          iprot.readListEnd()
7138 
        else:
7139 
          iprot.skip(ftype)
7140 
      elif fid == 1:
7141 
        if ftype == TType.STRUCT:
7142 
          self.cex = CatalogServiceException()
7143 
          self.cex.read(iprot)
7144 
        else:
7145 
          iprot.skip(ftype)
7146 
      else:
7147 
        iprot.skip(ftype)
7148 
      iprot.readFieldEnd()
7149 
    iprot.readStructEnd()
7150 
 
7151 
  def write(self, oprot):
7152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7154 
      return
7155 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7156 
    if self.success is not None:
7157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7159 
      for iter57 in self.success:
7160 
        iter57.write(oprot)
7161 
      oprot.writeListEnd()
7162 
      oprot.writeFieldEnd()
7163 
    if self.cex is not None:
7164 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7165 
      self.cex.write(oprot)
7166 
      oprot.writeFieldEnd()
7167 
    oprot.writeFieldStop()
7168 
    oprot.writeStructEnd()
7169 
 
7170 
  def validate(self):
7171 
    return
7172 
 
7173 
 
7174 
  def __repr__(self):
7175 
    L = ['%s=%r' % (key, value)
7176 
      for key, value in self.__dict__.iteritems()]
7177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7178 
 
7179 
  def __eq__(self, other):
7180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7181 
 
7182 
  def __ne__(self, other):
7183 
    return not (self == other)
7184 
 
7185 
class getItemCountByStatus_args:
7186 
  """
7187 
  Attributes:
7188 
   - useStatus
7189 
   - itemStatus
7190 
  """
7191 
 
7192 
  thrift_spec = (
7193 
    None, # 0
7194 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7195 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7196 
  )
7197 
 
7198 
  def __init__(self, useStatus=None, itemStatus=None,):
7199 
    self.useStatus = useStatus
7200 
    self.itemStatus = itemStatus
7201 
 
7202 
  def read(self, iprot):
7203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7205 
      return
7206 
    iprot.readStructBegin()
7207 
    while True:
7208 
      (fname, ftype, fid) = iprot.readFieldBegin()
7209 
      if ftype == TType.STOP:
7210 
        break
7211 
      if fid == 1:
7212 
        if ftype == TType.BOOL:
7213 
          self.useStatus = iprot.readBool();
7214 
        else:
7215 
          iprot.skip(ftype)
7216 
      elif fid == 2:
7217 
        if ftype == TType.I32:
7218 
          self.itemStatus = iprot.readI32();
7219 
        else:
7220 
          iprot.skip(ftype)
7221 
      else:
7222 
        iprot.skip(ftype)
7223 
      iprot.readFieldEnd()
7224 
    iprot.readStructEnd()
7225 
 
7226 
  def write(self, oprot):
7227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7229 
      return
7230 
    oprot.writeStructBegin('getItemCountByStatus_args')
7231 
    if self.useStatus is not None:
7232 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7233 
      oprot.writeBool(self.useStatus)
7234 
      oprot.writeFieldEnd()
7235 
    if self.itemStatus is not None:
7236 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7237 
      oprot.writeI32(self.itemStatus)
7238 
      oprot.writeFieldEnd()
7239 
    oprot.writeFieldStop()
7240 
    oprot.writeStructEnd()
7241 
 
7242 
  def validate(self):
7243 
    return
7244 
 
7245 
 
7246 
  def __repr__(self):
7247 
    L = ['%s=%r' % (key, value)
7248 
      for key, value in self.__dict__.iteritems()]
7249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7250 
 
7251 
  def __eq__(self, other):
7252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7253 
 
7254 
  def __ne__(self, other):
7255 
    return not (self == other)
7256 
 
7257 
class getItemCountByStatus_result:
7258 
  """
7259 
  Attributes:
7260 
   - success
7261 
  """
7262 
 
7263 
  thrift_spec = (
7264 
    (0, TType.I32, 'success', None, None, ), # 0
7265 
  )
7266 
 
7267 
  def __init__(self, success=None,):
7268 
    self.success = success
7269 
 
7270 
  def read(self, iprot):
7271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7273 
      return
7274 
    iprot.readStructBegin()
7275 
    while True:
7276 
      (fname, ftype, fid) = iprot.readFieldBegin()
7277 
      if ftype == TType.STOP:
7278 
        break
7279 
      if fid == 0:
7280 
        if ftype == TType.I32:
7281 
          self.success = iprot.readI32();
7282 
        else:
7283 
          iprot.skip(ftype)
7284 
      else:
7285 
        iprot.skip(ftype)
7286 
      iprot.readFieldEnd()
7287 
    iprot.readStructEnd()
7288 
 
7289 
  def write(self, oprot):
7290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7292 
      return
7293 
    oprot.writeStructBegin('getItemCountByStatus_result')
7294 
    if self.success is not None:
7295 
      oprot.writeFieldBegin('success', TType.I32, 0)
7296 
      oprot.writeI32(self.success)
7297 
      oprot.writeFieldEnd()
7298 
    oprot.writeFieldStop()
7299 
    oprot.writeStructEnd()
7300 
 
7301 
  def validate(self):
7302 
    return
7303 
 
7304 
 
7305 
  def __repr__(self):
7306 
    L = ['%s=%r' % (key, value)
7307 
      for key, value in self.__dict__.iteritems()]
7308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7309 
 
7310 
  def __eq__(self, other):
7311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7312 
 
7313 
  def __ne__(self, other):
7314 
    return not (self == other)
7315 
 
7316 
class getBestSellers_args:
7317 
 
7318 
  thrift_spec = (
7319 
  )
7320 
 
7321 
  def read(self, iprot):
7322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7324 
      return
7325 
    iprot.readStructBegin()
7326 
    while True:
7327 
      (fname, ftype, fid) = iprot.readFieldBegin()
7328 
      if ftype == TType.STOP:
7329 
        break
7330 
      else:
7331 
        iprot.skip(ftype)
7332 
      iprot.readFieldEnd()
7333 
    iprot.readStructEnd()
7334 
 
7335 
  def write(self, oprot):
7336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7338 
      return
7339 
    oprot.writeStructBegin('getBestSellers_args')
7340 
    oprot.writeFieldStop()
7341 
    oprot.writeStructEnd()
7342 
 
7343 
  def validate(self):
7344 
    return
7345 
 
7346 
 
7347 
  def __repr__(self):
7348 
    L = ['%s=%r' % (key, value)
7349 
      for key, value in self.__dict__.iteritems()]
7350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7351 
 
7352 
  def __eq__(self, other):
7353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7354 
 
7355 
  def __ne__(self, other):
7356 
    return not (self == other)
7357 
 
7358 
class getBestSellers_result:
7359 
  """
7360 
  Attributes:
7361 
   - success
7362 
   - isex
7363 
  """
7364 
 
7365 
  thrift_spec = (
7366 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7367 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7368 
  )
7369 
 
7370 
  def __init__(self, success=None, isex=None,):
7371 
    self.success = success
7372 
    self.isex = isex
7373 
 
7374 
  def read(self, iprot):
7375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7377 
      return
7378 
    iprot.readStructBegin()
7379 
    while True:
7380 
      (fname, ftype, fid) = iprot.readFieldBegin()
7381 
      if ftype == TType.STOP:
7382 
        break
7383 
      if fid == 0:
7384 
        if ftype == TType.LIST:
7385 
          self.success = []
7386 
          (_etype61, _size58) = iprot.readListBegin()
7387 
          for _i62 in xrange(_size58):
7388 
            _elem63 = Item()
7389 
            _elem63.read(iprot)
7390 
            self.success.append(_elem63)
7391 
          iprot.readListEnd()
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      elif fid == 1:
7395 
        if ftype == TType.STRUCT:
7396 
          self.isex = CatalogServiceException()
7397 
          self.isex.read(iprot)
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      else:
7401 
        iprot.skip(ftype)
7402 
      iprot.readFieldEnd()
7403 
    iprot.readStructEnd()
7404 
 
7405 
  def write(self, oprot):
7406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7408 
      return
7409 
    oprot.writeStructBegin('getBestSellers_result')
7410 
    if self.success is not None:
7411 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7412 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7413 
      for iter64 in self.success:
7414 
        iter64.write(oprot)
7415 
      oprot.writeListEnd()
7416 
      oprot.writeFieldEnd()
7417 
    if self.isex is not None:
7418 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7419 
      self.isex.write(oprot)
7420 
      oprot.writeFieldEnd()
7421 
    oprot.writeFieldStop()
7422 
    oprot.writeStructEnd()
7423 
 
7424 
  def validate(self):
7425 
    return
7426 
 
7427 
 
7428 
  def __repr__(self):
7429 
    L = ['%s=%r' % (key, value)
7430 
      for key, value in self.__dict__.iteritems()]
7431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7432 
 
7433 
  def __eq__(self, other):
7434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7435 
 
7436 
  def __ne__(self, other):
7437 
    return not (self == other)
7438 
 
7439 
class getBestSellersCatalogIds_args:
7440 
  """
7441 
  Attributes:
7442 
   - beginIndex
7443 
   - totalItems
7444 
   - brand
7445 
   - category
7446 
  """
7447 
 
7448 
  thrift_spec = (
7449 
    None, # 0
7450 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7451 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7452 
    (3, TType.STRING, 'brand', None, None, ), # 3
7453 
    (4, TType.I64, 'category', None, None, ), # 4
7454 
  )
7455 
 
7456 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7457 
    self.beginIndex = beginIndex
7458 
    self.totalItems = totalItems
7459 
    self.brand = brand
7460 
    self.category = category
7461 
 
7462 
  def read(self, iprot):
7463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7465 
      return
7466 
    iprot.readStructBegin()
7467 
    while True:
7468 
      (fname, ftype, fid) = iprot.readFieldBegin()
7469 
      if ftype == TType.STOP:
7470 
        break
7471 
      if fid == 1:
7472 
        if ftype == TType.I64:
7473 
          self.beginIndex = iprot.readI64();
7474 
        else:
7475 
          iprot.skip(ftype)
7476 
      elif fid == 2:
7477 
        if ftype == TType.I64:
7478 
          self.totalItems = iprot.readI64();
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 3:
7482 
        if ftype == TType.STRING:
7483 
          self.brand = iprot.readString();
7484 
        else:
7485 
          iprot.skip(ftype)
7486 
      elif fid == 4:
7487 
        if ftype == TType.I64:
7488 
          self.category = iprot.readI64();
7489 
        else:
7490 
          iprot.skip(ftype)
7491 
      else:
7492 
        iprot.skip(ftype)
7493 
      iprot.readFieldEnd()
7494 
    iprot.readStructEnd()
7495 
 
7496 
  def write(self, oprot):
7497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7499 
      return
7500 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7501 
    if self.beginIndex is not None:
7502 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7503 
      oprot.writeI64(self.beginIndex)
7504 
      oprot.writeFieldEnd()
7505 
    if self.totalItems is not None:
7506 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7507 
      oprot.writeI64(self.totalItems)
7508 
      oprot.writeFieldEnd()
7509 
    if self.brand is not None:
7510 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7511 
      oprot.writeString(self.brand)
7512 
      oprot.writeFieldEnd()
7513 
    if self.category is not None:
7514 
      oprot.writeFieldBegin('category', TType.I64, 4)
7515 
      oprot.writeI64(self.category)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
7520 
  def validate(self):
7521 
    return
7522 
 
7523 
 
7524 
  def __repr__(self):
7525 
    L = ['%s=%r' % (key, value)
7526 
      for key, value in self.__dict__.iteritems()]
7527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7528 
 
7529 
  def __eq__(self, other):
7530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7531 
 
7532 
  def __ne__(self, other):
7533 
    return not (self == other)
7534 
 
7535 
class getBestSellersCatalogIds_result:
7536 
  """
7537 
  Attributes:
7538 
   - success
7539 
   - cex
7540 
  """
7541 
 
7542 
  thrift_spec = (
7543 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7544 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7545 
  )
7546 
 
7547 
  def __init__(self, success=None, cex=None,):
7548 
    self.success = success
7549 
    self.cex = cex
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      if fid == 0:
7561 
        if ftype == TType.LIST:
7562 
          self.success = []
7563 
          (_etype68, _size65) = iprot.readListBegin()
7564 
          for _i69 in xrange(_size65):
7565 
            _elem70 = iprot.readI64();
7566 
            self.success.append(_elem70)
7567 
          iprot.readListEnd()
7568 
        else:
7569 
          iprot.skip(ftype)
7570 
      elif fid == 1:
7571 
        if ftype == TType.STRUCT:
7572 
          self.cex = CatalogServiceException()
7573 
          self.cex.read(iprot)
7574 
        else:
7575 
          iprot.skip(ftype)
7576 
      else:
7577 
        iprot.skip(ftype)
7578 
      iprot.readFieldEnd()
7579 
    iprot.readStructEnd()
7580 
 
7581 
  def write(self, oprot):
7582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7584 
      return
7585 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7586 
    if self.success is not None:
7587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7588 
      oprot.writeListBegin(TType.I64, len(self.success))
7589 
      for iter71 in self.success:
7590 
        oprot.writeI64(iter71)
7591 
      oprot.writeListEnd()
7592 
      oprot.writeFieldEnd()
7593 
    if self.cex is not None:
7594 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7595 
      self.cex.write(oprot)
7596 
      oprot.writeFieldEnd()
7597 
    oprot.writeFieldStop()
7598 
    oprot.writeStructEnd()
7599 
 
7600 
  def validate(self):
7601 
    return
7602 
 
7603 
 
7604 
  def __repr__(self):
7605 
    L = ['%s=%r' % (key, value)
7606 
      for key, value in self.__dict__.iteritems()]
7607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7608 
 
7609 
  def __eq__(self, other):
7610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7611 
 
7612 
  def __ne__(self, other):
7613 
    return not (self == other)
7614 
 
7615 
class getBestSellersCount_args:
7616 
 
7617 
  thrift_spec = (
7618 
  )
7619 
 
7620 
  def read(self, iprot):
7621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7623 
      return
7624 
    iprot.readStructBegin()
7625 
    while True:
7626 
      (fname, ftype, fid) = iprot.readFieldBegin()
7627 
      if ftype == TType.STOP:
7628 
        break
7629 
      else:
7630 
        iprot.skip(ftype)
7631 
      iprot.readFieldEnd()
7632 
    iprot.readStructEnd()
7633 
 
7634 
  def write(self, oprot):
7635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7637 
      return
7638 
    oprot.writeStructBegin('getBestSellersCount_args')
7639 
    oprot.writeFieldStop()
7640 
    oprot.writeStructEnd()
7641 
 
7642 
  def validate(self):
7643 
    return
7644 
 
7645 
 
7646 
  def __repr__(self):
7647 
    L = ['%s=%r' % (key, value)
7648 
      for key, value in self.__dict__.iteritems()]
7649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7650 
 
7651 
  def __eq__(self, other):
7652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7653 
 
7654 
  def __ne__(self, other):
7655 
    return not (self == other)
7656 
 
7657 
class getBestSellersCount_result:
7658 
  """
7659 
  Attributes:
7660 
   - success
7661 
   - cex
7662 
  """
7663 
 
7664 
  thrift_spec = (
7665 
    (0, TType.I64, 'success', None, None, ), # 0
7666 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7667 
  )
7668 
 
7669 
  def __init__(self, success=None, cex=None,):
7670 
    self.success = success
7671 
    self.cex = cex
7672 
 
7673 
  def read(self, iprot):
7674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7676 
      return
7677 
    iprot.readStructBegin()
7678 
    while True:
7679 
      (fname, ftype, fid) = iprot.readFieldBegin()
7680 
      if ftype == TType.STOP:
7681 
        break
7682 
      if fid == 0:
7683 
        if ftype == TType.I64:
7684 
          self.success = iprot.readI64();
7685 
        else:
7686 
          iprot.skip(ftype)
7687 
      elif fid == 1:
7688 
        if ftype == TType.STRUCT:
7689 
          self.cex = CatalogServiceException()
7690 
          self.cex.read(iprot)
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      else:
7694 
        iprot.skip(ftype)
7695 
      iprot.readFieldEnd()
7696 
    iprot.readStructEnd()
7697 
 
7698 
  def write(self, oprot):
7699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7701 
      return
7702 
    oprot.writeStructBegin('getBestSellersCount_result')
7703 
    if self.success is not None:
7704 
      oprot.writeFieldBegin('success', TType.I64, 0)
7705 
      oprot.writeI64(self.success)
7706 
      oprot.writeFieldEnd()
7707 
    if self.cex is not None:
7708 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7709 
      self.cex.write(oprot)
7710 
      oprot.writeFieldEnd()
7711 
    oprot.writeFieldStop()
7712 
    oprot.writeStructEnd()
7713 
 
7714 
  def validate(self):
7715 
    return
7716 
 
7717 
 
7718 
  def __repr__(self):
7719 
    L = ['%s=%r' % (key, value)
7720 
      for key, value in self.__dict__.iteritems()]
7721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7722 
 
7723 
  def __eq__(self, other):
7724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7725 
 
7726 
  def __ne__(self, other):
7727 
    return not (self == other)
7728 
 
7729 
class getBestDeals_args:
7730 
 
7731 
  thrift_spec = (
7732 
  )
7733 
 
7734 
  def read(self, iprot):
7735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7737 
      return
7738 
    iprot.readStructBegin()
7739 
    while True:
7740 
      (fname, ftype, fid) = iprot.readFieldBegin()
7741 
      if ftype == TType.STOP:
7742 
        break
7743 
      else:
7744 
        iprot.skip(ftype)
7745 
      iprot.readFieldEnd()
7746 
    iprot.readStructEnd()
7747 
 
7748 
  def write(self, oprot):
7749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7751 
      return
7752 
    oprot.writeStructBegin('getBestDeals_args')
7753 
    oprot.writeFieldStop()
7754 
    oprot.writeStructEnd()
7755 
 
7756 
  def validate(self):
7757 
    return
7758 
 
7759 
 
7760 
  def __repr__(self):
7761 
    L = ['%s=%r' % (key, value)
7762 
      for key, value in self.__dict__.iteritems()]
7763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7764 
 
7765 
  def __eq__(self, other):
7766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7767 
 
7768 
  def __ne__(self, other):
7769 
    return not (self == other)
7770 
 
7771 
class getBestDeals_result:
7772 
  """
7773 
  Attributes:
7774 
   - success
7775 
   - isex
7776 
  """
7777 
 
7778 
  thrift_spec = (
7779 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7780 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7781 
  )
7782 
 
7783 
  def __init__(self, success=None, isex=None,):
7784 
    self.success = success
7785 
    self.isex = isex
7786 
 
7787 
  def read(self, iprot):
7788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7790 
      return
7791 
    iprot.readStructBegin()
7792 
    while True:
7793 
      (fname, ftype, fid) = iprot.readFieldBegin()
7794 
      if ftype == TType.STOP:
7795 
        break
7796 
      if fid == 0:
7797 
        if ftype == TType.LIST:
7798 
          self.success = []
7799 
          (_etype75, _size72) = iprot.readListBegin()
7800 
          for _i76 in xrange(_size72):
7801 
            _elem77 = Item()
7802 
            _elem77.read(iprot)
7803 
            self.success.append(_elem77)
7804 
          iprot.readListEnd()
7805 
        else:
7806 
          iprot.skip(ftype)
7807 
      elif fid == 1:
7808 
        if ftype == TType.STRUCT:
7809 
          self.isex = CatalogServiceException()
7810 
          self.isex.read(iprot)
7811 
        else:
7812 
          iprot.skip(ftype)
7813 
      else:
7814 
        iprot.skip(ftype)
7815 
      iprot.readFieldEnd()
7816 
    iprot.readStructEnd()
7817 
 
7818 
  def write(self, oprot):
7819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7821 
      return
7822 
    oprot.writeStructBegin('getBestDeals_result')
7823 
    if self.success is not None:
7824 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7825 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7826 
      for iter78 in self.success:
7827 
        iter78.write(oprot)
7828 
      oprot.writeListEnd()
7829 
      oprot.writeFieldEnd()
7830 
    if self.isex is not None:
7831 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7832 
      self.isex.write(oprot)
7833 
      oprot.writeFieldEnd()
7834 
    oprot.writeFieldStop()
7835 
    oprot.writeStructEnd()
7836 
 
7837 
  def validate(self):
7838 
    return
7839 
 
7840 
 
7841 
  def __repr__(self):
7842 
    L = ['%s=%r' % (key, value)
7843 
      for key, value in self.__dict__.iteritems()]
7844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7845 
 
7846 
  def __eq__(self, other):
7847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7848 
 
7849 
  def __ne__(self, other):
7850 
    return not (self == other)
7851 
 
7852 
class getBestDealsCatalogIds_args:
7853 
  """
7854 
  Attributes:
7855 
   - beginIndex
7856 
   - totalItems
7857 
   - brand
7858 
   - category
7859 
  """
7860 
 
7861 
  thrift_spec = (
7862 
    None, # 0
7863 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7864 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7865 
    (3, TType.STRING, 'brand', None, None, ), # 3
7866 
    (4, TType.I64, 'category', None, None, ), # 4
7867 
  )
7868 
 
7869 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7870 
    self.beginIndex = beginIndex
7871 
    self.totalItems = totalItems
7872 
    self.brand = brand
7873 
    self.category = category
7874 
 
7875 
  def read(self, iprot):
7876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7878 
      return
7879 
    iprot.readStructBegin()
7880 
    while True:
7881 
      (fname, ftype, fid) = iprot.readFieldBegin()
7882 
      if ftype == TType.STOP:
7883 
        break
7884 
      if fid == 1:
7885 
        if ftype == TType.I64:
7886 
          self.beginIndex = iprot.readI64();
7887 
        else:
7888 
          iprot.skip(ftype)
7889 
      elif fid == 2:
7890 
        if ftype == TType.I64:
7891 
          self.totalItems = iprot.readI64();
7892 
        else:
7893 
          iprot.skip(ftype)
7894 
      elif fid == 3:
7895 
        if ftype == TType.STRING:
7896 
          self.brand = iprot.readString();
7897 
        else:
7898 
          iprot.skip(ftype)
7899 
      elif fid == 4:
7900 
        if ftype == TType.I64:
7901 
          self.category = iprot.readI64();
7902 
        else:
7903 
          iprot.skip(ftype)
7904 
      else:
7905 
        iprot.skip(ftype)
7906 
      iprot.readFieldEnd()
7907 
    iprot.readStructEnd()
7908 
 
7909 
  def write(self, oprot):
7910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7912 
      return
7913 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
7914 
    if self.beginIndex is not None:
7915 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7916 
      oprot.writeI64(self.beginIndex)
7917 
      oprot.writeFieldEnd()
7918 
    if self.totalItems is not None:
7919 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7920 
      oprot.writeI64(self.totalItems)
7921 
      oprot.writeFieldEnd()
7922 
    if self.brand is not None:
7923 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7924 
      oprot.writeString(self.brand)
7925 
      oprot.writeFieldEnd()
7926 
    if self.category is not None:
7927 
      oprot.writeFieldBegin('category', TType.I64, 4)
7928 
      oprot.writeI64(self.category)
7929 
      oprot.writeFieldEnd()
7930 
    oprot.writeFieldStop()
7931 
    oprot.writeStructEnd()
7932 
 
7933 
  def validate(self):
7934 
    return
7935 
 
7936 
 
7937 
  def __repr__(self):
7938 
    L = ['%s=%r' % (key, value)
7939 
      for key, value in self.__dict__.iteritems()]
7940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7941 
 
7942 
  def __eq__(self, other):
7943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7944 
 
7945 
  def __ne__(self, other):
7946 
    return not (self == other)
7947 
 
7948 
class getBestDealsCatalogIds_result:
7949 
  """
7950 
  Attributes:
7951 
   - success
7952 
   - cex
7953 
  """
7954 
 
7955 
  thrift_spec = (
7956 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7957 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7958 
  )
7959 
 
7960 
  def __init__(self, success=None, cex=None,):
7961 
    self.success = success
7962 
    self.cex = cex
7963 
 
7964 
  def read(self, iprot):
7965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7967 
      return
7968 
    iprot.readStructBegin()
7969 
    while True:
7970 
      (fname, ftype, fid) = iprot.readFieldBegin()
7971 
      if ftype == TType.STOP:
7972 
        break
7973 
      if fid == 0:
7974 
        if ftype == TType.LIST:
7975 
          self.success = []
7976 
          (_etype82, _size79) = iprot.readListBegin()
7977 
          for _i83 in xrange(_size79):
7978 
            _elem84 = iprot.readI64();
7979 
            self.success.append(_elem84)
7980 
          iprot.readListEnd()
7981 
        else:
7982 
          iprot.skip(ftype)
7983 
      elif fid == 1:
7984 
        if ftype == TType.STRUCT:
7985 
          self.cex = CatalogServiceException()
7986 
          self.cex.read(iprot)
7987 
        else:
7988 
          iprot.skip(ftype)
7989 
      else:
7990 
        iprot.skip(ftype)
7991 
      iprot.readFieldEnd()
7992 
    iprot.readStructEnd()
7993 
 
7994 
  def write(self, oprot):
7995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7997 
      return
7998 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
7999 
    if self.success is not None:
8000 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8001 
      oprot.writeListBegin(TType.I64, len(self.success))
8002 
      for iter85 in self.success:
8003 
        oprot.writeI64(iter85)
8004 
      oprot.writeListEnd()
8005 
      oprot.writeFieldEnd()
8006 
    if self.cex is not None:
8007 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8008 
      self.cex.write(oprot)
8009 
      oprot.writeFieldEnd()
8010 
    oprot.writeFieldStop()
8011 
    oprot.writeStructEnd()
8012 
 
8013 
  def validate(self):
8014 
    return
8015 
 
8016 
 
8017 
  def __repr__(self):
8018 
    L = ['%s=%r' % (key, value)
8019 
      for key, value in self.__dict__.iteritems()]
8020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8021 
 
8022 
  def __eq__(self, other):
8023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8024 
 
8025 
  def __ne__(self, other):
8026 
    return not (self == other)
8027 
 
8028 
class getBestDealsCount_args:
8029 
 
8030 
  thrift_spec = (
8031 
  )
8032 
 
8033 
  def read(self, iprot):
8034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8036 
      return
8037 
    iprot.readStructBegin()
8038 
    while True:
8039 
      (fname, ftype, fid) = iprot.readFieldBegin()
8040 
      if ftype == TType.STOP:
8041 
        break
8042 
      else:
8043 
        iprot.skip(ftype)
8044 
      iprot.readFieldEnd()
8045 
    iprot.readStructEnd()
8046 
 
8047 
  def write(self, oprot):
8048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8050 
      return
8051 
    oprot.writeStructBegin('getBestDealsCount_args')
8052 
    oprot.writeFieldStop()
8053 
    oprot.writeStructEnd()
8054 
 
8055 
  def validate(self):
8056 
    return
8057 
 
8058 
 
8059 
  def __repr__(self):
8060 
    L = ['%s=%r' % (key, value)
8061 
      for key, value in self.__dict__.iteritems()]
8062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8063 
 
8064 
  def __eq__(self, other):
8065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8066 
 
8067 
  def __ne__(self, other):
8068 
    return not (self == other)
8069 
 
8070 
class getBestDealsCount_result:
8071 
  """
8072 
  Attributes:
8073 
   - success
8074 
   - cex
8075 
  """
8076 
 
8077 
  thrift_spec = (
8078 
    (0, TType.I64, 'success', None, None, ), # 0
8079 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8080 
  )
8081 
 
8082 
  def __init__(self, success=None, cex=None,):
8083 
    self.success = success
8084 
    self.cex = cex
8085 
 
8086 
  def read(self, iprot):
8087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8089 
      return
8090 
    iprot.readStructBegin()
8091 
    while True:
8092 
      (fname, ftype, fid) = iprot.readFieldBegin()
8093 
      if ftype == TType.STOP:
8094 
        break
8095 
      if fid == 0:
8096 
        if ftype == TType.I64:
8097 
          self.success = iprot.readI64();
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      elif fid == 1:
8101 
        if ftype == TType.STRUCT:
8102 
          self.cex = CatalogServiceException()
8103 
          self.cex.read(iprot)
8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      else:
8107 
        iprot.skip(ftype)
8108 
      iprot.readFieldEnd()
8109 
    iprot.readStructEnd()
8110 
 
8111 
  def write(self, oprot):
8112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8114 
      return
8115 
    oprot.writeStructBegin('getBestDealsCount_result')
8116 
    if self.success is not None:
8117 
      oprot.writeFieldBegin('success', TType.I64, 0)
8118 
      oprot.writeI64(self.success)
8119 
      oprot.writeFieldEnd()
8120 
    if self.cex is not None:
8121 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8122 
      self.cex.write(oprot)
8123 
      oprot.writeFieldEnd()
8124 
    oprot.writeFieldStop()
8125 
    oprot.writeStructEnd()
8126 
 
8127 
  def validate(self):
8128 
    return
8129 
 
8130 
 
8131 
  def __repr__(self):
8132 
    L = ['%s=%r' % (key, value)
8133 
      for key, value in self.__dict__.iteritems()]
8134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8135 
 
8136 
  def __eq__(self, other):
8137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8138 
 
8139 
  def __ne__(self, other):
8140 
    return not (self == other)
8141 
 
8142 
class getComingSoon_args:
8143 
 
8144 
  thrift_spec = (
8145 
  )
8146 
 
8147 
  def read(self, iprot):
8148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8150 
      return
8151 
    iprot.readStructBegin()
8152 
    while True:
8153 
      (fname, ftype, fid) = iprot.readFieldBegin()
8154 
      if ftype == TType.STOP:
8155 
        break
8156 
      else:
8157 
        iprot.skip(ftype)
8158 
      iprot.readFieldEnd()
8159 
    iprot.readStructEnd()
8160 
 
8161 
  def write(self, oprot):
8162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8164 
      return
8165 
    oprot.writeStructBegin('getComingSoon_args')
8166 
    oprot.writeFieldStop()
8167 
    oprot.writeStructEnd()
8168 
 
8169 
  def validate(self):
8170 
    return
8171 
 
8172 
 
8173 
  def __repr__(self):
8174 
    L = ['%s=%r' % (key, value)
8175 
      for key, value in self.__dict__.iteritems()]
8176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8177 
 
8178 
  def __eq__(self, other):
8179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8180 
 
8181 
  def __ne__(self, other):
8182 
    return not (self == other)
8183 
 
8184 
class getComingSoon_result:
8185 
  """
8186 
  Attributes:
8187 
   - success
8188 
   - isex
8189 
  """
8190 
 
8191 
  thrift_spec = (
8192 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8193 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8194 
  )
8195 
 
8196 
  def __init__(self, success=None, isex=None,):
8197 
    self.success = success
8198 
    self.isex = isex
8199 
 
8200 
  def read(self, iprot):
8201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8203 
      return
8204 
    iprot.readStructBegin()
8205 
    while True:
8206 
      (fname, ftype, fid) = iprot.readFieldBegin()
8207 
      if ftype == TType.STOP:
8208 
        break
8209 
      if fid == 0:
8210 
        if ftype == TType.LIST:
8211 
          self.success = []
8212 
          (_etype89, _size86) = iprot.readListBegin()
8213 
          for _i90 in xrange(_size86):
8214 
            _elem91 = Item()
8215 
            _elem91.read(iprot)
8216 
            self.success.append(_elem91)
8217 
          iprot.readListEnd()
8218 
        else:
8219 
          iprot.skip(ftype)
8220 
      elif fid == 1:
8221 
        if ftype == TType.STRUCT:
8222 
          self.isex = CatalogServiceException()
8223 
          self.isex.read(iprot)
8224 
        else:
8225 
          iprot.skip(ftype)
8226 
      else:
8227 
        iprot.skip(ftype)
8228 
      iprot.readFieldEnd()
8229 
    iprot.readStructEnd()
8230 
 
8231 
  def write(self, oprot):
8232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8234 
      return
8235 
    oprot.writeStructBegin('getComingSoon_result')
8236 
    if self.success is not None:
8237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8238 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8239 
      for iter92 in self.success:
8240 
        iter92.write(oprot)
8241 
      oprot.writeListEnd()
8242 
      oprot.writeFieldEnd()
8243 
    if self.isex is not None:
8244 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8245 
      self.isex.write(oprot)
8246 
      oprot.writeFieldEnd()
8247 
    oprot.writeFieldStop()
8248 
    oprot.writeStructEnd()
8249 
 
8250 
  def validate(self):
8251 
    return
8252 
 
8253 
 
8254 
  def __repr__(self):
8255 
    L = ['%s=%r' % (key, value)
8256 
      for key, value in self.__dict__.iteritems()]
8257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8258 
 
8259 
  def __eq__(self, other):
8260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8261 
 
8262 
  def __ne__(self, other):
8263 
    return not (self == other)
8264 
 
8265 
class getComingSoonCatalogIds_args:
8266 
  """
8267 
  Attributes:
8268 
   - beginIndex
8269 
   - totalItems
8270 
   - brand
8271 
   - category
8272 
  """
8273 
 
8274 
  thrift_spec = (
8275 
    None, # 0
8276 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8277 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8278 
    (3, TType.STRING, 'brand', None, None, ), # 3
8279 
    (4, TType.I64, 'category', None, None, ), # 4
8280 
  )
8281 
 
8282 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8283 
    self.beginIndex = beginIndex
8284 
    self.totalItems = totalItems
8285 
    self.brand = brand
8286 
    self.category = category
8287 
 
8288 
  def read(self, iprot):
8289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8291 
      return
8292 
    iprot.readStructBegin()
8293 
    while True:
8294 
      (fname, ftype, fid) = iprot.readFieldBegin()
8295 
      if ftype == TType.STOP:
8296 
        break
8297 
      if fid == 1:
8298 
        if ftype == TType.I64:
8299 
          self.beginIndex = iprot.readI64();
8300 
        else:
8301 
          iprot.skip(ftype)
8302 
      elif fid == 2:
8303 
        if ftype == TType.I64:
8304 
          self.totalItems = iprot.readI64();
8305 
        else:
8306 
          iprot.skip(ftype)
8307 
      elif fid == 3:
8308 
        if ftype == TType.STRING:
8309 
          self.brand = iprot.readString();
8310 
        else:
8311 
          iprot.skip(ftype)
8312 
      elif fid == 4:
8313 
        if ftype == TType.I64:
8314 
          self.category = iprot.readI64();
8315 
        else:
8316 
          iprot.skip(ftype)
8317 
      else:
8318 
        iprot.skip(ftype)
8319 
      iprot.readFieldEnd()
8320 
    iprot.readStructEnd()
8321 
 
8322 
  def write(self, oprot):
8323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8325 
      return
8326 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8327 
    if self.beginIndex is not None:
8328 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8329 
      oprot.writeI64(self.beginIndex)
8330 
      oprot.writeFieldEnd()
8331 
    if self.totalItems is not None:
8332 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8333 
      oprot.writeI64(self.totalItems)
8334 
      oprot.writeFieldEnd()
8335 
    if self.brand is not None:
8336 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8337 
      oprot.writeString(self.brand)
8338 
      oprot.writeFieldEnd()
8339 
    if self.category is not None:
8340 
      oprot.writeFieldBegin('category', TType.I64, 4)
8341 
      oprot.writeI64(self.category)
8342 
      oprot.writeFieldEnd()
8343 
    oprot.writeFieldStop()
8344 
    oprot.writeStructEnd()
8345 
 
8346 
  def validate(self):
8347 
    return
8348 
 
8349 
 
8350 
  def __repr__(self):
8351 
    L = ['%s=%r' % (key, value)
8352 
      for key, value in self.__dict__.iteritems()]
8353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8354 
 
8355 
  def __eq__(self, other):
8356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8357 
 
8358 
  def __ne__(self, other):
8359 
    return not (self == other)
8360 
 
8361 
class getComingSoonCatalogIds_result:
8362 
  """
8363 
  Attributes:
8364 
   - success
8365 
   - cex
8366 
  """
8367 
 
8368 
  thrift_spec = (
8369 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8370 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8371 
  )
8372 
 
8373 
  def __init__(self, success=None, cex=None,):
8374 
    self.success = success
8375 
    self.cex = cex
8376 
 
8377 
  def read(self, iprot):
8378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8380 
      return
8381 
    iprot.readStructBegin()
8382 
    while True:
8383 
      (fname, ftype, fid) = iprot.readFieldBegin()
8384 
      if ftype == TType.STOP:
8385 
        break
8386 
      if fid == 0:
8387 
        if ftype == TType.LIST:
8388 
          self.success = []
8389 
          (_etype96, _size93) = iprot.readListBegin()
8390 
          for _i97 in xrange(_size93):
8391 
            _elem98 = iprot.readI64();
8392 
            self.success.append(_elem98)
8393 
          iprot.readListEnd()
8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      elif fid == 1:
8397 
        if ftype == TType.STRUCT:
8398 
          self.cex = CatalogServiceException()
8399 
          self.cex.read(iprot)
8400 
        else:
8401 
          iprot.skip(ftype)
8402 
      else:
8403 
        iprot.skip(ftype)
8404 
      iprot.readFieldEnd()
8405 
    iprot.readStructEnd()
8406 
 
8407 
  def write(self, oprot):
8408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8410 
      return
8411 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8412 
    if self.success is not None:
8413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8414 
      oprot.writeListBegin(TType.I64, len(self.success))
8415 
      for iter99 in self.success:
8416 
        oprot.writeI64(iter99)
8417 
      oprot.writeListEnd()
8418 
      oprot.writeFieldEnd()
8419 
    if self.cex is not None:
8420 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8421 
      self.cex.write(oprot)
8422 
      oprot.writeFieldEnd()
8423 
    oprot.writeFieldStop()
8424 
    oprot.writeStructEnd()
8425 
 
8426 
  def validate(self):
8427 
    return
8428 
 
8429 
 
8430 
  def __repr__(self):
8431 
    L = ['%s=%r' % (key, value)
8432 
      for key, value in self.__dict__.iteritems()]
8433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8434 
 
8435 
  def __eq__(self, other):
8436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8437 
 
8438 
  def __ne__(self, other):
8439 
    return not (self == other)
8440 
 
8441 
class getComingSoonCount_args:
8442 
 
8443 
  thrift_spec = (
8444 
  )
8445 
 
8446 
  def read(self, iprot):
8447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8449 
      return
8450 
    iprot.readStructBegin()
8451 
    while True:
8452 
      (fname, ftype, fid) = iprot.readFieldBegin()
8453 
      if ftype == TType.STOP:
8454 
        break
8455 
      else:
8456 
        iprot.skip(ftype)
8457 
      iprot.readFieldEnd()
8458 
    iprot.readStructEnd()
8459 
 
8460 
  def write(self, oprot):
8461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8463 
      return
8464 
    oprot.writeStructBegin('getComingSoonCount_args')
8465 
    oprot.writeFieldStop()
8466 
    oprot.writeStructEnd()
8467 
 
8468 
  def validate(self):
8469 
    return
8470 
 
8471 
 
8472 
  def __repr__(self):
8473 
    L = ['%s=%r' % (key, value)
8474 
      for key, value in self.__dict__.iteritems()]
8475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8476 
 
8477 
  def __eq__(self, other):
8478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8479 
 
8480 
  def __ne__(self, other):
8481 
    return not (self == other)
8482 
 
8483 
class getComingSoonCount_result:
8484 
  """
8485 
  Attributes:
8486 
   - success
8487 
   - cex
8488 
  """
8489 
 
8490 
  thrift_spec = (
8491 
    (0, TType.I64, 'success', None, None, ), # 0
8492 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8493 
  )
8494 
 
8495 
  def __init__(self, success=None, cex=None,):
8496 
    self.success = success
8497 
    self.cex = cex
8498 
 
8499 
  def read(self, iprot):
8500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8502 
      return
8503 
    iprot.readStructBegin()
8504 
    while True:
8505 
      (fname, ftype, fid) = iprot.readFieldBegin()
8506 
      if ftype == TType.STOP:
8507 
        break
8508 
      if fid == 0:
8509 
        if ftype == TType.I64:
8510 
          self.success = iprot.readI64();
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.cex = CatalogServiceException()
8516 
          self.cex.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
8528 
    oprot.writeStructBegin('getComingSoonCount_result')
8529 
    if self.success is not None:
8530 
      oprot.writeFieldBegin('success', TType.I64, 0)
8531 
      oprot.writeI64(self.success)
8532 
      oprot.writeFieldEnd()
8533 
    if self.cex is not None:
8534 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8535 
      self.cex.write(oprot)
8536 
      oprot.writeFieldEnd()
8537 
    oprot.writeFieldStop()
8538 
    oprot.writeStructEnd()
8539 
 
8540 
  def validate(self):
8541 
    return
8542 
 
8543 
 
8544 
  def __repr__(self):
8545 
    L = ['%s=%r' % (key, value)
8546 
      for key, value in self.__dict__.iteritems()]
8547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8548 
 
8549 
  def __eq__(self, other):
8550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8551 
 
8552 
  def __ne__(self, other):
8553 
    return not (self == other)
8554 
 
8555 
class getLatestArrivals_args:
8556 
 
8557 
  thrift_spec = (
8558 
  )
8559 
 
8560 
  def read(self, iprot):
8561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8563 
      return
8564 
    iprot.readStructBegin()
8565 
    while True:
8566 
      (fname, ftype, fid) = iprot.readFieldBegin()
8567 
      if ftype == TType.STOP:
8568 
        break
8569 
      else:
8570 
        iprot.skip(ftype)
8571 
      iprot.readFieldEnd()
8572 
    iprot.readStructEnd()
8573 
 
8574 
  def write(self, oprot):
8575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8577 
      return
8578 
    oprot.writeStructBegin('getLatestArrivals_args')
8579 
    oprot.writeFieldStop()
8580 
    oprot.writeStructEnd()
8581 
 
8582 
  def validate(self):
8583 
    return
8584 
 
8585 
 
8586 
  def __repr__(self):
8587 
    L = ['%s=%r' % (key, value)
8588 
      for key, value in self.__dict__.iteritems()]
8589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8590 
 
8591 
  def __eq__(self, other):
8592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8593 
 
8594 
  def __ne__(self, other):
8595 
    return not (self == other)
8596 
 
8597 
class getLatestArrivals_result:
8598 
  """
8599 
  Attributes:
8600 
   - success
8601 
   - isex
8602 
  """
8603 
 
8604 
  thrift_spec = (
8605 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8606 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8607 
  )
8608 
 
8609 
  def __init__(self, success=None, isex=None,):
8610 
    self.success = success
8611 
    self.isex = isex
8612 
 
8613 
  def read(self, iprot):
8614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8616 
      return
8617 
    iprot.readStructBegin()
8618 
    while True:
8619 
      (fname, ftype, fid) = iprot.readFieldBegin()
8620 
      if ftype == TType.STOP:
8621 
        break
8622 
      if fid == 0:
8623 
        if ftype == TType.LIST:
8624 
          self.success = []
8625 
          (_etype103, _size100) = iprot.readListBegin()
8626 
          for _i104 in xrange(_size100):
8627 
            _elem105 = Item()
8628 
            _elem105.read(iprot)
8629 
            self.success.append(_elem105)
8630 
          iprot.readListEnd()
8631 
        else:
8632 
          iprot.skip(ftype)
8633 
      elif fid == 1:
8634 
        if ftype == TType.STRUCT:
8635 
          self.isex = CatalogServiceException()
8636 
          self.isex.read(iprot)
8637 
        else:
8638 
          iprot.skip(ftype)
8639 
      else:
8640 
        iprot.skip(ftype)
8641 
      iprot.readFieldEnd()
8642 
    iprot.readStructEnd()
8643 
 
8644 
  def write(self, oprot):
8645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8647 
      return
8648 
    oprot.writeStructBegin('getLatestArrivals_result')
8649 
    if self.success is not None:
8650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8651 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8652 
      for iter106 in self.success:
8653 
        iter106.write(oprot)
8654 
      oprot.writeListEnd()
8655 
      oprot.writeFieldEnd()
8656 
    if self.isex is not None:
8657 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8658 
      self.isex.write(oprot)
8659 
      oprot.writeFieldEnd()
8660 
    oprot.writeFieldStop()
8661 
    oprot.writeStructEnd()
8662 
 
8663 
  def validate(self):
8664 
    return
8665 
 
8666 
 
8667 
  def __repr__(self):
8668 
    L = ['%s=%r' % (key, value)
8669 
      for key, value in self.__dict__.iteritems()]
8670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8671 
 
8672 
  def __eq__(self, other):
8673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8674 
 
8675 
  def __ne__(self, other):
8676 
    return not (self == other)
8677 
 
8678 
class getLatestArrivalsCatalogIds_args:
8679 
  """
8680 
  Attributes:
8681 
   - beginIndex
8682 
   - totalItems
8683 
   - brand
8684 
   - categories
8685 
  """
8686 
 
8687 
  thrift_spec = (
8688 
    None, # 0
8689 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8690 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8691 
    (3, TType.STRING, 'brand', None, None, ), # 3
8692 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8693 
  )
8694 
 
8695 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8696 
    self.beginIndex = beginIndex
8697 
    self.totalItems = totalItems
8698 
    self.brand = brand
8699 
    self.categories = categories
8700 
 
8701 
  def read(self, iprot):
8702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8704 
      return
8705 
    iprot.readStructBegin()
8706 
    while True:
8707 
      (fname, ftype, fid) = iprot.readFieldBegin()
8708 
      if ftype == TType.STOP:
8709 
        break
8710 
      if fid == 1:
8711 
        if ftype == TType.I64:
8712 
          self.beginIndex = iprot.readI64();
8713 
        else:
8714 
          iprot.skip(ftype)
8715 
      elif fid == 2:
8716 
        if ftype == TType.I64:
8717 
          self.totalItems = iprot.readI64();
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      elif fid == 3:
8721 
        if ftype == TType.STRING:
8722 
          self.brand = iprot.readString();
8723 
        else:
8724 
          iprot.skip(ftype)
8725 
      elif fid == 4:
8726 
        if ftype == TType.LIST:
8727 
          self.categories = []
8728 
          (_etype110, _size107) = iprot.readListBegin()
8729 
          for _i111 in xrange(_size107):
8730 
            _elem112 = iprot.readI64();
8731 
            self.categories.append(_elem112)
8732 
          iprot.readListEnd()
8733 
        else:
8734 
          iprot.skip(ftype)
8735 
      else:
8736 
        iprot.skip(ftype)
8737 
      iprot.readFieldEnd()
8738 
    iprot.readStructEnd()
8739 
 
8740 
  def write(self, oprot):
8741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8743 
      return
8744 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
8745 
    if self.beginIndex is not None:
8746 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8747 
      oprot.writeI64(self.beginIndex)
8748 
      oprot.writeFieldEnd()
8749 
    if self.totalItems is not None:
8750 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8751 
      oprot.writeI64(self.totalItems)
8752 
      oprot.writeFieldEnd()
8753 
    if self.brand is not None:
8754 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8755 
      oprot.writeString(self.brand)
8756 
      oprot.writeFieldEnd()
8757 
    if self.categories is not None:
8758 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
8759 
      oprot.writeListBegin(TType.I64, len(self.categories))
8760 
      for iter113 in self.categories:
8761 
        oprot.writeI64(iter113)
8762 
      oprot.writeListEnd()
8763 
      oprot.writeFieldEnd()
8764 
    oprot.writeFieldStop()
8765 
    oprot.writeStructEnd()
8766 
 
8767 
  def validate(self):
8768 
    return
8769 
 
8770 
 
8771 
  def __repr__(self):
8772 
    L = ['%s=%r' % (key, value)
8773 
      for key, value in self.__dict__.iteritems()]
8774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8775 
 
8776 
  def __eq__(self, other):
8777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8778 
 
8779 
  def __ne__(self, other):
8780 
    return not (self == other)
8781 
 
8782 
class getLatestArrivalsCatalogIds_result:
8783 
  """
8784 
  Attributes:
8785 
   - success
8786 
   - cex
8787 
  """
8788 
 
8789 
  thrift_spec = (
8790 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8791 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8792 
  )
8793 
 
8794 
  def __init__(self, success=None, cex=None,):
8795 
    self.success = success
8796 
    self.cex = cex
8797 
 
8798 
  def read(self, iprot):
8799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8801 
      return
8802 
    iprot.readStructBegin()
8803 
    while True:
8804 
      (fname, ftype, fid) = iprot.readFieldBegin()
8805 
      if ftype == TType.STOP:
8806 
        break
8807 
      if fid == 0:
8808 
        if ftype == TType.LIST:
8809 
          self.success = []
8810 
          (_etype117, _size114) = iprot.readListBegin()
8811 
          for _i118 in xrange(_size114):
8812 
            _elem119 = iprot.readI64();
8813 
            self.success.append(_elem119)
8814 
          iprot.readListEnd()
8815 
        else:
8816 
          iprot.skip(ftype)
8817 
      elif fid == 1:
8818 
        if ftype == TType.STRUCT:
8819 
          self.cex = CatalogServiceException()
8820 
          self.cex.read(iprot)
8821 
        else:
8822 
          iprot.skip(ftype)
8823 
      else:
8824 
        iprot.skip(ftype)
8825 
      iprot.readFieldEnd()
8826 
    iprot.readStructEnd()
8827 
 
8828 
  def write(self, oprot):
8829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8831 
      return
8832 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
8833 
    if self.success is not None:
8834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8835 
      oprot.writeListBegin(TType.I64, len(self.success))
8836 
      for iter120 in self.success:
8837 
        oprot.writeI64(iter120)
8838 
      oprot.writeListEnd()
8839 
      oprot.writeFieldEnd()
8840 
    if self.cex is not None:
8841 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8842 
      self.cex.write(oprot)
8843 
      oprot.writeFieldEnd()
8844 
    oprot.writeFieldStop()
8845 
    oprot.writeStructEnd()
8846 
 
8847 
  def validate(self):
8848 
    return
8849 
 
8850 
 
8851 
  def __repr__(self):
8852 
    L = ['%s=%r' % (key, value)
8853 
      for key, value in self.__dict__.iteritems()]
8854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8855 
 
8856 
  def __eq__(self, other):
8857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8858 
 
8859 
  def __ne__(self, other):
8860 
    return not (self == other)
8861 
 
8862 
class getLatestArrivalsCount_args:
8863 
 
8864 
  thrift_spec = (
8865 
  )
8866 
 
8867 
  def read(self, iprot):
8868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8870 
      return
8871 
    iprot.readStructBegin()
8872 
    while True:
8873 
      (fname, ftype, fid) = iprot.readFieldBegin()
8874 
      if ftype == TType.STOP:
8875 
        break
8876 
      else:
8877 
        iprot.skip(ftype)
8878 
      iprot.readFieldEnd()
8879 
    iprot.readStructEnd()
8880 
 
8881 
  def write(self, oprot):
8882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8884 
      return
8885 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
8886 
    oprot.writeFieldStop()
8887 
    oprot.writeStructEnd()
8888 
 
8889 
  def validate(self):
8890 
    return
8891 
 
8892 
 
8893 
  def __repr__(self):
8894 
    L = ['%s=%r' % (key, value)
8895 
      for key, value in self.__dict__.iteritems()]
8896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8897 
 
8898 
  def __eq__(self, other):
8899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8900 
 
8901 
  def __ne__(self, other):
8902 
    return not (self == other)
8903 
 
8904 
class getLatestArrivalsCount_result:
8905 
  """
8906 
  Attributes:
8907 
   - success
8908 
   - cex
8909 
  """
8910 
 
8911 
  thrift_spec = (
8912 
    (0, TType.I64, 'success', None, None, ), # 0
8913 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8914 
  )
8915 
 
8916 
  def __init__(self, success=None, cex=None,):
8917 
    self.success = success
8918 
    self.cex = cex
8919 
 
8920 
  def read(self, iprot):
8921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8923 
      return
8924 
    iprot.readStructBegin()
8925 
    while True:
8926 
      (fname, ftype, fid) = iprot.readFieldBegin()
8927 
      if ftype == TType.STOP:
8928 
        break
8929 
      if fid == 0:
8930 
        if ftype == TType.I64:
8931 
          self.success = iprot.readI64();
8932 
        else:
8933 
          iprot.skip(ftype)
8934 
      elif fid == 1:
8935 
        if ftype == TType.STRUCT:
8936 
          self.cex = CatalogServiceException()
8937 
          self.cex.read(iprot)
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      else:
8941 
        iprot.skip(ftype)
8942 
      iprot.readFieldEnd()
8943 
    iprot.readStructEnd()
8944 
 
8945 
  def write(self, oprot):
8946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8948 
      return
8949 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
8950 
    if self.success is not None:
8951 
      oprot.writeFieldBegin('success', TType.I64, 0)
8952 
      oprot.writeI64(self.success)
8953 
      oprot.writeFieldEnd()
8954 
    if self.cex is not None:
8955 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8956 
      self.cex.write(oprot)
8957 
      oprot.writeFieldEnd()
8958 
    oprot.writeFieldStop()
8959 
    oprot.writeStructEnd()
8960 
 
8961 
  def validate(self):
8962 
    return
8963 
 
8964 
 
8965 
  def __repr__(self):
8966 
    L = ['%s=%r' % (key, value)
8967 
      for key, value in self.__dict__.iteritems()]
8968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8969 
 
8970 
  def __eq__(self, other):
8971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8972 
 
8973 
  def __ne__(self, other):
8974 
    return not (self == other)
8975 
 
8976 
class generateNewEntityID_args:
8977 
 
8978 
  thrift_spec = (
8979 
  )
8980 
 
8981 
  def read(self, iprot):
8982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8984 
      return
8985 
    iprot.readStructBegin()
8986 
    while True:
8987 
      (fname, ftype, fid) = iprot.readFieldBegin()
8988 
      if ftype == TType.STOP:
8989 
        break
8990 
      else:
8991 
        iprot.skip(ftype)
8992 
      iprot.readFieldEnd()
8993 
    iprot.readStructEnd()
8994 
 
8995 
  def write(self, oprot):
8996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8998 
      return
8999 
    oprot.writeStructBegin('generateNewEntityID_args')
9000 
    oprot.writeFieldStop()
9001 
    oprot.writeStructEnd()
9002 
 
9003 
  def validate(self):
9004 
    return
9005 
 
9006 
 
9007 
  def __repr__(self):
9008 
    L = ['%s=%r' % (key, value)
9009 
      for key, value in self.__dict__.iteritems()]
9010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9011 
 
9012 
  def __eq__(self, other):
9013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9014 
 
9015 
  def __ne__(self, other):
9016 
    return not (self == other)
9017 
 
9018 
class generateNewEntityID_result:
9019 
  """
9020 
  Attributes:
9021 
   - success
9022 
  """
9023 
 
9024 
  thrift_spec = (
9025 
    (0, TType.I64, 'success', None, None, ), # 0
9026 
  )
9027 
 
9028 
  def __init__(self, success=None,):
9029 
    self.success = success
9030 
 
9031 
  def read(self, iprot):
9032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9034 
      return
9035 
    iprot.readStructBegin()
9036 
    while True:
9037 
      (fname, ftype, fid) = iprot.readFieldBegin()
9038 
      if ftype == TType.STOP:
9039 
        break
9040 
      if fid == 0:
9041 
        if ftype == TType.I64:
9042 
          self.success = iprot.readI64();
9043 
        else:
9044 
          iprot.skip(ftype)
9045 
      else:
9046 
        iprot.skip(ftype)
9047 
      iprot.readFieldEnd()
9048 
    iprot.readStructEnd()
9049 
 
9050 
  def write(self, oprot):
9051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9053 
      return
9054 
    oprot.writeStructBegin('generateNewEntityID_result')
9055 
    if self.success is not None:
9056 
      oprot.writeFieldBegin('success', TType.I64, 0)
9057 
      oprot.writeI64(self.success)
9058 
      oprot.writeFieldEnd()
9059 
    oprot.writeFieldStop()
9060 
    oprot.writeStructEnd()
9061 
 
9062 
  def validate(self):
9063 
    return
9064 
 
9065 
 
9066 
  def __repr__(self):
9067 
    L = ['%s=%r' % (key, value)
9068 
      for key, value in self.__dict__.iteritems()]
9069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9070 
 
9071 
  def __eq__(self, other):
9072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9073 
 
9074 
  def __ne__(self, other):
9075 
    return not (self == other)
9076 
 
9077 
class addCategory_args:
9078 
  """
9079 
  Attributes:
9080 
   - category
9081 
  """
9082 
 
9083 
  thrift_spec = (
9084 
    None, # 0
9085 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9086 
  )
9087 
 
9088 
  def __init__(self, category=None,):
9089 
    self.category = category
9090 
 
9091 
  def read(self, iprot):
9092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9094 
      return
9095 
    iprot.readStructBegin()
9096 
    while True:
9097 
      (fname, ftype, fid) = iprot.readFieldBegin()
9098 
      if ftype == TType.STOP:
9099 
        break
9100 
      if fid == 1:
9101 
        if ftype == TType.STRUCT:
9102 
          self.category = Category()
9103 
          self.category.read(iprot)
9104 
        else:
9105 
          iprot.skip(ftype)
9106 
      else:
9107 
        iprot.skip(ftype)
9108 
      iprot.readFieldEnd()
9109 
    iprot.readStructEnd()
9110 
 
9111 
  def write(self, oprot):
9112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9114 
      return
9115 
    oprot.writeStructBegin('addCategory_args')
9116 
    if self.category is not None:
9117 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9118 
      self.category.write(oprot)
9119 
      oprot.writeFieldEnd()
9120 
    oprot.writeFieldStop()
9121 
    oprot.writeStructEnd()
9122 
 
9123 
  def validate(self):
9124 
    return
9125 
 
9126 
 
9127 
  def __repr__(self):
9128 
    L = ['%s=%r' % (key, value)
9129 
      for key, value in self.__dict__.iteritems()]
9130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9131 
 
9132 
  def __eq__(self, other):
9133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9134 
 
9135 
  def __ne__(self, other):
9136 
    return not (self == other)
9137 
 
9138 
class addCategory_result:
9139 
  """
9140 
  Attributes:
9141 
   - success
9142 
  """
9143 
 
9144 
  thrift_spec = (
9145 
    (0, TType.BOOL, 'success', None, None, ), # 0
9146 
  )
9147 
 
9148 
  def __init__(self, success=None,):
9149 
    self.success = success
9150 
 
9151 
  def read(self, iprot):
9152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9154 
      return
9155 
    iprot.readStructBegin()
9156 
    while True:
9157 
      (fname, ftype, fid) = iprot.readFieldBegin()
9158 
      if ftype == TType.STOP:
9159 
        break
9160 
      if fid == 0:
9161 
        if ftype == TType.BOOL:
9162 
          self.success = iprot.readBool();
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('addCategory_result')
9175 
    if self.success is not None:
9176 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9177 
      oprot.writeBool(self.success)
9178 
      oprot.writeFieldEnd()
9179 
    oprot.writeFieldStop()
9180 
    oprot.writeStructEnd()
9181 
 
9182 
  def validate(self):
9183 
    return
9184 
 
9185 
 
9186 
  def __repr__(self):
9187 
    L = ['%s=%r' % (key, value)
9188 
      for key, value in self.__dict__.iteritems()]
9189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9190 
 
9191 
  def __eq__(self, other):
9192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9193 
 
9194 
  def __ne__(self, other):
9195 
    return not (self == other)
9196 
 
9197 
class getCategory_args:
9198 
  """
9199 
  Attributes:
9200 
   - id
9201 
  """
9202 
 
9203 
  thrift_spec = (
9204 
    None, # 0
9205 
    (1, TType.I64, 'id', None, None, ), # 1
9206 
  )
9207 
 
9208 
  def __init__(self, id=None,):
9209 
    self.id = id
9210 
 
9211 
  def read(self, iprot):
9212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9214 
      return
9215 
    iprot.readStructBegin()
9216 
    while True:
9217 
      (fname, ftype, fid) = iprot.readFieldBegin()
9218 
      if ftype == TType.STOP:
9219 
        break
9220 
      if fid == 1:
9221 
        if ftype == TType.I64:
9222 
          self.id = iprot.readI64();
9223 
        else:
9224 
          iprot.skip(ftype)
9225 
      else:
9226 
        iprot.skip(ftype)
9227 
      iprot.readFieldEnd()
9228 
    iprot.readStructEnd()
9229 
 
9230 
  def write(self, oprot):
9231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9233 
      return
9234 
    oprot.writeStructBegin('getCategory_args')
9235 
    if self.id is not None:
9236 
      oprot.writeFieldBegin('id', TType.I64, 1)
9237 
      oprot.writeI64(self.id)
9238 
      oprot.writeFieldEnd()
9239 
    oprot.writeFieldStop()
9240 
    oprot.writeStructEnd()
9241 
 
9242 
  def validate(self):
9243 
    return
9244 
 
9245 
 
9246 
  def __repr__(self):
9247 
    L = ['%s=%r' % (key, value)
9248 
      for key, value in self.__dict__.iteritems()]
9249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9250 
 
9251 
  def __eq__(self, other):
9252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9253 
 
9254 
  def __ne__(self, other):
9255 
    return not (self == other)
9256 
 
9257 
class getCategory_result:
9258 
  """
9259 
  Attributes:
9260 
   - success
9261 
  """
9262 
 
9263 
  thrift_spec = (
9264 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9265 
  )
9266 
 
9267 
  def __init__(self, success=None,):
9268 
    self.success = success
9269 
 
9270 
  def read(self, iprot):
9271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9273 
      return
9274 
    iprot.readStructBegin()
9275 
    while True:
9276 
      (fname, ftype, fid) = iprot.readFieldBegin()
9277 
      if ftype == TType.STOP:
9278 
        break
9279 
      if fid == 0:
9280 
        if ftype == TType.STRUCT:
9281 
          self.success = Category()
9282 
          self.success.read(iprot)
9283 
        else:
9284 
          iprot.skip(ftype)
9285 
      else:
9286 
        iprot.skip(ftype)
9287 
      iprot.readFieldEnd()
9288 
    iprot.readStructEnd()
9289 
 
9290 
  def write(self, oprot):
9291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9293 
      return
9294 
    oprot.writeStructBegin('getCategory_result')
9295 
    if self.success is not None:
9296 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9297 
      self.success.write(oprot)
9298 
      oprot.writeFieldEnd()
9299 
    oprot.writeFieldStop()
9300 
    oprot.writeStructEnd()
9301 
 
9302 
  def validate(self):
9303 
    return
9304 
 
9305 
 
9306 
  def __repr__(self):
9307 
    L = ['%s=%r' % (key, value)
9308 
      for key, value in self.__dict__.iteritems()]
9309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9310 
 
9311 
  def __eq__(self, other):
9312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9313 
 
9314 
  def __ne__(self, other):
9315 
    return not (self == other)
9316 
 
9317 
class getAllCategories_args:
9318 
 
9319 
  thrift_spec = (
9320 
  )
9321 
 
9322 
  def read(self, iprot):
9323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9325 
      return
9326 
    iprot.readStructBegin()
9327 
    while True:
9328 
      (fname, ftype, fid) = iprot.readFieldBegin()
9329 
      if ftype == TType.STOP:
9330 
        break
9331 
      else:
9332 
        iprot.skip(ftype)
9333 
      iprot.readFieldEnd()
9334 
    iprot.readStructEnd()
9335 
 
9336 
  def write(self, oprot):
9337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9339 
      return
9340 
    oprot.writeStructBegin('getAllCategories_args')
9341 
    oprot.writeFieldStop()
9342 
    oprot.writeStructEnd()
9343 
 
9344 
  def validate(self):
9345 
    return
9346 
 
9347 
 
9348 
  def __repr__(self):
9349 
    L = ['%s=%r' % (key, value)
9350 
      for key, value in self.__dict__.iteritems()]
9351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9352 
 
9353 
  def __eq__(self, other):
9354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9355 
 
9356 
  def __ne__(self, other):
9357 
    return not (self == other)
9358 
 
9359 
class getAllCategories_result:
9360 
  """
9361 
  Attributes:
9362 
   - success
9363 
  """
9364 
 
9365 
  thrift_spec = (
9366 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9367 
  )
9368 
 
9369 
  def __init__(self, success=None,):
9370 
    self.success = success
9371 
 
9372 
  def read(self, iprot):
9373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9375 
      return
9376 
    iprot.readStructBegin()
9377 
    while True:
9378 
      (fname, ftype, fid) = iprot.readFieldBegin()
9379 
      if ftype == TType.STOP:
9380 
        break
9381 
      if fid == 0:
9382 
        if ftype == TType.LIST:
9383 
          self.success = []
9384 
          (_etype124, _size121) = iprot.readListBegin()
9385 
          for _i125 in xrange(_size121):
9386 
            _elem126 = Category()
9387 
            _elem126.read(iprot)
9388 
            self.success.append(_elem126)
9389 
          iprot.readListEnd()
9390 
        else:
9391 
          iprot.skip(ftype)
9392 
      else:
9393 
        iprot.skip(ftype)
9394 
      iprot.readFieldEnd()
9395 
    iprot.readStructEnd()
9396 
 
9397 
  def write(self, oprot):
9398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9400 
      return
9401 
    oprot.writeStructBegin('getAllCategories_result')
9402 
    if self.success is not None:
9403 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9404 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9405 
      for iter127 in self.success:
9406 
        iter127.write(oprot)
9407 
      oprot.writeListEnd()
9408 
      oprot.writeFieldEnd()
9409 
    oprot.writeFieldStop()
9410 
    oprot.writeStructEnd()
9411 
 
9412 
  def validate(self):
9413 
    return
9414 
 
9415 
 
9416 
  def __repr__(self):
9417 
    L = ['%s=%r' % (key, value)
9418 
      for key, value in self.__dict__.iteritems()]
9419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9420 
 
9421 
  def __eq__(self, other):
9422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9423 
 
9424 
  def __ne__(self, other):
9425 
    return not (self == other)
9426 
 
9427 
class getAllSimilarItems_args:
9428 
  """
9429 
  Attributes:
9430 
   - itemId
9431 
  """
9432 
 
9433 
  thrift_spec = (
9434 
    None, # 0
9435 
    (1, TType.I64, 'itemId', None, None, ), # 1
9436 
  )
9437 
 
9438 
  def __init__(self, itemId=None,):
9439 
    self.itemId = itemId
9440 
 
9441 
  def read(self, iprot):
9442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9444 
      return
9445 
    iprot.readStructBegin()
9446 
    while True:
9447 
      (fname, ftype, fid) = iprot.readFieldBegin()
9448 
      if ftype == TType.STOP:
9449 
        break
9450 
      if fid == 1:
9451 
        if ftype == TType.I64:
9452 
          self.itemId = iprot.readI64();
9453 
        else:
9454 
          iprot.skip(ftype)
9455 
      else:
9456 
        iprot.skip(ftype)
9457 
      iprot.readFieldEnd()
9458 
    iprot.readStructEnd()
9459 
 
9460 
  def write(self, oprot):
9461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9463 
      return
9464 
    oprot.writeStructBegin('getAllSimilarItems_args')
9465 
    if self.itemId is not None:
9466 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9467 
      oprot.writeI64(self.itemId)
9468 
      oprot.writeFieldEnd()
9469 
    oprot.writeFieldStop()
9470 
    oprot.writeStructEnd()
9471 
 
9472 
  def validate(self):
9473 
    return
9474 
 
9475 
 
9476 
  def __repr__(self):
9477 
    L = ['%s=%r' % (key, value)
9478 
      for key, value in self.__dict__.iteritems()]
9479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9480 
 
9481 
  def __eq__(self, other):
9482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9483 
 
9484 
  def __ne__(self, other):
9485 
    return not (self == other)
9486 
 
9487 
class getAllSimilarItems_result:
9488 
  """
9489 
  Attributes:
9490 
   - success
9491 
  """
9492 
 
9493 
  thrift_spec = (
9494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9495 
  )
9496 
 
9497 
  def __init__(self, success=None,):
9498 
    self.success = success
9499 
 
9500 
  def read(self, iprot):
9501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9503 
      return
9504 
    iprot.readStructBegin()
9505 
    while True:
9506 
      (fname, ftype, fid) = iprot.readFieldBegin()
9507 
      if ftype == TType.STOP:
9508 
        break
9509 
      if fid == 0:
9510 
        if ftype == TType.LIST:
9511 
          self.success = []
9512 
          (_etype131, _size128) = iprot.readListBegin()
9513 
          for _i132 in xrange(_size128):
9514 
            _elem133 = Item()
9515 
            _elem133.read(iprot)
9516 
            self.success.append(_elem133)
9517 
          iprot.readListEnd()
9518 
        else:
9519 
          iprot.skip(ftype)
9520 
      else:
9521 
        iprot.skip(ftype)
9522 
      iprot.readFieldEnd()
9523 
    iprot.readStructEnd()
9524 
 
9525 
  def write(self, oprot):
9526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9528 
      return
9529 
    oprot.writeStructBegin('getAllSimilarItems_result')
9530 
    if self.success is not None:
9531 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9532 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9533 
      for iter134 in self.success:
9534 
        iter134.write(oprot)
9535 
      oprot.writeListEnd()
9536 
      oprot.writeFieldEnd()
9537 
    oprot.writeFieldStop()
9538 
    oprot.writeStructEnd()
9539 
 
9540 
  def validate(self):
9541 
    return
9542 
 
9543 
 
9544 
  def __repr__(self):
9545 
    L = ['%s=%r' % (key, value)
9546 
      for key, value in self.__dict__.iteritems()]
9547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9548 
 
9549 
  def __eq__(self, other):
9550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9551 
 
9552 
  def __ne__(self, other):
9553 
    return not (self == other)
9554 
 
9555 
class addSimilarItem_args:
9556 
  """
9557 
  Attributes:
9558 
   - itemId
9559 
   - catalogItemId
9560 
  """
9561 
 
9562 
  thrift_spec = (
9563 
    None, # 0
9564 
    (1, TType.I64, 'itemId', None, None, ), # 1
9565 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9566 
  )
9567 
 
9568 
  def __init__(self, itemId=None, catalogItemId=None,):
9569 
    self.itemId = itemId
9570 
    self.catalogItemId = catalogItemId
9571 
 
9572 
  def read(self, iprot):
9573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9575 
      return
9576 
    iprot.readStructBegin()
9577 
    while True:
9578 
      (fname, ftype, fid) = iprot.readFieldBegin()
9579 
      if ftype == TType.STOP:
9580 
        break
9581 
      if fid == 1:
9582 
        if ftype == TType.I64:
9583 
          self.itemId = iprot.readI64();
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      elif fid == 2:
9587 
        if ftype == TType.I64:
9588 
          self.catalogItemId = iprot.readI64();
9589 
        else:
9590 
          iprot.skip(ftype)
9591 
      else:
9592 
        iprot.skip(ftype)
9593 
      iprot.readFieldEnd()
9594 
    iprot.readStructEnd()
9595 
 
9596 
  def write(self, oprot):
9597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9599 
      return
9600 
    oprot.writeStructBegin('addSimilarItem_args')
9601 
    if self.itemId is not None:
9602 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9603 
      oprot.writeI64(self.itemId)
9604 
      oprot.writeFieldEnd()
9605 
    if self.catalogItemId is not None:
9606 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9607 
      oprot.writeI64(self.catalogItemId)
9608 
      oprot.writeFieldEnd()
9609 
    oprot.writeFieldStop()
9610 
    oprot.writeStructEnd()
9611 
 
9612 
  def validate(self):
9613 
    return
9614 
 
9615 
 
9616 
  def __repr__(self):
9617 
    L = ['%s=%r' % (key, value)
9618 
      for key, value in self.__dict__.iteritems()]
9619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9620 
 
9621 
  def __eq__(self, other):
9622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9623 
 
9624 
  def __ne__(self, other):
9625 
    return not (self == other)
9626 
 
9627 
class addSimilarItem_result:
9628 
  """
9629 
  Attributes:
9630 
   - success
9631 
   - cex
9632 
  """
9633 
 
9634 
  thrift_spec = (
9635 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9636 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9637 
  )
9638 
 
9639 
  def __init__(self, success=None, cex=None,):
9640 
    self.success = success
9641 
    self.cex = cex
9642 
 
9643 
  def read(self, iprot):
9644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9646 
      return
9647 
    iprot.readStructBegin()
9648 
    while True:
9649 
      (fname, ftype, fid) = iprot.readFieldBegin()
9650 
      if ftype == TType.STOP:
9651 
        break
9652 
      if fid == 0:
9653 
        if ftype == TType.STRUCT:
9654 
          self.success = Item()
9655 
          self.success.read(iprot)
9656 
        else:
9657 
          iprot.skip(ftype)
9658 
      elif fid == 1:
9659 
        if ftype == TType.STRUCT:
9660 
          self.cex = CatalogServiceException()
9661 
          self.cex.read(iprot)
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      else:
9665 
        iprot.skip(ftype)
9666 
      iprot.readFieldEnd()
9667 
    iprot.readStructEnd()
9668 
 
9669 
  def write(self, oprot):
9670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9672 
      return
9673 
    oprot.writeStructBegin('addSimilarItem_result')
9674 
    if self.success is not None:
9675 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9676 
      self.success.write(oprot)
9677 
      oprot.writeFieldEnd()
9678 
    if self.cex is not None:
9679 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9680 
      self.cex.write(oprot)
9681 
      oprot.writeFieldEnd()
9682 
    oprot.writeFieldStop()
9683 
    oprot.writeStructEnd()
9684 
 
9685 
  def validate(self):
9686 
    return
9687 
 
9688 
 
9689 
  def __repr__(self):
9690 
    L = ['%s=%r' % (key, value)
9691 
      for key, value in self.__dict__.iteritems()]
9692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9693 
 
9694 
  def __eq__(self, other):
9695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9696 
 
9697 
  def __ne__(self, other):
9698 
    return not (self == other)
9699 
 
6512 kshitij.so 9700 
class addTag_args:
9701 
  """
9702 
  Attributes:
9703 
   - displayName
9704 
   - itemId
9705 
  """
9706 
 
9707 
  thrift_spec = (
9708 
    None, # 0
9709 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9710 
    (2, TType.I64, 'itemId', None, None, ), # 2
9711 
  )
9712 
 
9713 
  def __init__(self, displayName=None, itemId=None,):
9714 
    self.displayName = displayName
9715 
    self.itemId = itemId
9716 
 
9717 
  def read(self, iprot):
9718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9720 
      return
9721 
    iprot.readStructBegin()
9722 
    while True:
9723 
      (fname, ftype, fid) = iprot.readFieldBegin()
9724 
      if ftype == TType.STOP:
9725 
        break
9726 
      if fid == 1:
9727 
        if ftype == TType.STRING:
9728 
          self.displayName = iprot.readString();
9729 
        else:
9730 
          iprot.skip(ftype)
9731 
      elif fid == 2:
9732 
        if ftype == TType.I64:
9733 
          self.itemId = iprot.readI64();
9734 
        else:
9735 
          iprot.skip(ftype)
9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
9745 
    oprot.writeStructBegin('addTag_args')
9746 
    if self.displayName is not None:
9747 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9748 
      oprot.writeString(self.displayName)
9749 
      oprot.writeFieldEnd()
9750 
    if self.itemId is not None:
9751 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9752 
      oprot.writeI64(self.itemId)
9753 
      oprot.writeFieldEnd()
9754 
    oprot.writeFieldStop()
9755 
    oprot.writeStructEnd()
9756 
 
9757 
  def validate(self):
9758 
    return
9759 
 
9760 
 
9761 
  def __repr__(self):
9762 
    L = ['%s=%r' % (key, value)
9763 
      for key, value in self.__dict__.iteritems()]
9764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9765 
 
9766 
  def __eq__(self, other):
9767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9768 
 
9769 
  def __ne__(self, other):
9770 
    return not (self == other)
9771 
 
9772 
class addTag_result:
9773 
  """
9774 
  Attributes:
9775 
   - success
9776 
  """
9777 
 
9778 
  thrift_spec = (
9779 
    (0, TType.BOOL, 'success', None, None, ), # 0
9780 
  )
9781 
 
9782 
  def __init__(self, success=None,):
9783 
    self.success = success
9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 0:
9795 
        if ftype == TType.BOOL:
9796 
          self.success = iprot.readBool();
9797 
        else:
9798 
          iprot.skip(ftype)
9799 
      else:
9800 
        iprot.skip(ftype)
9801 
      iprot.readFieldEnd()
9802 
    iprot.readStructEnd()
9803 
 
9804 
  def write(self, oprot):
9805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9807 
      return
9808 
    oprot.writeStructBegin('addTag_result')
9809 
    if self.success is not None:
9810 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9811 
      oprot.writeBool(self.success)
9812 
      oprot.writeFieldEnd()
9813 
    oprot.writeFieldStop()
9814 
    oprot.writeStructEnd()
9815 
 
9816 
  def validate(self):
9817 
    return
9818 
 
9819 
 
9820 
  def __repr__(self):
9821 
    L = ['%s=%r' % (key, value)
9822 
      for key, value in self.__dict__.iteritems()]
9823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9824 
 
9825 
  def __eq__(self, other):
9826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9827 
 
9828 
  def __ne__(self, other):
9829 
    return not (self == other)
9830 
 
9831 
class deleteEntityTag_args:
9832 
  """
9833 
  Attributes:
9834 
   - displayName
9835 
   - itemId
9836 
  """
9837 
 
9838 
  thrift_spec = (
9839 
    None, # 0
9840 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9841 
    (2, TType.I64, 'itemId', None, None, ), # 2
9842 
  )
9843 
 
9844 
  def __init__(self, displayName=None, itemId=None,):
9845 
    self.displayName = displayName
9846 
    self.itemId = itemId
9847 
 
9848 
  def read(self, iprot):
9849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9851 
      return
9852 
    iprot.readStructBegin()
9853 
    while True:
9854 
      (fname, ftype, fid) = iprot.readFieldBegin()
9855 
      if ftype == TType.STOP:
9856 
        break
9857 
      if fid == 1:
9858 
        if ftype == TType.STRING:
9859 
          self.displayName = iprot.readString();
9860 
        else:
9861 
          iprot.skip(ftype)
9862 
      elif fid == 2:
9863 
        if ftype == TType.I64:
9864 
          self.itemId = iprot.readI64();
9865 
        else:
9866 
          iprot.skip(ftype)
9867 
      else:
9868 
        iprot.skip(ftype)
9869 
      iprot.readFieldEnd()
9870 
    iprot.readStructEnd()
9871 
 
9872 
  def write(self, oprot):
9873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9875 
      return
9876 
    oprot.writeStructBegin('deleteEntityTag_args')
9877 
    if self.displayName is not None:
9878 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
9879 
      oprot.writeString(self.displayName)
9880 
      oprot.writeFieldEnd()
9881 
    if self.itemId is not None:
9882 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9883 
      oprot.writeI64(self.itemId)
9884 
      oprot.writeFieldEnd()
9885 
    oprot.writeFieldStop()
9886 
    oprot.writeStructEnd()
9887 
 
9888 
  def validate(self):
9889 
    return
9890 
 
9891 
 
9892 
  def __repr__(self):
9893 
    L = ['%s=%r' % (key, value)
9894 
      for key, value in self.__dict__.iteritems()]
9895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9896 
 
9897 
  def __eq__(self, other):
9898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9899 
 
9900 
  def __ne__(self, other):
9901 
    return not (self == other)
9902 
 
9903 
class deleteEntityTag_result:
9904 
  """
9905 
  Attributes:
9906 
   - success
9907 
  """
9908 
 
9909 
  thrift_spec = (
9910 
    (0, TType.BOOL, 'success', None, None, ), # 0
9911 
  )
9912 
 
9913 
  def __init__(self, success=None,):
9914 
    self.success = success
9915 
 
9916 
  def read(self, iprot):
9917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9919 
      return
9920 
    iprot.readStructBegin()
9921 
    while True:
9922 
      (fname, ftype, fid) = iprot.readFieldBegin()
9923 
      if ftype == TType.STOP:
9924 
        break
9925 
      if fid == 0:
9926 
        if ftype == TType.BOOL:
9927 
          self.success = iprot.readBool();
9928 
        else:
9929 
          iprot.skip(ftype)
9930 
      else:
9931 
        iprot.skip(ftype)
9932 
      iprot.readFieldEnd()
9933 
    iprot.readStructEnd()
9934 
 
9935 
  def write(self, oprot):
9936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9938 
      return
9939 
    oprot.writeStructBegin('deleteEntityTag_result')
9940 
    if self.success is not None:
9941 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9942 
      oprot.writeBool(self.success)
9943 
      oprot.writeFieldEnd()
9944 
    oprot.writeFieldStop()
9945 
    oprot.writeStructEnd()
9946 
 
9947 
  def validate(self):
9948 
    return
9949 
 
9950 
 
9951 
  def __repr__(self):
9952 
    L = ['%s=%r' % (key, value)
9953 
      for key, value in self.__dict__.iteritems()]
9954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9955 
 
9956 
  def __eq__(self, other):
9957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9958 
 
9959 
  def __ne__(self, other):
9960 
    return not (self == other)
9961 
 
9962 
class deleteTag_args:
9963 
  """
9964 
  Attributes:
9965 
   - displayName
9966 
  """
9967 
 
9968 
  thrift_spec = (
9969 
    None, # 0
9970 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9971 
  )
9972 
 
9973 
  def __init__(self, displayName=None,):
9974 
    self.displayName = displayName
9975 
 
9976 
  def read(self, iprot):
9977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9979 
      return
9980 
    iprot.readStructBegin()
9981 
    while True:
9982 
      (fname, ftype, fid) = iprot.readFieldBegin()
9983 
      if ftype == TType.STOP:
9984 
        break
9985 
      if fid == 1:
9986 
        if ftype == TType.STRING:
9987 
          self.displayName = iprot.readString();
9988 
        else:
9989 
          iprot.skip(ftype)
9990 
      else:
9991 
        iprot.skip(ftype)
9992 
      iprot.readFieldEnd()
9993 
    iprot.readStructEnd()
9994 
 
9995 
  def write(self, oprot):
9996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9998 
      return
9999 
    oprot.writeStructBegin('deleteTag_args')
10000 
    if self.displayName is not None:
10001 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10002 
      oprot.writeString(self.displayName)
10003 
      oprot.writeFieldEnd()
10004 
    oprot.writeFieldStop()
10005 
    oprot.writeStructEnd()
10006 
 
10007 
  def validate(self):
10008 
    return
10009 
 
10010 
 
10011 
  def __repr__(self):
10012 
    L = ['%s=%r' % (key, value)
10013 
      for key, value in self.__dict__.iteritems()]
10014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10015 
 
10016 
  def __eq__(self, other):
10017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10018 
 
10019 
  def __ne__(self, other):
10020 
    return not (self == other)
10021 
 
10022 
class deleteTag_result:
10023 
  """
10024 
  Attributes:
10025 
   - success
10026 
  """
10027 
 
10028 
  thrift_spec = (
10029 
    (0, TType.BOOL, 'success', None, None, ), # 0
10030 
  )
10031 
 
10032 
  def __init__(self, success=None,):
10033 
    self.success = success
10034 
 
10035 
  def read(self, iprot):
10036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10038 
      return
10039 
    iprot.readStructBegin()
10040 
    while True:
10041 
      (fname, ftype, fid) = iprot.readFieldBegin()
10042 
      if ftype == TType.STOP:
10043 
        break
10044 
      if fid == 0:
10045 
        if ftype == TType.BOOL:
10046 
          self.success = iprot.readBool();
10047 
        else:
10048 
          iprot.skip(ftype)
10049 
      else:
10050 
        iprot.skip(ftype)
10051 
      iprot.readFieldEnd()
10052 
    iprot.readStructEnd()
10053 
 
10054 
  def write(self, oprot):
10055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10057 
      return
10058 
    oprot.writeStructBegin('deleteTag_result')
10059 
    if self.success is not None:
10060 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10061 
      oprot.writeBool(self.success)
10062 
      oprot.writeFieldEnd()
10063 
    oprot.writeFieldStop()
10064 
    oprot.writeStructEnd()
10065 
 
10066 
  def validate(self):
10067 
    return
10068 
 
10069 
 
10070 
  def __repr__(self):
10071 
    L = ['%s=%r' % (key, value)
10072 
      for key, value in self.__dict__.iteritems()]
10073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10074 
 
10075 
  def __eq__(self, other):
10076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10077 
 
10078 
  def __ne__(self, other):
10079 
    return not (self == other)
10080 
 
10081 
class getAllTags_args:
10082 
 
10083 
  thrift_spec = (
10084 
  )
10085 
 
10086 
  def read(self, iprot):
10087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10089 
      return
10090 
    iprot.readStructBegin()
10091 
    while True:
10092 
      (fname, ftype, fid) = iprot.readFieldBegin()
10093 
      if ftype == TType.STOP:
10094 
        break
10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
10104 
    oprot.writeStructBegin('getAllTags_args')
10105 
    oprot.writeFieldStop()
10106 
    oprot.writeStructEnd()
10107 
 
10108 
  def validate(self):
10109 
    return
10110 
 
10111 
 
10112 
  def __repr__(self):
10113 
    L = ['%s=%r' % (key, value)
10114 
      for key, value in self.__dict__.iteritems()]
10115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10116 
 
10117 
  def __eq__(self, other):
10118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10119 
 
10120 
  def __ne__(self, other):
10121 
    return not (self == other)
10122 
 
10123 
class getAllTags_result:
10124 
  """
10125 
  Attributes:
10126 
   - success
10127 
  """
10128 
 
10129 
  thrift_spec = (
10130 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10131 
  )
10132 
 
10133 
  def __init__(self, success=None,):
10134 
    self.success = success
10135 
 
10136 
  def read(self, iprot):
10137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10139 
      return
10140 
    iprot.readStructBegin()
10141 
    while True:
10142 
      (fname, ftype, fid) = iprot.readFieldBegin()
10143 
      if ftype == TType.STOP:
10144 
        break
10145 
      if fid == 0:
10146 
        if ftype == TType.LIST:
10147 
          self.success = []
10148 
          (_etype138, _size135) = iprot.readListBegin()
10149 
          for _i139 in xrange(_size135):
10150 
            _elem140 = iprot.readString();
10151 
            self.success.append(_elem140)
10152 
          iprot.readListEnd()
10153 
        else:
10154 
          iprot.skip(ftype)
10155 
      else:
10156 
        iprot.skip(ftype)
10157 
      iprot.readFieldEnd()
10158 
    iprot.readStructEnd()
10159 
 
10160 
  def write(self, oprot):
10161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10163 
      return
10164 
    oprot.writeStructBegin('getAllTags_result')
10165 
    if self.success is not None:
10166 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10167 
      oprot.writeListBegin(TType.STRING, len(self.success))
10168 
      for iter141 in self.success:
10169 
        oprot.writeString(iter141)
10170 
      oprot.writeListEnd()
10171 
      oprot.writeFieldEnd()
10172 
    oprot.writeFieldStop()
10173 
    oprot.writeStructEnd()
10174 
 
10175 
  def validate(self):
10176 
    return
10177 
 
10178 
 
10179 
  def __repr__(self):
10180 
    L = ['%s=%r' % (key, value)
10181 
      for key, value in self.__dict__.iteritems()]
10182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10183 
 
10184 
  def __eq__(self, other):
10185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10186 
 
10187 
  def __ne__(self, other):
10188 
    return not (self == other)
10189 
 
10190 
class getAllEntitiesByTagName_args:
10191 
  """
10192 
  Attributes:
10193 
   - displayName
10194 
  """
10195 
 
10196 
  thrift_spec = (
10197 
    None, # 0
10198 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10199 
  )
10200 
 
10201 
  def __init__(self, displayName=None,):
10202 
    self.displayName = displayName
10203 
 
10204 
  def read(self, iprot):
10205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10207 
      return
10208 
    iprot.readStructBegin()
10209 
    while True:
10210 
      (fname, ftype, fid) = iprot.readFieldBegin()
10211 
      if ftype == TType.STOP:
10212 
        break
10213 
      if fid == 1:
10214 
        if ftype == TType.STRING:
10215 
          self.displayName = iprot.readString();
10216 
        else:
10217 
          iprot.skip(ftype)
10218 
      else:
10219 
        iprot.skip(ftype)
10220 
      iprot.readFieldEnd()
10221 
    iprot.readStructEnd()
10222 
 
10223 
  def write(self, oprot):
10224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10226 
      return
10227 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10228 
    if self.displayName is not None:
10229 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10230 
      oprot.writeString(self.displayName)
10231 
      oprot.writeFieldEnd()
10232 
    oprot.writeFieldStop()
10233 
    oprot.writeStructEnd()
10234 
 
10235 
  def validate(self):
10236 
    return
10237 
 
10238 
 
10239 
  def __repr__(self):
10240 
    L = ['%s=%r' % (key, value)
10241 
      for key, value in self.__dict__.iteritems()]
10242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10243 
 
10244 
  def __eq__(self, other):
10245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10246 
 
10247 
  def __ne__(self, other):
10248 
    return not (self == other)
10249 
 
10250 
class getAllEntitiesByTagName_result:
10251 
  """
10252 
  Attributes:
10253 
   - success
10254 
  """
10255 
 
10256 
  thrift_spec = (
10257 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10258 
  )
10259 
 
10260 
  def __init__(self, success=None,):
10261 
    self.success = success
10262 
 
10263 
  def read(self, iprot):
10264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10266 
      return
10267 
    iprot.readStructBegin()
10268 
    while True:
10269 
      (fname, ftype, fid) = iprot.readFieldBegin()
10270 
      if ftype == TType.STOP:
10271 
        break
10272 
      if fid == 0:
10273 
        if ftype == TType.LIST:
10274 
          self.success = []
10275 
          (_etype145, _size142) = iprot.readListBegin()
10276 
          for _i146 in xrange(_size142):
10277 
            _elem147 = iprot.readI64();
10278 
            self.success.append(_elem147)
10279 
          iprot.readListEnd()
10280 
        else:
10281 
          iprot.skip(ftype)
10282 
      else:
10283 
        iprot.skip(ftype)
10284 
      iprot.readFieldEnd()
10285 
    iprot.readStructEnd()
10286 
 
10287 
  def write(self, oprot):
10288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10290 
      return
10291 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10292 
    if self.success is not None:
10293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10294 
      oprot.writeListBegin(TType.I64, len(self.success))
10295 
      for iter148 in self.success:
10296 
        oprot.writeI64(iter148)
10297 
      oprot.writeListEnd()
10298 
      oprot.writeFieldEnd()
10299 
    oprot.writeFieldStop()
10300 
    oprot.writeStructEnd()
10301 
 
10302 
  def validate(self):
10303 
    return
10304 
 
10305 
 
10306 
  def __repr__(self):
10307 
    L = ['%s=%r' % (key, value)
10308 
      for key, value in self.__dict__.iteritems()]
10309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10310 
 
10311 
  def __eq__(self, other):
10312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10313 
 
10314 
  def __ne__(self, other):
10315 
    return not (self == other)
10316 
 
6845 amit.gupta 10317 
class getAllEntityTags_args:
10318 
 
10319 
  thrift_spec = (
10320 
  )
10321 
 
10322 
  def read(self, iprot):
10323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10325 
      return
10326 
    iprot.readStructBegin()
10327 
    while True:
10328 
      (fname, ftype, fid) = iprot.readFieldBegin()
10329 
      if ftype == TType.STOP:
10330 
        break
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
10340 
    oprot.writeStructBegin('getAllEntityTags_args')
10341 
    oprot.writeFieldStop()
10342 
    oprot.writeStructEnd()
10343 
 
10344 
  def validate(self):
10345 
    return
10346 
 
10347 
 
10348 
  def __repr__(self):
10349 
    L = ['%s=%r' % (key, value)
10350 
      for key, value in self.__dict__.iteritems()]
10351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10352 
 
10353 
  def __eq__(self, other):
10354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10355 
 
10356 
  def __ne__(self, other):
10357 
    return not (self == other)
10358 
 
10359 
class getAllEntityTags_result:
10360 
  """
10361 
  Attributes:
10362 
   - success
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10367 
  )
10368 
 
10369 
  def __init__(self, success=None,):
10370 
    self.success = success
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 0:
10382 
        if ftype == TType.MAP:
10383 
          self.success = {}
10384 
          (_ktype150, _vtype151, _size149 ) = iprot.readMapBegin()
10385 
          for _i153 in xrange(_size149):
10386 
            _key154 = iprot.readI64();
10387 
            _val155 = []
10388 
            (_etype159, _size156) = iprot.readListBegin()
10389 
            for _i160 in xrange(_size156):
10390 
              _elem161 = iprot.readString();
10391 
              _val155.append(_elem161)
10392 
            iprot.readListEnd()
10393 
            self.success[_key154] = _val155
10394 
          iprot.readMapEnd()
10395 
        else:
10396 
          iprot.skip(ftype)
10397 
      else:
10398 
        iprot.skip(ftype)
10399 
      iprot.readFieldEnd()
10400 
    iprot.readStructEnd()
10401 
 
10402 
  def write(self, oprot):
10403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10405 
      return
10406 
    oprot.writeStructBegin('getAllEntityTags_result')
10407 
    if self.success is not None:
10408 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10409 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
10410 
      for kiter162,viter163 in self.success.items():
10411 
        oprot.writeI64(kiter162)
10412 
        oprot.writeListBegin(TType.STRING, len(viter163))
10413 
        for iter164 in viter163:
10414 
          oprot.writeString(iter164)
10415 
        oprot.writeListEnd()
10416 
      oprot.writeMapEnd()
10417 
      oprot.writeFieldEnd()
10418 
    oprot.writeFieldStop()
10419 
    oprot.writeStructEnd()
10420 
 
10421 
  def validate(self):
10422 
    return
10423 
 
10424 
 
10425 
  def __repr__(self):
10426 
    L = ['%s=%r' % (key, value)
10427 
      for key, value in self.__dict__.iteritems()]
10428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10429 
 
10430 
  def __eq__(self, other):
10431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10432 
 
10433 
  def __ne__(self, other):
10434 
    return not (self == other)
10435 
 
6850 kshitij.so 10436 
class addBanner_args:
10437 
  """
10438 
  Attributes:
10439 
   - bannerName
10440 
   - imageName
10441 
   - link
10442 
   - priority
10443 
   - isActive
10444 
   - hasMap
10445 
  """
10446 
 
10447 
  thrift_spec = (
10448 
    None, # 0
10449 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10450 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10451 
    (3, TType.STRING, 'link', None, None, ), # 3
10452 
    (4, TType.I64, 'priority', None, None, ), # 4
10453 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10454 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10455 
  )
10456 
 
10457 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10458 
    self.bannerName = bannerName
10459 
    self.imageName = imageName
10460 
    self.link = link
10461 
    self.priority = priority
10462 
    self.isActive = isActive
10463 
    self.hasMap = hasMap
10464 
 
10465 
  def read(self, iprot):
10466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10468 
      return
10469 
    iprot.readStructBegin()
10470 
    while True:
10471 
      (fname, ftype, fid) = iprot.readFieldBegin()
10472 
      if ftype == TType.STOP:
10473 
        break
10474 
      if fid == 1:
10475 
        if ftype == TType.STRING:
10476 
          self.bannerName = iprot.readString();
10477 
        else:
10478 
          iprot.skip(ftype)
10479 
      elif fid == 2:
10480 
        if ftype == TType.STRING:
10481 
          self.imageName = iprot.readString();
10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 3:
10485 
        if ftype == TType.STRING:
10486 
          self.link = iprot.readString();
10487 
        else:
10488 
          iprot.skip(ftype)
10489 
      elif fid == 4:
10490 
        if ftype == TType.I64:
10491 
          self.priority = iprot.readI64();
10492 
        else:
10493 
          iprot.skip(ftype)
10494 
      elif fid == 5:
10495 
        if ftype == TType.BOOL:
10496 
          self.isActive = iprot.readBool();
10497 
        else:
10498 
          iprot.skip(ftype)
10499 
      elif fid == 6:
10500 
        if ftype == TType.BOOL:
10501 
          self.hasMap = iprot.readBool();
10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      else:
10505 
        iprot.skip(ftype)
10506 
      iprot.readFieldEnd()
10507 
    iprot.readStructEnd()
10508 
 
10509 
  def write(self, oprot):
10510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10512 
      return
10513 
    oprot.writeStructBegin('addBanner_args')
10514 
    if self.bannerName is not None:
10515 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10516 
      oprot.writeString(self.bannerName)
10517 
      oprot.writeFieldEnd()
10518 
    if self.imageName is not None:
10519 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10520 
      oprot.writeString(self.imageName)
10521 
      oprot.writeFieldEnd()
10522 
    if self.link is not None:
10523 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10524 
      oprot.writeString(self.link)
10525 
      oprot.writeFieldEnd()
10526 
    if self.priority is not None:
10527 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10528 
      oprot.writeI64(self.priority)
10529 
      oprot.writeFieldEnd()
10530 
    if self.isActive is not None:
10531 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10532 
      oprot.writeBool(self.isActive)
10533 
      oprot.writeFieldEnd()
10534 
    if self.hasMap is not None:
10535 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10536 
      oprot.writeBool(self.hasMap)
10537 
      oprot.writeFieldEnd()
10538 
    oprot.writeFieldStop()
10539 
    oprot.writeStructEnd()
10540 
 
10541 
  def validate(self):
10542 
    return
10543 
 
10544 
 
10545 
  def __repr__(self):
10546 
    L = ['%s=%r' % (key, value)
10547 
      for key, value in self.__dict__.iteritems()]
10548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10549 
 
10550 
  def __eq__(self, other):
10551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10552 
 
10553 
  def __ne__(self, other):
10554 
    return not (self == other)
10555 
 
10556 
class addBanner_result:
10557 
  """
10558 
  Attributes:
10559 
   - success
10560 
  """
10561 
 
10562 
  thrift_spec = (
10563 
    (0, TType.BOOL, 'success', None, None, ), # 0
10564 
  )
10565 
 
10566 
  def __init__(self, success=None,):
10567 
    self.success = success
10568 
 
10569 
  def read(self, iprot):
10570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10572 
      return
10573 
    iprot.readStructBegin()
10574 
    while True:
10575 
      (fname, ftype, fid) = iprot.readFieldBegin()
10576 
      if ftype == TType.STOP:
10577 
        break
10578 
      if fid == 0:
10579 
        if ftype == TType.BOOL:
10580 
          self.success = iprot.readBool();
10581 
        else:
10582 
          iprot.skip(ftype)
10583 
      else:
10584 
        iprot.skip(ftype)
10585 
      iprot.readFieldEnd()
10586 
    iprot.readStructEnd()
10587 
 
10588 
  def write(self, oprot):
10589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10591 
      return
10592 
    oprot.writeStructBegin('addBanner_result')
10593 
    if self.success is not None:
10594 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10595 
      oprot.writeBool(self.success)
10596 
      oprot.writeFieldEnd()
10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
10615 
class getAllBanners_args:
10616 
 
10617 
  thrift_spec = (
10618 
  )
10619 
 
10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
10629 
      else:
10630 
        iprot.skip(ftype)
10631 
      iprot.readFieldEnd()
10632 
    iprot.readStructEnd()
10633 
 
10634 
  def write(self, oprot):
10635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10637 
      return
10638 
    oprot.writeStructBegin('getAllBanners_args')
10639 
    oprot.writeFieldStop()
10640 
    oprot.writeStructEnd()
10641 
 
10642 
  def validate(self):
10643 
    return
10644 
 
10645 
 
10646 
  def __repr__(self):
10647 
    L = ['%s=%r' % (key, value)
10648 
      for key, value in self.__dict__.iteritems()]
10649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10650 
 
10651 
  def __eq__(self, other):
10652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10653 
 
10654 
  def __ne__(self, other):
10655 
    return not (self == other)
10656 
 
10657 
class getAllBanners_result:
10658 
  """
10659 
  Attributes:
10660 
   - success
10661 
  """
10662 
 
10663 
  thrift_spec = (
10664 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10665 
  )
10666 
 
10667 
  def __init__(self, success=None,):
10668 
    self.success = success
10669 
 
10670 
  def read(self, iprot):
10671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10673 
      return
10674 
    iprot.readStructBegin()
10675 
    while True:
10676 
      (fname, ftype, fid) = iprot.readFieldBegin()
10677 
      if ftype == TType.STOP:
10678 
        break
10679 
      if fid == 0:
10680 
        if ftype == TType.LIST:
10681 
          self.success = []
10682 
          (_etype168, _size165) = iprot.readListBegin()
10683 
          for _i169 in xrange(_size165):
10684 
            _elem170 = iprot.readString();
10685 
            self.success.append(_elem170)
10686 
          iprot.readListEnd()
10687 
        else:
10688 
          iprot.skip(ftype)
10689 
      else:
10690 
        iprot.skip(ftype)
10691 
      iprot.readFieldEnd()
10692 
    iprot.readStructEnd()
10693 
 
10694 
  def write(self, oprot):
10695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10697 
      return
10698 
    oprot.writeStructBegin('getAllBanners_result')
10699 
    if self.success is not None:
10700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10701 
      oprot.writeListBegin(TType.STRING, len(self.success))
10702 
      for iter171 in self.success:
10703 
        oprot.writeString(iter171)
10704 
      oprot.writeListEnd()
10705 
      oprot.writeFieldEnd()
10706 
    oprot.writeFieldStop()
10707 
    oprot.writeStructEnd()
10708 
 
10709 
  def validate(self):
10710 
    return
10711 
 
10712 
 
10713 
  def __repr__(self):
10714 
    L = ['%s=%r' % (key, value)
10715 
      for key, value in self.__dict__.iteritems()]
10716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10717 
 
10718 
  def __eq__(self, other):
10719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10720 
 
10721 
  def __ne__(self, other):
10722 
    return not (self == other)
10723 
 
10724 
class deleteBanner_args:
10725 
  """
10726 
  Attributes:
10727 
   - bannerName
10728 
  """
10729 
 
10730 
  thrift_spec = (
10731 
    None, # 0
10732 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10733 
  )
10734 
 
10735 
  def __init__(self, bannerName=None,):
10736 
    self.bannerName = bannerName
10737 
 
10738 
  def read(self, iprot):
10739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10741 
      return
10742 
    iprot.readStructBegin()
10743 
    while True:
10744 
      (fname, ftype, fid) = iprot.readFieldBegin()
10745 
      if ftype == TType.STOP:
10746 
        break
10747 
      if fid == 1:
10748 
        if ftype == TType.STRING:
10749 
          self.bannerName = iprot.readString();
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      else:
10753 
        iprot.skip(ftype)
10754 
      iprot.readFieldEnd()
10755 
    iprot.readStructEnd()
10756 
 
10757 
  def write(self, oprot):
10758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10760 
      return
10761 
    oprot.writeStructBegin('deleteBanner_args')
10762 
    if self.bannerName is not None:
10763 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10764 
      oprot.writeString(self.bannerName)
10765 
      oprot.writeFieldEnd()
10766 
    oprot.writeFieldStop()
10767 
    oprot.writeStructEnd()
10768 
 
10769 
  def validate(self):
10770 
    return
10771 
 
10772 
 
10773 
  def __repr__(self):
10774 
    L = ['%s=%r' % (key, value)
10775 
      for key, value in self.__dict__.iteritems()]
10776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10777 
 
10778 
  def __eq__(self, other):
10779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10780 
 
10781 
  def __ne__(self, other):
10782 
    return not (self == other)
10783 
 
10784 
class deleteBanner_result:
10785 
  """
10786 
  Attributes:
10787 
   - success
10788 
  """
10789 
 
10790 
  thrift_spec = (
10791 
    (0, TType.BOOL, 'success', None, None, ), # 0
10792 
  )
10793 
 
10794 
  def __init__(self, success=None,):
10795 
    self.success = success
10796 
 
10797 
  def read(self, iprot):
10798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10800 
      return
10801 
    iprot.readStructBegin()
10802 
    while True:
10803 
      (fname, ftype, fid) = iprot.readFieldBegin()
10804 
      if ftype == TType.STOP:
10805 
        break
10806 
      if fid == 0:
10807 
        if ftype == TType.BOOL:
10808 
          self.success = iprot.readBool();
10809 
        else:
10810 
          iprot.skip(ftype)
10811 
      else:
10812 
        iprot.skip(ftype)
10813 
      iprot.readFieldEnd()
10814 
    iprot.readStructEnd()
10815 
 
10816 
  def write(self, oprot):
10817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10819 
      return
10820 
    oprot.writeStructBegin('deleteBanner_result')
10821 
    if self.success is not None:
10822 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10823 
      oprot.writeBool(self.success)
10824 
      oprot.writeFieldEnd()
10825 
    oprot.writeFieldStop()
10826 
    oprot.writeStructEnd()
10827 
 
10828 
  def validate(self):
10829 
    return
10830 
 
10831 
 
10832 
  def __repr__(self):
10833 
    L = ['%s=%r' % (key, value)
10834 
      for key, value in self.__dict__.iteritems()]
10835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10836 
 
10837 
  def __eq__(self, other):
10838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10839 
 
10840 
  def __ne__(self, other):
10841 
    return not (self == other)
10842 
 
10843 
class getBannerDetails_args:
10844 
  """
10845 
  Attributes:
10846 
   - bannerName
10847 
  """
10848 
 
10849 
  thrift_spec = (
10850 
    None, # 0
10851 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10852 
  )
10853 
 
10854 
  def __init__(self, bannerName=None,):
10855 
    self.bannerName = bannerName
10856 
 
10857 
  def read(self, iprot):
10858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10860 
      return
10861 
    iprot.readStructBegin()
10862 
    while True:
10863 
      (fname, ftype, fid) = iprot.readFieldBegin()
10864 
      if ftype == TType.STOP:
10865 
        break
10866 
      if fid == 1:
10867 
        if ftype == TType.STRING:
10868 
          self.bannerName = iprot.readString();
10869 
        else:
10870 
          iprot.skip(ftype)
10871 
      else:
10872 
        iprot.skip(ftype)
10873 
      iprot.readFieldEnd()
10874 
    iprot.readStructEnd()
10875 
 
10876 
  def write(self, oprot):
10877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10879 
      return
10880 
    oprot.writeStructBegin('getBannerDetails_args')
10881 
    if self.bannerName is not None:
10882 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10883 
      oprot.writeString(self.bannerName)
10884 
      oprot.writeFieldEnd()
10885 
    oprot.writeFieldStop()
10886 
    oprot.writeStructEnd()
10887 
 
10888 
  def validate(self):
10889 
    return
10890 
 
10891 
 
10892 
  def __repr__(self):
10893 
    L = ['%s=%r' % (key, value)
10894 
      for key, value in self.__dict__.iteritems()]
10895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10896 
 
10897 
  def __eq__(self, other):
10898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10899 
 
10900 
  def __ne__(self, other):
10901 
    return not (self == other)
10902 
 
10903 
class getBannerDetails_result:
10904 
  """
10905 
  Attributes:
10906 
   - success
10907 
  """
10908 
 
10909 
  thrift_spec = (
10910 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
10911 
  )
10912 
 
10913 
  def __init__(self, success=None,):
10914 
    self.success = success
10915 
 
10916 
  def read(self, iprot):
10917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10919 
      return
10920 
    iprot.readStructBegin()
10921 
    while True:
10922 
      (fname, ftype, fid) = iprot.readFieldBegin()
10923 
      if ftype == TType.STOP:
10924 
        break
10925 
      if fid == 0:
10926 
        if ftype == TType.STRUCT:
10927 
          self.success = Banner()
10928 
          self.success.read(iprot)
10929 
        else:
10930 
          iprot.skip(ftype)
10931 
      else:
10932 
        iprot.skip(ftype)
10933 
      iprot.readFieldEnd()
10934 
    iprot.readStructEnd()
10935 
 
10936 
  def write(self, oprot):
10937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10939 
      return
10940 
    oprot.writeStructBegin('getBannerDetails_result')
10941 
    if self.success is not None:
10942 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10943 
      self.success.write(oprot)
10944 
      oprot.writeFieldEnd()
10945 
    oprot.writeFieldStop()
10946 
    oprot.writeStructEnd()
10947 
 
10948 
  def validate(self):
10949 
    return
10950 
 
10951 
 
10952 
  def __repr__(self):
10953 
    L = ['%s=%r' % (key, value)
10954 
      for key, value in self.__dict__.iteritems()]
10955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10956 
 
10957 
  def __eq__(self, other):
10958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10959 
 
10960 
  def __ne__(self, other):
10961 
    return not (self == other)
10962 
 
10963 
class getActiveBanners_args:
10964 
 
10965 
  thrift_spec = (
10966 
  )
10967 
 
10968 
  def read(self, iprot):
10969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10971 
      return
10972 
    iprot.readStructBegin()
10973 
    while True:
10974 
      (fname, ftype, fid) = iprot.readFieldBegin()
10975 
      if ftype == TType.STOP:
10976 
        break
10977 
      else:
10978 
        iprot.skip(ftype)
10979 
      iprot.readFieldEnd()
10980 
    iprot.readStructEnd()
10981 
 
10982 
  def write(self, oprot):
10983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10985 
      return
10986 
    oprot.writeStructBegin('getActiveBanners_args')
10987 
    oprot.writeFieldStop()
10988 
    oprot.writeStructEnd()
10989 
 
10990 
  def validate(self):
10991 
    return
10992 
 
10993 
 
10994 
  def __repr__(self):
10995 
    L = ['%s=%r' % (key, value)
10996 
      for key, value in self.__dict__.iteritems()]
10997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10998 
 
10999 
  def __eq__(self, other):
11000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11001 
 
11002 
  def __ne__(self, other):
11003 
    return not (self == other)
11004 
 
11005 
class getActiveBanners_result:
11006 
  """
11007 
  Attributes:
11008 
   - success
11009 
  """
11010 
 
11011 
  thrift_spec = (
11012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11013 
  )
11014 
 
11015 
  def __init__(self, success=None,):
11016 
    self.success = success
11017 
 
11018 
  def read(self, iprot):
11019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11021 
      return
11022 
    iprot.readStructBegin()
11023 
    while True:
11024 
      (fname, ftype, fid) = iprot.readFieldBegin()
11025 
      if ftype == TType.STOP:
11026 
        break
11027 
      if fid == 0:
11028 
        if ftype == TType.LIST:
11029 
          self.success = []
11030 
          (_etype175, _size172) = iprot.readListBegin()
11031 
          for _i176 in xrange(_size172):
11032 
            _elem177 = Banner()
11033 
            _elem177.read(iprot)
11034 
            self.success.append(_elem177)
11035 
          iprot.readListEnd()
11036 
        else:
11037 
          iprot.skip(ftype)
11038 
      else:
11039 
        iprot.skip(ftype)
11040 
      iprot.readFieldEnd()
11041 
    iprot.readStructEnd()
11042 
 
11043 
  def write(self, oprot):
11044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11046 
      return
11047 
    oprot.writeStructBegin('getActiveBanners_result')
11048 
    if self.success is not None:
11049 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11050 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11051 
      for iter178 in self.success:
11052 
        iter178.write(oprot)
11053 
      oprot.writeListEnd()
11054 
      oprot.writeFieldEnd()
11055 
    oprot.writeFieldStop()
11056 
    oprot.writeStructEnd()
11057 
 
11058 
  def validate(self):
11059 
    return
11060 
 
11061 
 
11062 
  def __repr__(self):
11063 
    L = ['%s=%r' % (key, value)
11064 
      for key, value in self.__dict__.iteritems()]
11065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11066 
 
11067 
  def __eq__(self, other):
11068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11069 
 
11070 
  def __ne__(self, other):
11071 
    return not (self == other)
11072 
 
6849 kshitij.so 11073 
class addBannerMap_args:
11074 
  """
11075 
  Attributes:
11076 
   - bannerName
11077 
   - mapLink
11078 
   - coordinates
11079 
  """
11080 
 
11081 
  thrift_spec = (
11082 
    None, # 0
11083 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11084 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11085 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11086 
  )
11087 
 
11088 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11089 
    self.bannerName = bannerName
11090 
    self.mapLink = mapLink
11091 
    self.coordinates = coordinates
11092 
 
11093 
  def read(self, iprot):
11094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11096 
      return
11097 
    iprot.readStructBegin()
11098 
    while True:
11099 
      (fname, ftype, fid) = iprot.readFieldBegin()
11100 
      if ftype == TType.STOP:
11101 
        break
11102 
      if fid == 1:
11103 
        if ftype == TType.STRING:
11104 
          self.bannerName = iprot.readString();
11105 
        else:
11106 
          iprot.skip(ftype)
11107 
      elif fid == 2:
11108 
        if ftype == TType.STRING:
11109 
          self.mapLink = iprot.readString();
11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      elif fid == 3:
11113 
        if ftype == TType.STRING:
11114 
          self.coordinates = iprot.readString();
11115 
        else:
11116 
          iprot.skip(ftype)
11117 
      else:
11118 
        iprot.skip(ftype)
11119 
      iprot.readFieldEnd()
11120 
    iprot.readStructEnd()
11121 
 
11122 
  def write(self, oprot):
11123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11125 
      return
11126 
    oprot.writeStructBegin('addBannerMap_args')
11127 
    if self.bannerName is not None:
11128 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11129 
      oprot.writeString(self.bannerName)
11130 
      oprot.writeFieldEnd()
11131 
    if self.mapLink is not None:
11132 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11133 
      oprot.writeString(self.mapLink)
11134 
      oprot.writeFieldEnd()
11135 
    if self.coordinates is not None:
11136 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11137 
      oprot.writeString(self.coordinates)
11138 
      oprot.writeFieldEnd()
11139 
    oprot.writeFieldStop()
11140 
    oprot.writeStructEnd()
11141 
 
11142 
  def validate(self):
11143 
    return
11144 
 
11145 
 
11146 
  def __repr__(self):
11147 
    L = ['%s=%r' % (key, value)
11148 
      for key, value in self.__dict__.iteritems()]
11149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11150 
 
11151 
  def __eq__(self, other):
11152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11153 
 
11154 
  def __ne__(self, other):
11155 
    return not (self == other)
11156 
 
11157 
class addBannerMap_result:
11158 
  """
11159 
  Attributes:
11160 
   - success
11161 
  """
11162 
 
11163 
  thrift_spec = (
11164 
    (0, TType.BOOL, 'success', None, None, ), # 0
11165 
  )
11166 
 
11167 
  def __init__(self, success=None,):
11168 
    self.success = success
11169 
 
11170 
  def read(self, iprot):
11171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11173 
      return
11174 
    iprot.readStructBegin()
11175 
    while True:
11176 
      (fname, ftype, fid) = iprot.readFieldBegin()
11177 
      if ftype == TType.STOP:
11178 
        break
11179 
      if fid == 0:
11180 
        if ftype == TType.BOOL:
11181 
          self.success = iprot.readBool();
11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      else:
11185 
        iprot.skip(ftype)
11186 
      iprot.readFieldEnd()
11187 
    iprot.readStructEnd()
11188 
 
11189 
  def write(self, oprot):
11190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11192 
      return
11193 
    oprot.writeStructBegin('addBannerMap_result')
11194 
    if self.success is not None:
11195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11196 
      oprot.writeBool(self.success)
11197 
      oprot.writeFieldEnd()
11198 
    oprot.writeFieldStop()
11199 
    oprot.writeStructEnd()
11200 
 
11201 
  def validate(self):
11202 
    return
11203 
 
11204 
 
11205 
  def __repr__(self):
11206 
    L = ['%s=%r' % (key, value)
11207 
      for key, value in self.__dict__.iteritems()]
11208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11209 
 
11210 
  def __eq__(self, other):
11211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11212 
 
11213 
  def __ne__(self, other):
11214 
    return not (self == other)
11215 
 
11216 
class deleteBannerMap_args:
11217 
  """
11218 
  Attributes:
11219 
   - bannerName
11220 
  """
11221 
 
11222 
  thrift_spec = (
11223 
    None, # 0
11224 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11225 
  )
11226 
 
11227 
  def __init__(self, bannerName=None,):
11228 
    self.bannerName = bannerName
11229 
 
11230 
  def read(self, iprot):
11231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11233 
      return
11234 
    iprot.readStructBegin()
11235 
    while True:
11236 
      (fname, ftype, fid) = iprot.readFieldBegin()
11237 
      if ftype == TType.STOP:
11238 
        break
11239 
      if fid == 1:
11240 
        if ftype == TType.STRING:
11241 
          self.bannerName = iprot.readString();
11242 
        else:
11243 
          iprot.skip(ftype)
11244 
      else:
11245 
        iprot.skip(ftype)
11246 
      iprot.readFieldEnd()
11247 
    iprot.readStructEnd()
11248 
 
11249 
  def write(self, oprot):
11250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11252 
      return
11253 
    oprot.writeStructBegin('deleteBannerMap_args')
11254 
    if self.bannerName is not None:
11255 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11256 
      oprot.writeString(self.bannerName)
11257 
      oprot.writeFieldEnd()
11258 
    oprot.writeFieldStop()
11259 
    oprot.writeStructEnd()
11260 
 
11261 
  def validate(self):
11262 
    return
11263 
 
11264 
 
11265 
  def __repr__(self):
11266 
    L = ['%s=%r' % (key, value)
11267 
      for key, value in self.__dict__.iteritems()]
11268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11269 
 
11270 
  def __eq__(self, other):
11271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11272 
 
11273 
  def __ne__(self, other):
11274 
    return not (self == other)
11275 
 
11276 
class deleteBannerMap_result:
11277 
  """
11278 
  Attributes:
11279 
   - success
11280 
  """
11281 
 
11282 
  thrift_spec = (
11283 
    (0, TType.BOOL, 'success', None, None, ), # 0
11284 
  )
11285 
 
11286 
  def __init__(self, success=None,):
11287 
    self.success = success
11288 
 
11289 
  def read(self, iprot):
11290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11292 
      return
11293 
    iprot.readStructBegin()
11294 
    while True:
11295 
      (fname, ftype, fid) = iprot.readFieldBegin()
11296 
      if ftype == TType.STOP:
11297 
        break
11298 
      if fid == 0:
11299 
        if ftype == TType.BOOL:
11300 
          self.success = iprot.readBool();
11301 
        else:
11302 
          iprot.skip(ftype)
11303 
      else:
11304 
        iprot.skip(ftype)
11305 
      iprot.readFieldEnd()
11306 
    iprot.readStructEnd()
11307 
 
11308 
  def write(self, oprot):
11309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11311 
      return
11312 
    oprot.writeStructBegin('deleteBannerMap_result')
11313 
    if self.success is not None:
11314 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11315 
      oprot.writeBool(self.success)
11316 
      oprot.writeFieldEnd()
11317 
    oprot.writeFieldStop()
11318 
    oprot.writeStructEnd()
11319 
 
11320 
  def validate(self):
11321 
    return
11322 
 
11323 
 
11324 
  def __repr__(self):
11325 
    L = ['%s=%r' % (key, value)
11326 
      for key, value in self.__dict__.iteritems()]
11327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11328 
 
11329 
  def __eq__(self, other):
11330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11331 
 
11332 
  def __ne__(self, other):
11333 
    return not (self == other)
11334 
 
11335 
class getBannerMapDetails_args:
11336 
  """
11337 
  Attributes:
11338 
   - bannerName
11339 
  """
11340 
 
11341 
  thrift_spec = (
11342 
    None, # 0
11343 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11344 
  )
11345 
 
11346 
  def __init__(self, bannerName=None,):
11347 
    self.bannerName = bannerName
11348 
 
11349 
  def read(self, iprot):
11350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11352 
      return
11353 
    iprot.readStructBegin()
11354 
    while True:
11355 
      (fname, ftype, fid) = iprot.readFieldBegin()
11356 
      if ftype == TType.STOP:
11357 
        break
11358 
      if fid == 1:
11359 
        if ftype == TType.STRING:
11360 
          self.bannerName = iprot.readString();
11361 
        else:
11362 
          iprot.skip(ftype)
11363 
      else:
11364 
        iprot.skip(ftype)
11365 
      iprot.readFieldEnd()
11366 
    iprot.readStructEnd()
11367 
 
11368 
  def write(self, oprot):
11369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11371 
      return
11372 
    oprot.writeStructBegin('getBannerMapDetails_args')
11373 
    if self.bannerName is not None:
11374 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11375 
      oprot.writeString(self.bannerName)
11376 
      oprot.writeFieldEnd()
11377 
    oprot.writeFieldStop()
11378 
    oprot.writeStructEnd()
11379 
 
11380 
  def validate(self):
11381 
    return
11382 
 
11383 
 
11384 
  def __repr__(self):
11385 
    L = ['%s=%r' % (key, value)
11386 
      for key, value in self.__dict__.iteritems()]
11387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11388 
 
11389 
  def __eq__(self, other):
11390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11391 
 
11392 
  def __ne__(self, other):
11393 
    return not (self == other)
11394 
 
11395 
class getBannerMapDetails_result:
11396 
  """
11397 
  Attributes:
11398 
   - success
11399 
  """
11400 
 
11401 
  thrift_spec = (
11402 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11403 
  )
11404 
 
11405 
  def __init__(self, success=None,):
11406 
    self.success = success
11407 
 
11408 
  def read(self, iprot):
11409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11411 
      return
11412 
    iprot.readStructBegin()
11413 
    while True:
11414 
      (fname, ftype, fid) = iprot.readFieldBegin()
11415 
      if ftype == TType.STOP:
11416 
        break
11417 
      if fid == 0:
11418 
        if ftype == TType.LIST:
11419 
          self.success = []
6850 kshitij.so 11420 
          (_etype182, _size179) = iprot.readListBegin()
11421 
          for _i183 in xrange(_size179):
11422 
            _elem184 = BannerMap()
11423 
            _elem184.read(iprot)
11424 
            self.success.append(_elem184)
6849 kshitij.so 11425 
          iprot.readListEnd()
11426 
        else:
11427 
          iprot.skip(ftype)
11428 
      else:
11429 
        iprot.skip(ftype)
11430 
      iprot.readFieldEnd()
11431 
    iprot.readStructEnd()
11432 
 
11433 
  def write(self, oprot):
11434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11436 
      return
11437 
    oprot.writeStructBegin('getBannerMapDetails_result')
11438 
    if self.success is not None:
11439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 11441 
      for iter185 in self.success:
11442 
        iter185.write(oprot)
6849 kshitij.so 11443 
      oprot.writeListEnd()
11444 
      oprot.writeFieldEnd()
11445 
    oprot.writeFieldStop()
11446 
    oprot.writeStructEnd()
11447 
 
11448 
  def validate(self):
11449 
    return
11450 
 
11451 
 
11452 
  def __repr__(self):
11453 
    L = ['%s=%r' % (key, value)
11454 
      for key, value in self.__dict__.iteritems()]
11455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11456 
 
11457 
  def __eq__(self, other):
11458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11459 
 
11460 
  def __ne__(self, other):
11461 
    return not (self == other)
11462 
 
5944 mandeep.dh 11463 
class deleteSimilarItem_args:
11464 
  """
11465 
  Attributes:
11466 
   - itemId
11467 
   - catalogItemId
11468 
  """
11469 
 
11470 
  thrift_spec = (
11471 
    None, # 0
11472 
    (1, TType.I64, 'itemId', None, None, ), # 1
11473 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11474 
  )
11475 
 
11476 
  def __init__(self, itemId=None, catalogItemId=None,):
11477 
    self.itemId = itemId
11478 
    self.catalogItemId = catalogItemId
11479 
 
11480 
  def read(self, iprot):
11481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11483 
      return
11484 
    iprot.readStructBegin()
11485 
    while True:
11486 
      (fname, ftype, fid) = iprot.readFieldBegin()
11487 
      if ftype == TType.STOP:
11488 
        break
11489 
      if fid == 1:
11490 
        if ftype == TType.I64:
11491 
          self.itemId = iprot.readI64();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      elif fid == 2:
11495 
        if ftype == TType.I64:
11496 
          self.catalogItemId = iprot.readI64();
11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      else:
11500 
        iprot.skip(ftype)
11501 
      iprot.readFieldEnd()
11502 
    iprot.readStructEnd()
11503 
 
11504 
  def write(self, oprot):
11505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11507 
      return
11508 
    oprot.writeStructBegin('deleteSimilarItem_args')
11509 
    if self.itemId is not None:
11510 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11511 
      oprot.writeI64(self.itemId)
11512 
      oprot.writeFieldEnd()
11513 
    if self.catalogItemId is not None:
11514 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11515 
      oprot.writeI64(self.catalogItemId)
11516 
      oprot.writeFieldEnd()
11517 
    oprot.writeFieldStop()
11518 
    oprot.writeStructEnd()
11519 
 
11520 
  def validate(self):
11521 
    return
11522 
 
11523 
 
11524 
  def __repr__(self):
11525 
    L = ['%s=%r' % (key, value)
11526 
      for key, value in self.__dict__.iteritems()]
11527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11528 
 
11529 
  def __eq__(self, other):
11530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11531 
 
11532 
  def __ne__(self, other):
11533 
    return not (self == other)
11534 
 
11535 
class deleteSimilarItem_result:
11536 
  """
11537 
  Attributes:
11538 
   - success
11539 
   - cex
11540 
  """
11541 
 
11542 
  thrift_spec = (
11543 
    (0, TType.BOOL, 'success', None, None, ), # 0
11544 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11545 
  )
11546 
 
11547 
  def __init__(self, success=None, cex=None,):
11548 
    self.success = success
11549 
    self.cex = cex
11550 
 
11551 
  def read(self, iprot):
11552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11554 
      return
11555 
    iprot.readStructBegin()
11556 
    while True:
11557 
      (fname, ftype, fid) = iprot.readFieldBegin()
11558 
      if ftype == TType.STOP:
11559 
        break
11560 
      if fid == 0:
11561 
        if ftype == TType.BOOL:
11562 
          self.success = iprot.readBool();
11563 
        else:
11564 
          iprot.skip(ftype)
11565 
      elif fid == 1:
11566 
        if ftype == TType.STRUCT:
11567 
          self.cex = CatalogServiceException()
11568 
          self.cex.read(iprot)
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      else:
11572 
        iprot.skip(ftype)
11573 
      iprot.readFieldEnd()
11574 
    iprot.readStructEnd()
11575 
 
11576 
  def write(self, oprot):
11577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11579 
      return
11580 
    oprot.writeStructBegin('deleteSimilarItem_result')
11581 
    if self.success is not None:
11582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11583 
      oprot.writeBool(self.success)
11584 
      oprot.writeFieldEnd()
11585 
    if self.cex is not None:
11586 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11587 
      self.cex.write(oprot)
11588 
      oprot.writeFieldEnd()
11589 
    oprot.writeFieldStop()
11590 
    oprot.writeStructEnd()
11591 
 
11592 
  def validate(self):
11593 
    return
11594 
 
11595 
 
11596 
  def __repr__(self):
11597 
    L = ['%s=%r' % (key, value)
11598 
      for key, value in self.__dict__.iteritems()]
11599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11600 
 
11601 
  def __eq__(self, other):
11602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11603 
 
11604 
  def __ne__(self, other):
11605 
    return not (self == other)
11606 
 
11607 
class checkSimilarItem_args:
11608 
  """
11609 
  Attributes:
11610 
   - brand
11611 
   - modelNumber
11612 
   - modelName
11613 
   - color
11614 
  """
11615 
 
11616 
  thrift_spec = (
11617 
    None, # 0
11618 
    (1, TType.STRING, 'brand', None, None, ), # 1
11619 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11620 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11621 
    (4, TType.STRING, 'color', None, None, ), # 4
11622 
  )
11623 
 
11624 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11625 
    self.brand = brand
11626 
    self.modelNumber = modelNumber
11627 
    self.modelName = modelName
11628 
    self.color = color
11629 
 
11630 
  def read(self, iprot):
11631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11633 
      return
11634 
    iprot.readStructBegin()
11635 
    while True:
11636 
      (fname, ftype, fid) = iprot.readFieldBegin()
11637 
      if ftype == TType.STOP:
11638 
        break
11639 
      if fid == 1:
11640 
        if ftype == TType.STRING:
11641 
          self.brand = iprot.readString();
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      elif fid == 2:
11645 
        if ftype == TType.STRING:
11646 
          self.modelNumber = iprot.readString();
11647 
        else:
11648 
          iprot.skip(ftype)
11649 
      elif fid == 3:
11650 
        if ftype == TType.STRING:
11651 
          self.modelName = iprot.readString();
11652 
        else:
11653 
          iprot.skip(ftype)
11654 
      elif fid == 4:
11655 
        if ftype == TType.STRING:
11656 
          self.color = iprot.readString();
11657 
        else:
11658 
          iprot.skip(ftype)
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('checkSimilarItem_args')
11669 
    if self.brand is not None:
11670 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11671 
      oprot.writeString(self.brand)
11672 
      oprot.writeFieldEnd()
11673 
    if self.modelNumber is not None:
11674 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11675 
      oprot.writeString(self.modelNumber)
11676 
      oprot.writeFieldEnd()
11677 
    if self.modelName is not None:
11678 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11679 
      oprot.writeString(self.modelName)
11680 
      oprot.writeFieldEnd()
11681 
    if self.color is not None:
11682 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11683 
      oprot.writeString(self.color)
11684 
      oprot.writeFieldEnd()
11685 
    oprot.writeFieldStop()
11686 
    oprot.writeStructEnd()
11687 
 
11688 
  def validate(self):
11689 
    return
11690 
 
11691 
 
11692 
  def __repr__(self):
11693 
    L = ['%s=%r' % (key, value)
11694 
      for key, value in self.__dict__.iteritems()]
11695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11696 
 
11697 
  def __eq__(self, other):
11698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11699 
 
11700 
  def __ne__(self, other):
11701 
    return not (self == other)
11702 
 
11703 
class checkSimilarItem_result:
11704 
  """
11705 
  Attributes:
11706 
   - success
11707 
  """
11708 
 
11709 
  thrift_spec = (
11710 
    (0, TType.I64, 'success', None, None, ), # 0
11711 
  )
11712 
 
11713 
  def __init__(self, success=None,):
11714 
    self.success = success
11715 
 
11716 
  def read(self, iprot):
11717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11719 
      return
11720 
    iprot.readStructBegin()
11721 
    while True:
11722 
      (fname, ftype, fid) = iprot.readFieldBegin()
11723 
      if ftype == TType.STOP:
11724 
        break
11725 
      if fid == 0:
11726 
        if ftype == TType.I64:
11727 
          self.success = iprot.readI64();
11728 
        else:
11729 
          iprot.skip(ftype)
11730 
      else:
11731 
        iprot.skip(ftype)
11732 
      iprot.readFieldEnd()
11733 
    iprot.readStructEnd()
11734 
 
11735 
  def write(self, oprot):
11736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11738 
      return
11739 
    oprot.writeStructBegin('checkSimilarItem_result')
11740 
    if self.success is not None:
11741 
      oprot.writeFieldBegin('success', TType.I64, 0)
11742 
      oprot.writeI64(self.success)
11743 
      oprot.writeFieldEnd()
11744 
    oprot.writeFieldStop()
11745 
    oprot.writeStructEnd()
11746 
 
11747 
  def validate(self):
11748 
    return
11749 
 
11750 
 
11751 
  def __repr__(self):
11752 
    L = ['%s=%r' % (key, value)
11753 
      for key, value in self.__dict__.iteritems()]
11754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11755 
 
11756 
  def __eq__(self, other):
11757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11758 
 
11759 
  def __ne__(self, other):
11760 
    return not (self == other)
11761 
 
11762 
class validateRiskyStatus_args:
11763 
  """
11764 
  Attributes:
11765 
   - itemId
11766 
  """
11767 
 
11768 
  thrift_spec = (
11769 
    None, # 0
11770 
    (1, TType.I64, 'itemId', None, None, ), # 1
11771 
  )
11772 
 
11773 
  def __init__(self, itemId=None,):
11774 
    self.itemId = itemId
11775 
 
11776 
  def read(self, iprot):
11777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11779 
      return
11780 
    iprot.readStructBegin()
11781 
    while True:
11782 
      (fname, ftype, fid) = iprot.readFieldBegin()
11783 
      if ftype == TType.STOP:
11784 
        break
11785 
      if fid == 1:
11786 
        if ftype == TType.I64:
11787 
          self.itemId = iprot.readI64();
11788 
        else:
11789 
          iprot.skip(ftype)
11790 
      else:
11791 
        iprot.skip(ftype)
11792 
      iprot.readFieldEnd()
11793 
    iprot.readStructEnd()
11794 
 
11795 
  def write(self, oprot):
11796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11798 
      return
11799 
    oprot.writeStructBegin('validateRiskyStatus_args')
11800 
    if self.itemId is not None:
11801 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11802 
      oprot.writeI64(self.itemId)
11803 
      oprot.writeFieldEnd()
11804 
    oprot.writeFieldStop()
11805 
    oprot.writeStructEnd()
11806 
 
11807 
  def validate(self):
11808 
    return
11809 
 
11810 
 
11811 
  def __repr__(self):
11812 
    L = ['%s=%r' % (key, value)
11813 
      for key, value in self.__dict__.iteritems()]
11814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11815 
 
11816 
  def __eq__(self, other):
11817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11818 
 
11819 
  def __ne__(self, other):
11820 
    return not (self == other)
11821 
 
11822 
class validateRiskyStatus_result:
11823 
 
11824 
  thrift_spec = (
11825 
  )
11826 
 
11827 
  def read(self, iprot):
11828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11830 
      return
11831 
    iprot.readStructBegin()
11832 
    while True:
11833 
      (fname, ftype, fid) = iprot.readFieldBegin()
11834 
      if ftype == TType.STOP:
11835 
        break
11836 
      else:
11837 
        iprot.skip(ftype)
11838 
      iprot.readFieldEnd()
11839 
    iprot.readStructEnd()
11840 
 
11841 
  def write(self, oprot):
11842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11844 
      return
11845 
    oprot.writeStructBegin('validateRiskyStatus_result')
11846 
    oprot.writeFieldStop()
11847 
    oprot.writeStructEnd()
11848 
 
11849 
  def validate(self):
11850 
    return
11851 
 
11852 
 
11853 
  def __repr__(self):
11854 
    L = ['%s=%r' % (key, value)
11855 
      for key, value in self.__dict__.iteritems()]
11856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11857 
 
11858 
  def __eq__(self, other):
11859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11860 
 
11861 
  def __ne__(self, other):
11862 
    return not (self == other)
11863 
 
11864 
class changeItemRiskyFlag_args:
11865 
  """
11866 
  Attributes:
11867 
   - itemId
11868 
   - risky
11869 
  """
11870 
 
11871 
  thrift_spec = (
11872 
    None, # 0
11873 
    (1, TType.I64, 'itemId', None, None, ), # 1
11874 
    (2, TType.BOOL, 'risky', None, None, ), # 2
11875 
  )
11876 
 
11877 
  def __init__(self, itemId=None, risky=None,):
11878 
    self.itemId = itemId
11879 
    self.risky = risky
11880 
 
11881 
  def read(self, iprot):
11882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11884 
      return
11885 
    iprot.readStructBegin()
11886 
    while True:
11887 
      (fname, ftype, fid) = iprot.readFieldBegin()
11888 
      if ftype == TType.STOP:
11889 
        break
11890 
      if fid == 1:
11891 
        if ftype == TType.I64:
11892 
          self.itemId = iprot.readI64();
11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      elif fid == 2:
11896 
        if ftype == TType.BOOL:
11897 
          self.risky = iprot.readBool();
11898 
        else:
11899 
          iprot.skip(ftype)
11900 
      else:
11901 
        iprot.skip(ftype)
11902 
      iprot.readFieldEnd()
11903 
    iprot.readStructEnd()
11904 
 
11905 
  def write(self, oprot):
11906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11908 
      return
11909 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
11910 
    if self.itemId is not None:
11911 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11912 
      oprot.writeI64(self.itemId)
11913 
      oprot.writeFieldEnd()
11914 
    if self.risky is not None:
11915 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
11916 
      oprot.writeBool(self.risky)
11917 
      oprot.writeFieldEnd()
11918 
    oprot.writeFieldStop()
11919 
    oprot.writeStructEnd()
11920 
 
11921 
  def validate(self):
11922 
    return
11923 
 
11924 
 
11925 
  def __repr__(self):
11926 
    L = ['%s=%r' % (key, value)
11927 
      for key, value in self.__dict__.iteritems()]
11928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11929 
 
11930 
  def __eq__(self, other):
11931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11932 
 
11933 
  def __ne__(self, other):
11934 
    return not (self == other)
11935 
 
11936 
class changeItemRiskyFlag_result:
11937 
 
11938 
  thrift_spec = (
11939 
  )
11940 
 
11941 
  def read(self, iprot):
11942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11944 
      return
11945 
    iprot.readStructBegin()
11946 
    while True:
11947 
      (fname, ftype, fid) = iprot.readFieldBegin()
11948 
      if ftype == TType.STOP:
11949 
        break
11950 
      else:
11951 
        iprot.skip(ftype)
11952 
      iprot.readFieldEnd()
11953 
    iprot.readStructEnd()
11954 
 
11955 
  def write(self, oprot):
11956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11958 
      return
11959 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
11960 
    oprot.writeFieldStop()
11961 
    oprot.writeStructEnd()
11962 
 
11963 
  def validate(self):
11964 
    return
11965 
 
11966 
 
11967 
  def __repr__(self):
11968 
    L = ['%s=%r' % (key, value)
11969 
      for key, value in self.__dict__.iteritems()]
11970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11971 
 
11972 
  def __eq__(self, other):
11973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11974 
 
11975 
  def __ne__(self, other):
11976 
    return not (self == other)
11977 
 
11978 
class getItemsByRiskyFlag_args:
11979 
 
11980 
  thrift_spec = (
11981 
  )
11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      else:
11993 
        iprot.skip(ftype)
11994 
      iprot.readFieldEnd()
11995 
    iprot.readStructEnd()
11996 
 
11997 
  def write(self, oprot):
11998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12000 
      return
12001 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12002 
    oprot.writeFieldStop()
12003 
    oprot.writeStructEnd()
12004 
 
12005 
  def validate(self):
12006 
    return
12007 
 
12008 
 
12009 
  def __repr__(self):
12010 
    L = ['%s=%r' % (key, value)
12011 
      for key, value in self.__dict__.iteritems()]
12012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12013 
 
12014 
  def __eq__(self, other):
12015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12016 
 
12017 
  def __ne__(self, other):
12018 
    return not (self == other)
12019 
 
12020 
class getItemsByRiskyFlag_result:
12021 
  """
12022 
  Attributes:
12023 
   - success
12024 
  """
12025 
 
12026 
  thrift_spec = (
12027 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12028 
  )
12029 
 
12030 
  def __init__(self, success=None,):
12031 
    self.success = success
12032 
 
12033 
  def read(self, iprot):
12034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12036 
      return
12037 
    iprot.readStructBegin()
12038 
    while True:
12039 
      (fname, ftype, fid) = iprot.readFieldBegin()
12040 
      if ftype == TType.STOP:
12041 
        break
12042 
      if fid == 0:
12043 
        if ftype == TType.LIST:
12044 
          self.success = []
6850 kshitij.so 12045 
          (_etype189, _size186) = iprot.readListBegin()
12046 
          for _i190 in xrange(_size186):
12047 
            _elem191 = Item()
12048 
            _elem191.read(iprot)
12049 
            self.success.append(_elem191)
5944 mandeep.dh 12050 
          iprot.readListEnd()
12051 
        else:
12052 
          iprot.skip(ftype)
12053 
      else:
12054 
        iprot.skip(ftype)
12055 
      iprot.readFieldEnd()
12056 
    iprot.readStructEnd()
12057 
 
12058 
  def write(self, oprot):
12059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12061 
      return
12062 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12063 
    if self.success is not None:
12064 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12065 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12066 
      for iter192 in self.success:
12067 
        iter192.write(oprot)
5944 mandeep.dh 12068 
      oprot.writeListEnd()
12069 
      oprot.writeFieldEnd()
12070 
    oprot.writeFieldStop()
12071 
    oprot.writeStructEnd()
12072 
 
12073 
  def validate(self):
12074 
    return
12075 
 
12076 
 
12077 
  def __repr__(self):
12078 
    L = ['%s=%r' % (key, value)
12079 
      for key, value in self.__dict__.iteritems()]
12080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12081 
 
12082 
  def __eq__(self, other):
12083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12084 
 
12085 
  def __ne__(self, other):
12086 
    return not (self == other)
12087 
 
12088 
class getItemsForMasterSheet_args:
12089 
  """
12090 
  Attributes:
12091 
   - category
12092 
   - brand
12093 
  """
12094 
 
12095 
  thrift_spec = (
12096 
    None, # 0
12097 
    (1, TType.STRING, 'category', None, None, ), # 1
12098 
    (2, TType.STRING, 'brand', None, None, ), # 2
12099 
  )
12100 
 
12101 
  def __init__(self, category=None, brand=None,):
12102 
    self.category = category
12103 
    self.brand = brand
12104 
 
12105 
  def read(self, iprot):
12106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12108 
      return
12109 
    iprot.readStructBegin()
12110 
    while True:
12111 
      (fname, ftype, fid) = iprot.readFieldBegin()
12112 
      if ftype == TType.STOP:
12113 
        break
12114 
      if fid == 1:
12115 
        if ftype == TType.STRING:
12116 
          self.category = iprot.readString();
12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      elif fid == 2:
12120 
        if ftype == TType.STRING:
12121 
          self.brand = iprot.readString();
12122 
        else:
12123 
          iprot.skip(ftype)
12124 
      else:
12125 
        iprot.skip(ftype)
12126 
      iprot.readFieldEnd()
12127 
    iprot.readStructEnd()
12128 
 
12129 
  def write(self, oprot):
12130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12132 
      return
12133 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12134 
    if self.category is not None:
12135 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12136 
      oprot.writeString(self.category)
12137 
      oprot.writeFieldEnd()
12138 
    if self.brand is not None:
12139 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12140 
      oprot.writeString(self.brand)
12141 
      oprot.writeFieldEnd()
12142 
    oprot.writeFieldStop()
12143 
    oprot.writeStructEnd()
12144 
 
12145 
  def validate(self):
12146 
    return
12147 
 
12148 
 
12149 
  def __repr__(self):
12150 
    L = ['%s=%r' % (key, value)
12151 
      for key, value in self.__dict__.iteritems()]
12152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12153 
 
12154 
  def __eq__(self, other):
12155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12156 
 
12157 
  def __ne__(self, other):
12158 
    return not (self == other)
12159 
 
12160 
class getItemsForMasterSheet_result:
12161 
  """
12162 
  Attributes:
12163 
   - success
12164 
  """
12165 
 
12166 
  thrift_spec = (
12167 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12168 
  )
12169 
 
12170 
  def __init__(self, success=None,):
12171 
    self.success = success
12172 
 
12173 
  def read(self, iprot):
12174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12176 
      return
12177 
    iprot.readStructBegin()
12178 
    while True:
12179 
      (fname, ftype, fid) = iprot.readFieldBegin()
12180 
      if ftype == TType.STOP:
12181 
        break
12182 
      if fid == 0:
12183 
        if ftype == TType.LIST:
12184 
          self.success = []
6850 kshitij.so 12185 
          (_etype196, _size193) = iprot.readListBegin()
12186 
          for _i197 in xrange(_size193):
12187 
            _elem198 = Item()
12188 
            _elem198.read(iprot)
12189 
            self.success.append(_elem198)
5944 mandeep.dh 12190 
          iprot.readListEnd()
12191 
        else:
12192 
          iprot.skip(ftype)
12193 
      else:
12194 
        iprot.skip(ftype)
12195 
      iprot.readFieldEnd()
12196 
    iprot.readStructEnd()
12197 
 
12198 
  def write(self, oprot):
12199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12201 
      return
12202 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12203 
    if self.success is not None:
12204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12206 
      for iter199 in self.success:
12207 
        iter199.write(oprot)
5944 mandeep.dh 12208 
      oprot.writeListEnd()
12209 
      oprot.writeFieldEnd()
12210 
    oprot.writeFieldStop()
12211 
    oprot.writeStructEnd()
12212 
 
12213 
  def validate(self):
12214 
    return
12215 
 
12216 
 
12217 
  def __repr__(self):
12218 
    L = ['%s=%r' % (key, value)
12219 
      for key, value in self.__dict__.iteritems()]
12220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12221 
 
12222 
  def __eq__(self, other):
12223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12224 
 
12225 
  def __ne__(self, other):
12226 
    return not (self == other)
12227 
 
12228 
class getSimilarItemsCatalogIds_args:
12229 
  """
12230 
  Attributes:
12231 
   - beginIndex
12232 
   - totalItems
12233 
   - itemId
12234 
  """
12235 
 
12236 
  thrift_spec = (
12237 
    None, # 0
12238 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12239 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12240 
    (3, TType.I64, 'itemId', None, None, ), # 3
12241 
  )
12242 
 
12243 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12244 
    self.beginIndex = beginIndex
12245 
    self.totalItems = totalItems
12246 
    self.itemId = itemId
12247 
 
12248 
  def read(self, iprot):
12249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12251 
      return
12252 
    iprot.readStructBegin()
12253 
    while True:
12254 
      (fname, ftype, fid) = iprot.readFieldBegin()
12255 
      if ftype == TType.STOP:
12256 
        break
12257 
      if fid == 1:
12258 
        if ftype == TType.I64:
12259 
          self.beginIndex = iprot.readI64();
12260 
        else:
12261 
          iprot.skip(ftype)
12262 
      elif fid == 2:
12263 
        if ftype == TType.I64:
12264 
          self.totalItems = iprot.readI64();
12265 
        else:
12266 
          iprot.skip(ftype)
12267 
      elif fid == 3:
12268 
        if ftype == TType.I64:
12269 
          self.itemId = iprot.readI64();
12270 
        else:
12271 
          iprot.skip(ftype)
12272 
      else:
12273 
        iprot.skip(ftype)
12274 
      iprot.readFieldEnd()
12275 
    iprot.readStructEnd()
12276 
 
12277 
  def write(self, oprot):
12278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12280 
      return
12281 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12282 
    if self.beginIndex is not None:
12283 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12284 
      oprot.writeI64(self.beginIndex)
12285 
      oprot.writeFieldEnd()
12286 
    if self.totalItems is not None:
12287 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12288 
      oprot.writeI64(self.totalItems)
12289 
      oprot.writeFieldEnd()
12290 
    if self.itemId is not None:
12291 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12292 
      oprot.writeI64(self.itemId)
12293 
      oprot.writeFieldEnd()
12294 
    oprot.writeFieldStop()
12295 
    oprot.writeStructEnd()
12296 
 
12297 
  def validate(self):
12298 
    return
12299 
 
12300 
 
12301 
  def __repr__(self):
12302 
    L = ['%s=%r' % (key, value)
12303 
      for key, value in self.__dict__.iteritems()]
12304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12305 
 
12306 
  def __eq__(self, other):
12307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12308 
 
12309 
  def __ne__(self, other):
12310 
    return not (self == other)
12311 
 
12312 
class getSimilarItemsCatalogIds_result:
12313 
  """
12314 
  Attributes:
12315 
   - success
12316 
  """
12317 
 
12318 
  thrift_spec = (
12319 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12320 
  )
12321 
 
12322 
  def __init__(self, success=None,):
12323 
    self.success = success
12324 
 
12325 
  def read(self, iprot):
12326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12328 
      return
12329 
    iprot.readStructBegin()
12330 
    while True:
12331 
      (fname, ftype, fid) = iprot.readFieldBegin()
12332 
      if ftype == TType.STOP:
12333 
        break
12334 
      if fid == 0:
12335 
        if ftype == TType.LIST:
12336 
          self.success = []
6850 kshitij.so 12337 
          (_etype203, _size200) = iprot.readListBegin()
12338 
          for _i204 in xrange(_size200):
12339 
            _elem205 = iprot.readI64();
12340 
            self.success.append(_elem205)
5944 mandeep.dh 12341 
          iprot.readListEnd()
12342 
        else:
12343 
          iprot.skip(ftype)
12344 
      else:
12345 
        iprot.skip(ftype)
12346 
      iprot.readFieldEnd()
12347 
    iprot.readStructEnd()
12348 
 
12349 
  def write(self, oprot):
12350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12352 
      return
12353 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12354 
    if self.success is not None:
12355 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12356 
      oprot.writeListBegin(TType.I64, len(self.success))
6850 kshitij.so 12357 
      for iter206 in self.success:
12358 
        oprot.writeI64(iter206)
5944 mandeep.dh 12359 
      oprot.writeListEnd()
12360 
      oprot.writeFieldEnd()
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
12379 
class addProductNotification_args:
12380 
  """
12381 
  Attributes:
12382 
   - itemId
12383 
   - email
12384 
  """
12385 
 
12386 
  thrift_spec = None
12387 
  def __init__(self, itemId=None, email=None,):
12388 
    self.itemId = itemId
12389 
    self.email = email
12390 
 
12391 
  def read(self, iprot):
12392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12394 
      return
12395 
    iprot.readStructBegin()
12396 
    while True:
12397 
      (fname, ftype, fid) = iprot.readFieldBegin()
12398 
      if ftype == TType.STOP:
12399 
        break
12400 
      if fid == -1:
12401 
        if ftype == TType.I64:
12402 
          self.itemId = iprot.readI64();
12403 
        else:
12404 
          iprot.skip(ftype)
12405 
      elif fid == -2:
12406 
        if ftype == TType.STRING:
12407 
          self.email = iprot.readString();
12408 
        else:
12409 
          iprot.skip(ftype)
12410 
      else:
12411 
        iprot.skip(ftype)
12412 
      iprot.readFieldEnd()
12413 
    iprot.readStructEnd()
12414 
 
12415 
  def write(self, oprot):
12416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12418 
      return
12419 
    oprot.writeStructBegin('addProductNotification_args')
12420 
    if self.email is not None:
12421 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12422 
      oprot.writeString(self.email)
12423 
      oprot.writeFieldEnd()
12424 
    if self.itemId is not None:
12425 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12426 
      oprot.writeI64(self.itemId)
12427 
      oprot.writeFieldEnd()
12428 
    oprot.writeFieldStop()
12429 
    oprot.writeStructEnd()
12430 
 
12431 
  def validate(self):
12432 
    return
12433 
 
12434 
 
12435 
  def __repr__(self):
12436 
    L = ['%s=%r' % (key, value)
12437 
      for key, value in self.__dict__.iteritems()]
12438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12439 
 
12440 
  def __eq__(self, other):
12441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12442 
 
12443 
  def __ne__(self, other):
12444 
    return not (self == other)
12445 
 
12446 
class addProductNotification_result:
12447 
  """
12448 
  Attributes:
12449 
   - success
12450 
  """
12451 
 
12452 
  thrift_spec = (
12453 
    (0, TType.BOOL, 'success', None, None, ), # 0
12454 
  )
12455 
 
12456 
  def __init__(self, success=None,):
12457 
    self.success = success
12458 
 
12459 
  def read(self, iprot):
12460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12462 
      return
12463 
    iprot.readStructBegin()
12464 
    while True:
12465 
      (fname, ftype, fid) = iprot.readFieldBegin()
12466 
      if ftype == TType.STOP:
12467 
        break
12468 
      if fid == 0:
12469 
        if ftype == TType.BOOL:
12470 
          self.success = iprot.readBool();
12471 
        else:
12472 
          iprot.skip(ftype)
12473 
      else:
12474 
        iprot.skip(ftype)
12475 
      iprot.readFieldEnd()
12476 
    iprot.readStructEnd()
12477 
 
12478 
  def write(self, oprot):
12479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12481 
      return
12482 
    oprot.writeStructBegin('addProductNotification_result')
12483 
    if self.success is not None:
12484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12485 
      oprot.writeBool(self.success)
12486 
      oprot.writeFieldEnd()
12487 
    oprot.writeFieldStop()
12488 
    oprot.writeStructEnd()
12489 
 
12490 
  def validate(self):
12491 
    return
12492 
 
12493 
 
12494 
  def __repr__(self):
12495 
    L = ['%s=%r' % (key, value)
12496 
      for key, value in self.__dict__.iteritems()]
12497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12498 
 
12499 
  def __eq__(self, other):
12500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12501 
 
12502 
  def __ne__(self, other):
12503 
    return not (self == other)
12504 
 
12505 
class sendProductNotifications_args:
12506 
 
12507 
  thrift_spec = (
12508 
  )
12509 
 
12510 
  def read(self, iprot):
12511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12513 
      return
12514 
    iprot.readStructBegin()
12515 
    while True:
12516 
      (fname, ftype, fid) = iprot.readFieldBegin()
12517 
      if ftype == TType.STOP:
12518 
        break
12519 
      else:
12520 
        iprot.skip(ftype)
12521 
      iprot.readFieldEnd()
12522 
    iprot.readStructEnd()
12523 
 
12524 
  def write(self, oprot):
12525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12527 
      return
12528 
    oprot.writeStructBegin('sendProductNotifications_args')
12529 
    oprot.writeFieldStop()
12530 
    oprot.writeStructEnd()
12531 
 
12532 
  def validate(self):
12533 
    return
12534 
 
12535 
 
12536 
  def __repr__(self):
12537 
    L = ['%s=%r' % (key, value)
12538 
      for key, value in self.__dict__.iteritems()]
12539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12540 
 
12541 
  def __eq__(self, other):
12542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12543 
 
12544 
  def __ne__(self, other):
12545 
    return not (self == other)
12546 
 
12547 
class sendProductNotifications_result:
12548 
  """
12549 
  Attributes:
12550 
   - success
12551 
  """
12552 
 
12553 
  thrift_spec = (
12554 
    (0, TType.BOOL, 'success', None, None, ), # 0
12555 
  )
12556 
 
12557 
  def __init__(self, success=None,):
12558 
    self.success = success
12559 
 
12560 
  def read(self, iprot):
12561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12563 
      return
12564 
    iprot.readStructBegin()
12565 
    while True:
12566 
      (fname, ftype, fid) = iprot.readFieldBegin()
12567 
      if ftype == TType.STOP:
12568 
        break
12569 
      if fid == 0:
12570 
        if ftype == TType.BOOL:
12571 
          self.success = iprot.readBool();
12572 
        else:
12573 
          iprot.skip(ftype)
12574 
      else:
12575 
        iprot.skip(ftype)
12576 
      iprot.readFieldEnd()
12577 
    iprot.readStructEnd()
12578 
 
12579 
  def write(self, oprot):
12580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12582 
      return
12583 
    oprot.writeStructBegin('sendProductNotifications_result')
12584 
    if self.success is not None:
12585 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12586 
      oprot.writeBool(self.success)
12587 
      oprot.writeFieldEnd()
12588 
    oprot.writeFieldStop()
12589 
    oprot.writeStructEnd()
12590 
 
12591 
  def validate(self):
12592 
    return
12593 
 
12594 
 
12595 
  def __repr__(self):
12596 
    L = ['%s=%r' % (key, value)
12597 
      for key, value in self.__dict__.iteritems()]
12598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12599 
 
12600 
  def __eq__(self, other):
12601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12602 
 
12603 
  def __ne__(self, other):
12604 
    return not (self == other)
12605 
 
12606 
class getAllBrandsByCategory_args:
12607 
  """
12608 
  Attributes:
12609 
   - categoryId
12610 
  """
12611 
 
12612 
  thrift_spec = (
12613 
    None, # 0
12614 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12615 
  )
12616 
 
12617 
  def __init__(self, categoryId=None,):
12618 
    self.categoryId = categoryId
12619 
 
12620 
  def read(self, iprot):
12621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12623 
      return
12624 
    iprot.readStructBegin()
12625 
    while True:
12626 
      (fname, ftype, fid) = iprot.readFieldBegin()
12627 
      if ftype == TType.STOP:
12628 
        break
12629 
      if fid == 1:
12630 
        if ftype == TType.I64:
12631 
          self.categoryId = iprot.readI64();
12632 
        else:
12633 
          iprot.skip(ftype)
12634 
      else:
12635 
        iprot.skip(ftype)
12636 
      iprot.readFieldEnd()
12637 
    iprot.readStructEnd()
12638 
 
12639 
  def write(self, oprot):
12640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12642 
      return
12643 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12644 
    if self.categoryId is not None:
12645 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12646 
      oprot.writeI64(self.categoryId)
12647 
      oprot.writeFieldEnd()
12648 
    oprot.writeFieldStop()
12649 
    oprot.writeStructEnd()
12650 
 
12651 
  def validate(self):
12652 
    return
12653 
 
12654 
 
12655 
  def __repr__(self):
12656 
    L = ['%s=%r' % (key, value)
12657 
      for key, value in self.__dict__.iteritems()]
12658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12659 
 
12660 
  def __eq__(self, other):
12661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12662 
 
12663 
  def __ne__(self, other):
12664 
    return not (self == other)
12665 
 
12666 
class getAllBrandsByCategory_result:
12667 
  """
12668 
  Attributes:
12669 
   - success
12670 
  """
12671 
 
12672 
  thrift_spec = (
12673 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12674 
  )
12675 
 
12676 
  def __init__(self, success=None,):
12677 
    self.success = success
12678 
 
12679 
  def read(self, iprot):
12680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12682 
      return
12683 
    iprot.readStructBegin()
12684 
    while True:
12685 
      (fname, ftype, fid) = iprot.readFieldBegin()
12686 
      if ftype == TType.STOP:
12687 
        break
12688 
      if fid == 0:
12689 
        if ftype == TType.LIST:
12690 
          self.success = []
6850 kshitij.so 12691 
          (_etype210, _size207) = iprot.readListBegin()
12692 
          for _i211 in xrange(_size207):
12693 
            _elem212 = iprot.readString();
12694 
            self.success.append(_elem212)
5944 mandeep.dh 12695 
          iprot.readListEnd()
12696 
        else:
12697 
          iprot.skip(ftype)
12698 
      else:
12699 
        iprot.skip(ftype)
12700 
      iprot.readFieldEnd()
12701 
    iprot.readStructEnd()
12702 
 
12703 
  def write(self, oprot):
12704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12706 
      return
12707 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12708 
    if self.success is not None:
12709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12710 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12711 
      for iter213 in self.success:
12712 
        oprot.writeString(iter213)
5944 mandeep.dh 12713 
      oprot.writeListEnd()
12714 
      oprot.writeFieldEnd()
12715 
    oprot.writeFieldStop()
12716 
    oprot.writeStructEnd()
12717 
 
12718 
  def validate(self):
12719 
    return
12720 
 
12721 
 
12722 
  def __repr__(self):
12723 
    L = ['%s=%r' % (key, value)
12724 
      for key, value in self.__dict__.iteritems()]
12725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12726 
 
12727 
  def __eq__(self, other):
12728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12729 
 
12730 
  def __ne__(self, other):
12731 
    return not (self == other)
12732 
 
12733 
class getAllBrands_args:
12734 
 
12735 
  thrift_spec = (
12736 
  )
12737 
 
12738 
  def read(self, iprot):
12739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12741 
      return
12742 
    iprot.readStructBegin()
12743 
    while True:
12744 
      (fname, ftype, fid) = iprot.readFieldBegin()
12745 
      if ftype == TType.STOP:
12746 
        break
12747 
      else:
12748 
        iprot.skip(ftype)
12749 
      iprot.readFieldEnd()
12750 
    iprot.readStructEnd()
12751 
 
12752 
  def write(self, oprot):
12753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12755 
      return
12756 
    oprot.writeStructBegin('getAllBrands_args')
12757 
    oprot.writeFieldStop()
12758 
    oprot.writeStructEnd()
12759 
 
12760 
  def validate(self):
12761 
    return
12762 
 
12763 
 
12764 
  def __repr__(self):
12765 
    L = ['%s=%r' % (key, value)
12766 
      for key, value in self.__dict__.iteritems()]
12767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12768 
 
12769 
  def __eq__(self, other):
12770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12771 
 
12772 
  def __ne__(self, other):
12773 
    return not (self == other)
12774 
 
12775 
class getAllBrands_result:
12776 
  """
12777 
  Attributes:
12778 
   - success
12779 
  """
12780 
 
12781 
  thrift_spec = (
12782 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12783 
  )
12784 
 
12785 
  def __init__(self, success=None,):
12786 
    self.success = success
12787 
 
12788 
  def read(self, iprot):
12789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12791 
      return
12792 
    iprot.readStructBegin()
12793 
    while True:
12794 
      (fname, ftype, fid) = iprot.readFieldBegin()
12795 
      if ftype == TType.STOP:
12796 
        break
12797 
      if fid == 0:
12798 
        if ftype == TType.LIST:
12799 
          self.success = []
6850 kshitij.so 12800 
          (_etype217, _size214) = iprot.readListBegin()
12801 
          for _i218 in xrange(_size214):
12802 
            _elem219 = iprot.readString();
12803 
            self.success.append(_elem219)
5944 mandeep.dh 12804 
          iprot.readListEnd()
12805 
        else:
12806 
          iprot.skip(ftype)
12807 
      else:
12808 
        iprot.skip(ftype)
12809 
      iprot.readFieldEnd()
12810 
    iprot.readStructEnd()
12811 
 
12812 
  def write(self, oprot):
12813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12815 
      return
12816 
    oprot.writeStructBegin('getAllBrands_result')
12817 
    if self.success is not None:
12818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12819 
      oprot.writeListBegin(TType.STRING, len(self.success))
6850 kshitij.so 12820 
      for iter220 in self.success:
12821 
        oprot.writeString(iter220)
5944 mandeep.dh 12822 
      oprot.writeListEnd()
12823 
      oprot.writeFieldEnd()
12824 
    oprot.writeFieldStop()
12825 
    oprot.writeStructEnd()
12826 
 
12827 
  def validate(self):
12828 
    return
12829 
 
12830 
 
12831 
  def __repr__(self):
12832 
    L = ['%s=%r' % (key, value)
12833 
      for key, value in self.__dict__.iteritems()]
12834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12835 
 
12836 
  def __eq__(self, other):
12837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12838 
 
12839 
  def __ne__(self, other):
12840 
    return not (self == other)
12841 
 
12842 
class getAllSources_args:
12843 
 
12844 
  thrift_spec = (
12845 
  )
12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      else:
12857 
        iprot.skip(ftype)
12858 
      iprot.readFieldEnd()
12859 
    iprot.readStructEnd()
12860 
 
12861 
  def write(self, oprot):
12862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12864 
      return
12865 
    oprot.writeStructBegin('getAllSources_args')
12866 
    oprot.writeFieldStop()
12867 
    oprot.writeStructEnd()
12868 
 
12869 
  def validate(self):
12870 
    return
12871 
 
12872 
 
12873 
  def __repr__(self):
12874 
    L = ['%s=%r' % (key, value)
12875 
      for key, value in self.__dict__.iteritems()]
12876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12877 
 
12878 
  def __eq__(self, other):
12879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12880 
 
12881 
  def __ne__(self, other):
12882 
    return not (self == other)
12883 
 
12884 
class getAllSources_result:
12885 
  """
12886 
  Attributes:
12887 
   - success
12888 
  """
12889 
 
12890 
  thrift_spec = (
12891 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
12892 
  )
12893 
 
12894 
  def __init__(self, success=None,):
12895 
    self.success = success
12896 
 
12897 
  def read(self, iprot):
12898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12900 
      return
12901 
    iprot.readStructBegin()
12902 
    while True:
12903 
      (fname, ftype, fid) = iprot.readFieldBegin()
12904 
      if ftype == TType.STOP:
12905 
        break
12906 
      if fid == 0:
12907 
        if ftype == TType.LIST:
12908 
          self.success = []
6850 kshitij.so 12909 
          (_etype224, _size221) = iprot.readListBegin()
12910 
          for _i225 in xrange(_size221):
12911 
            _elem226 = Source()
12912 
            _elem226.read(iprot)
12913 
            self.success.append(_elem226)
5944 mandeep.dh 12914 
          iprot.readListEnd()
12915 
        else:
12916 
          iprot.skip(ftype)
12917 
      else:
12918 
        iprot.skip(ftype)
12919 
      iprot.readFieldEnd()
12920 
    iprot.readStructEnd()
12921 
 
12922 
  def write(self, oprot):
12923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12925 
      return
12926 
    oprot.writeStructBegin('getAllSources_result')
12927 
    if self.success is not None:
12928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 12930 
      for iter227 in self.success:
12931 
        iter227.write(oprot)
5944 mandeep.dh 12932 
      oprot.writeListEnd()
12933 
      oprot.writeFieldEnd()
12934 
    oprot.writeFieldStop()
12935 
    oprot.writeStructEnd()
12936 
 
12937 
  def validate(self):
12938 
    return
12939 
 
12940 
 
12941 
  def __repr__(self):
12942 
    L = ['%s=%r' % (key, value)
12943 
      for key, value in self.__dict__.iteritems()]
12944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12945 
 
12946 
  def __eq__(self, other):
12947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12948 
 
12949 
  def __ne__(self, other):
12950 
    return not (self == other)
12951 
 
12952 
class getItemPricingBySource_args:
12953 
  """
12954 
  Attributes:
12955 
   - itemId
12956 
   - sourceId
12957 
  """
12958 
 
12959 
  thrift_spec = (
12960 
    None, # 0
12961 
    (1, TType.I64, 'itemId', None, None, ), # 1
12962 
    (2, TType.I64, 'sourceId', None, None, ), # 2
12963 
  )
12964 
 
12965 
  def __init__(self, itemId=None, sourceId=None,):
12966 
    self.itemId = itemId
12967 
    self.sourceId = sourceId
12968 
 
12969 
  def read(self, iprot):
12970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12972 
      return
12973 
    iprot.readStructBegin()
12974 
    while True:
12975 
      (fname, ftype, fid) = iprot.readFieldBegin()
12976 
      if ftype == TType.STOP:
12977 
        break
12978 
      if fid == 1:
12979 
        if ftype == TType.I64:
12980 
          self.itemId = iprot.readI64();
12981 
        else:
12982 
          iprot.skip(ftype)
12983 
      elif fid == 2:
12984 
        if ftype == TType.I64:
12985 
          self.sourceId = iprot.readI64();
12986 
        else:
12987 
          iprot.skip(ftype)
12988 
      else:
12989 
        iprot.skip(ftype)
12990 
      iprot.readFieldEnd()
12991 
    iprot.readStructEnd()
12992 
 
12993 
  def write(self, oprot):
12994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12996 
      return
12997 
    oprot.writeStructBegin('getItemPricingBySource_args')
12998 
    if self.itemId is not None:
12999 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13000 
      oprot.writeI64(self.itemId)
13001 
      oprot.writeFieldEnd()
13002 
    if self.sourceId is not None:
13003 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13004 
      oprot.writeI64(self.sourceId)
13005 
      oprot.writeFieldEnd()
13006 
    oprot.writeFieldStop()
13007 
    oprot.writeStructEnd()
13008 
 
13009 
  def validate(self):
13010 
    return
13011 
 
13012 
 
13013 
  def __repr__(self):
13014 
    L = ['%s=%r' % (key, value)
13015 
      for key, value in self.__dict__.iteritems()]
13016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13017 
 
13018 
  def __eq__(self, other):
13019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13020 
 
13021 
  def __ne__(self, other):
13022 
    return not (self == other)
13023 
 
13024 
class getItemPricingBySource_result:
13025 
  """
13026 
  Attributes:
13027 
   - success
13028 
   - cex
13029 
  """
13030 
 
13031 
  thrift_spec = (
13032 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13033 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13034 
  )
13035 
 
13036 
  def __init__(self, success=None, cex=None,):
13037 
    self.success = success
13038 
    self.cex = cex
13039 
 
13040 
  def read(self, iprot):
13041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13043 
      return
13044 
    iprot.readStructBegin()
13045 
    while True:
13046 
      (fname, ftype, fid) = iprot.readFieldBegin()
13047 
      if ftype == TType.STOP:
13048 
        break
13049 
      if fid == 0:
13050 
        if ftype == TType.STRUCT:
13051 
          self.success = SourceItemPricing()
13052 
          self.success.read(iprot)
13053 
        else:
13054 
          iprot.skip(ftype)
13055 
      elif fid == 1:
13056 
        if ftype == TType.STRUCT:
13057 
          self.cex = CatalogServiceException()
13058 
          self.cex.read(iprot)
13059 
        else:
13060 
          iprot.skip(ftype)
13061 
      else:
13062 
        iprot.skip(ftype)
13063 
      iprot.readFieldEnd()
13064 
    iprot.readStructEnd()
13065 
 
13066 
  def write(self, oprot):
13067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13069 
      return
13070 
    oprot.writeStructBegin('getItemPricingBySource_result')
13071 
    if self.success is not None:
13072 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13073 
      self.success.write(oprot)
13074 
      oprot.writeFieldEnd()
13075 
    if self.cex is not None:
13076 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13077 
      self.cex.write(oprot)
13078 
      oprot.writeFieldEnd()
13079 
    oprot.writeFieldStop()
13080 
    oprot.writeStructEnd()
13081 
 
13082 
  def validate(self):
13083 
    return
13084 
 
13085 
 
13086 
  def __repr__(self):
13087 
    L = ['%s=%r' % (key, value)
13088 
      for key, value in self.__dict__.iteritems()]
13089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13090 
 
13091 
  def __eq__(self, other):
13092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13093 
 
13094 
  def __ne__(self, other):
13095 
    return not (self == other)
13096 
 
13097 
class addSourceItemPricing_args:
13098 
  """
13099 
  Attributes:
13100 
   - sourceItemPricing
13101 
  """
13102 
 
13103 
  thrift_spec = (
13104 
    None, # 0
13105 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13106 
  )
13107 
 
13108 
  def __init__(self, sourceItemPricing=None,):
13109 
    self.sourceItemPricing = sourceItemPricing
13110 
 
13111 
  def read(self, iprot):
13112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13114 
      return
13115 
    iprot.readStructBegin()
13116 
    while True:
13117 
      (fname, ftype, fid) = iprot.readFieldBegin()
13118 
      if ftype == TType.STOP:
13119 
        break
13120 
      if fid == 1:
13121 
        if ftype == TType.STRUCT:
13122 
          self.sourceItemPricing = SourceItemPricing()
13123 
          self.sourceItemPricing.read(iprot)
13124 
        else:
13125 
          iprot.skip(ftype)
13126 
      else:
13127 
        iprot.skip(ftype)
13128 
      iprot.readFieldEnd()
13129 
    iprot.readStructEnd()
13130 
 
13131 
  def write(self, oprot):
13132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13134 
      return
13135 
    oprot.writeStructBegin('addSourceItemPricing_args')
13136 
    if self.sourceItemPricing is not None:
13137 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13138 
      self.sourceItemPricing.write(oprot)
13139 
      oprot.writeFieldEnd()
13140 
    oprot.writeFieldStop()
13141 
    oprot.writeStructEnd()
13142 
 
13143 
  def validate(self):
13144 
    return
13145 
 
13146 
 
13147 
  def __repr__(self):
13148 
    L = ['%s=%r' % (key, value)
13149 
      for key, value in self.__dict__.iteritems()]
13150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13151 
 
13152 
  def __eq__(self, other):
13153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13154 
 
13155 
  def __ne__(self, other):
13156 
    return not (self == other)
13157 
 
13158 
class addSourceItemPricing_result:
13159 
  """
13160 
  Attributes:
13161 
   - cex
13162 
  """
13163 
 
13164 
  thrift_spec = (
13165 
    None, # 0
13166 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13167 
  )
13168 
 
13169 
  def __init__(self, cex=None,):
13170 
    self.cex = cex
13171 
 
13172 
  def read(self, iprot):
13173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13175 
      return
13176 
    iprot.readStructBegin()
13177 
    while True:
13178 
      (fname, ftype, fid) = iprot.readFieldBegin()
13179 
      if ftype == TType.STOP:
13180 
        break
13181 
      if fid == 1:
13182 
        if ftype == TType.STRUCT:
13183 
          self.cex = CatalogServiceException()
13184 
          self.cex.read(iprot)
13185 
        else:
13186 
          iprot.skip(ftype)
13187 
      else:
13188 
        iprot.skip(ftype)
13189 
      iprot.readFieldEnd()
13190 
    iprot.readStructEnd()
13191 
 
13192 
  def write(self, oprot):
13193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13195 
      return
13196 
    oprot.writeStructBegin('addSourceItemPricing_result')
13197 
    if self.cex is not None:
13198 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13199 
      self.cex.write(oprot)
13200 
      oprot.writeFieldEnd()
13201 
    oprot.writeFieldStop()
13202 
    oprot.writeStructEnd()
13203 
 
13204 
  def validate(self):
13205 
    return
13206 
 
13207 
 
13208 
  def __repr__(self):
13209 
    L = ['%s=%r' % (key, value)
13210 
      for key, value in self.__dict__.iteritems()]
13211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13212 
 
13213 
  def __eq__(self, other):
13214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13215 
 
13216 
  def __ne__(self, other):
13217 
    return not (self == other)
13218 
 
13219 
class getAllSourcePricing_args:
13220 
  """
13221 
  Attributes:
13222 
   - itemId
13223 
  """
13224 
 
13225 
  thrift_spec = (
13226 
    None, # 0
13227 
    (1, TType.I64, 'itemId', None, None, ), # 1
13228 
  )
13229 
 
13230 
  def __init__(self, itemId=None,):
13231 
    self.itemId = itemId
13232 
 
13233 
  def read(self, iprot):
13234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13236 
      return
13237 
    iprot.readStructBegin()
13238 
    while True:
13239 
      (fname, ftype, fid) = iprot.readFieldBegin()
13240 
      if ftype == TType.STOP:
13241 
        break
13242 
      if fid == 1:
13243 
        if ftype == TType.I64:
13244 
          self.itemId = iprot.readI64();
13245 
        else:
13246 
          iprot.skip(ftype)
13247 
      else:
13248 
        iprot.skip(ftype)
13249 
      iprot.readFieldEnd()
13250 
    iprot.readStructEnd()
13251 
 
13252 
  def write(self, oprot):
13253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13255 
      return
13256 
    oprot.writeStructBegin('getAllSourcePricing_args')
13257 
    if self.itemId is not None:
13258 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13259 
      oprot.writeI64(self.itemId)
13260 
      oprot.writeFieldEnd()
13261 
    oprot.writeFieldStop()
13262 
    oprot.writeStructEnd()
13263 
 
13264 
  def validate(self):
13265 
    return
13266 
 
13267 
 
13268 
  def __repr__(self):
13269 
    L = ['%s=%r' % (key, value)
13270 
      for key, value in self.__dict__.iteritems()]
13271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13272 
 
13273 
  def __eq__(self, other):
13274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13275 
 
13276 
  def __ne__(self, other):
13277 
    return not (self == other)
13278 
 
13279 
class getAllSourcePricing_result:
13280 
  """
13281 
  Attributes:
13282 
   - success
13283 
   - cex
13284 
  """
13285 
 
13286 
  thrift_spec = (
13287 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13288 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13289 
  )
13290 
 
13291 
  def __init__(self, success=None, cex=None,):
13292 
    self.success = success
13293 
    self.cex = cex
13294 
 
13295 
  def read(self, iprot):
13296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13298 
      return
13299 
    iprot.readStructBegin()
13300 
    while True:
13301 
      (fname, ftype, fid) = iprot.readFieldBegin()
13302 
      if ftype == TType.STOP:
13303 
        break
13304 
      if fid == 0:
13305 
        if ftype == TType.LIST:
13306 
          self.success = []
6850 kshitij.so 13307 
          (_etype231, _size228) = iprot.readListBegin()
13308 
          for _i232 in xrange(_size228):
13309 
            _elem233 = SourceItemPricing()
13310 
            _elem233.read(iprot)
13311 
            self.success.append(_elem233)
5944 mandeep.dh 13312 
          iprot.readListEnd()
13313 
        else:
13314 
          iprot.skip(ftype)
13315 
      elif fid == 1:
13316 
        if ftype == TType.STRUCT:
13317 
          self.cex = CatalogServiceException()
13318 
          self.cex.read(iprot)
13319 
        else:
13320 
          iprot.skip(ftype)
13321 
      else:
13322 
        iprot.skip(ftype)
13323 
      iprot.readFieldEnd()
13324 
    iprot.readStructEnd()
13325 
 
13326 
  def write(self, oprot):
13327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13329 
      return
13330 
    oprot.writeStructBegin('getAllSourcePricing_result')
13331 
    if self.success is not None:
13332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13334 
      for iter234 in self.success:
13335 
        iter234.write(oprot)
5944 mandeep.dh 13336 
      oprot.writeListEnd()
13337 
      oprot.writeFieldEnd()
13338 
    if self.cex is not None:
13339 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13340 
      self.cex.write(oprot)
13341 
      oprot.writeFieldEnd()
13342 
    oprot.writeFieldStop()
13343 
    oprot.writeStructEnd()
13344 
 
13345 
  def validate(self):
13346 
    return
13347 
 
13348 
 
13349 
  def __repr__(self):
13350 
    L = ['%s=%r' % (key, value)
13351 
      for key, value in self.__dict__.iteritems()]
13352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13353 
 
13354 
  def __eq__(self, other):
13355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13356 
 
13357 
  def __ne__(self, other):
13358 
    return not (self == other)
13359 
 
13360 
class getItemForSource_args:
13361 
  """
13362 
  Attributes:
13363 
   - item_id
13364 
   - sourceId
13365 
  """
13366 
 
13367 
  thrift_spec = (
13368 
    None, # 0
13369 
    (1, TType.I64, 'item_id', None, None, ), # 1
13370 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13371 
  )
13372 
 
13373 
  def __init__(self, item_id=None, sourceId=None,):
13374 
    self.item_id = item_id
13375 
    self.sourceId = sourceId
13376 
 
13377 
  def read(self, iprot):
13378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13380 
      return
13381 
    iprot.readStructBegin()
13382 
    while True:
13383 
      (fname, ftype, fid) = iprot.readFieldBegin()
13384 
      if ftype == TType.STOP:
13385 
        break
13386 
      if fid == 1:
13387 
        if ftype == TType.I64:
13388 
          self.item_id = iprot.readI64();
13389 
        else:
13390 
          iprot.skip(ftype)
13391 
      elif fid == 2:
13392 
        if ftype == TType.I64:
13393 
          self.sourceId = iprot.readI64();
13394 
        else:
13395 
          iprot.skip(ftype)
13396 
      else:
13397 
        iprot.skip(ftype)
13398 
      iprot.readFieldEnd()
13399 
    iprot.readStructEnd()
13400 
 
13401 
  def write(self, oprot):
13402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13404 
      return
13405 
    oprot.writeStructBegin('getItemForSource_args')
13406 
    if self.item_id is not None:
13407 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13408 
      oprot.writeI64(self.item_id)
13409 
      oprot.writeFieldEnd()
13410 
    if self.sourceId is not None:
13411 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13412 
      oprot.writeI64(self.sourceId)
13413 
      oprot.writeFieldEnd()
13414 
    oprot.writeFieldStop()
13415 
    oprot.writeStructEnd()
13416 
 
13417 
  def validate(self):
13418 
    return
13419 
 
13420 
 
13421 
  def __repr__(self):
13422 
    L = ['%s=%r' % (key, value)
13423 
      for key, value in self.__dict__.iteritems()]
13424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13425 
 
13426 
  def __eq__(self, other):
13427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13428 
 
13429 
  def __ne__(self, other):
13430 
    return not (self == other)
13431 
 
13432 
class getItemForSource_result:
13433 
  """
13434 
  Attributes:
13435 
   - success
13436 
   - cex
13437 
  """
13438 
 
13439 
  thrift_spec = (
13440 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13441 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13442 
  )
13443 
 
13444 
  def __init__(self, success=None, cex=None,):
13445 
    self.success = success
13446 
    self.cex = cex
13447 
 
13448 
  def read(self, iprot):
13449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13451 
      return
13452 
    iprot.readStructBegin()
13453 
    while True:
13454 
      (fname, ftype, fid) = iprot.readFieldBegin()
13455 
      if ftype == TType.STOP:
13456 
        break
13457 
      if fid == 0:
13458 
        if ftype == TType.STRUCT:
13459 
          self.success = Item()
13460 
          self.success.read(iprot)
13461 
        else:
13462 
          iprot.skip(ftype)
13463 
      elif fid == 1:
13464 
        if ftype == TType.STRUCT:
13465 
          self.cex = CatalogServiceException()
13466 
          self.cex.read(iprot)
13467 
        else:
13468 
          iprot.skip(ftype)
13469 
      else:
13470 
        iprot.skip(ftype)
13471 
      iprot.readFieldEnd()
13472 
    iprot.readStructEnd()
13473 
 
13474 
  def write(self, oprot):
13475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13477 
      return
13478 
    oprot.writeStructBegin('getItemForSource_result')
13479 
    if self.success is not None:
13480 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13481 
      self.success.write(oprot)
13482 
      oprot.writeFieldEnd()
13483 
    if self.cex is not None:
13484 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13485 
      self.cex.write(oprot)
13486 
      oprot.writeFieldEnd()
13487 
    oprot.writeFieldStop()
13488 
    oprot.writeStructEnd()
13489 
 
13490 
  def validate(self):
13491 
    return
13492 
 
13493 
 
13494 
  def __repr__(self):
13495 
    L = ['%s=%r' % (key, value)
13496 
      for key, value in self.__dict__.iteritems()]
13497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13498 
 
13499 
  def __eq__(self, other):
13500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13501 
 
13502 
  def __ne__(self, other):
13503 
    return not (self == other)
13504 
 
13505 
class searchItemsInRange_args:
13506 
  """
13507 
  Attributes:
13508 
   - searchTerms
13509 
   - offset
13510 
   - limit
13511 
  """
13512 
 
13513 
  thrift_spec = (
13514 
    None, # 0
13515 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13516 
    (2, TType.I64, 'offset', None, None, ), # 2
13517 
    (3, TType.I64, 'limit', None, None, ), # 3
13518 
  )
13519 
 
13520 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13521 
    self.searchTerms = searchTerms
13522 
    self.offset = offset
13523 
    self.limit = limit
13524 
 
13525 
  def read(self, iprot):
13526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13528 
      return
13529 
    iprot.readStructBegin()
13530 
    while True:
13531 
      (fname, ftype, fid) = iprot.readFieldBegin()
13532 
      if ftype == TType.STOP:
13533 
        break
13534 
      if fid == 1:
13535 
        if ftype == TType.LIST:
13536 
          self.searchTerms = []
6850 kshitij.so 13537 
          (_etype238, _size235) = iprot.readListBegin()
13538 
          for _i239 in xrange(_size235):
13539 
            _elem240 = iprot.readString();
13540 
            self.searchTerms.append(_elem240)
5944 mandeep.dh 13541 
          iprot.readListEnd()
13542 
        else:
13543 
          iprot.skip(ftype)
13544 
      elif fid == 2:
13545 
        if ftype == TType.I64:
13546 
          self.offset = iprot.readI64();
13547 
        else:
13548 
          iprot.skip(ftype)
13549 
      elif fid == 3:
13550 
        if ftype == TType.I64:
13551 
          self.limit = iprot.readI64();
13552 
        else:
13553 
          iprot.skip(ftype)
13554 
      else:
13555 
        iprot.skip(ftype)
13556 
      iprot.readFieldEnd()
13557 
    iprot.readStructEnd()
13558 
 
13559 
  def write(self, oprot):
13560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13562 
      return
13563 
    oprot.writeStructBegin('searchItemsInRange_args')
13564 
    if self.searchTerms is not None:
13565 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13566 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13567 
      for iter241 in self.searchTerms:
13568 
        oprot.writeString(iter241)
5944 mandeep.dh 13569 
      oprot.writeListEnd()
13570 
      oprot.writeFieldEnd()
13571 
    if self.offset is not None:
13572 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13573 
      oprot.writeI64(self.offset)
13574 
      oprot.writeFieldEnd()
13575 
    if self.limit is not None:
13576 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13577 
      oprot.writeI64(self.limit)
13578 
      oprot.writeFieldEnd()
13579 
    oprot.writeFieldStop()
13580 
    oprot.writeStructEnd()
13581 
 
13582 
  def validate(self):
13583 
    return
13584 
 
13585 
 
13586 
  def __repr__(self):
13587 
    L = ['%s=%r' % (key, value)
13588 
      for key, value in self.__dict__.iteritems()]
13589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13590 
 
13591 
  def __eq__(self, other):
13592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13593 
 
13594 
  def __ne__(self, other):
13595 
    return not (self == other)
13596 
 
13597 
class searchItemsInRange_result:
13598 
  """
13599 
  Attributes:
13600 
   - success
13601 
  """
13602 
 
13603 
  thrift_spec = (
13604 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13605 
  )
13606 
 
13607 
  def __init__(self, success=None,):
13608 
    self.success = success
13609 
 
13610 
  def read(self, iprot):
13611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13613 
      return
13614 
    iprot.readStructBegin()
13615 
    while True:
13616 
      (fname, ftype, fid) = iprot.readFieldBegin()
13617 
      if ftype == TType.STOP:
13618 
        break
13619 
      if fid == 0:
13620 
        if ftype == TType.LIST:
13621 
          self.success = []
6850 kshitij.so 13622 
          (_etype245, _size242) = iprot.readListBegin()
13623 
          for _i246 in xrange(_size242):
13624 
            _elem247 = Item()
13625 
            _elem247.read(iprot)
13626 
            self.success.append(_elem247)
5944 mandeep.dh 13627 
          iprot.readListEnd()
13628 
        else:
13629 
          iprot.skip(ftype)
13630 
      else:
13631 
        iprot.skip(ftype)
13632 
      iprot.readFieldEnd()
13633 
    iprot.readStructEnd()
13634 
 
13635 
  def write(self, oprot):
13636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13638 
      return
13639 
    oprot.writeStructBegin('searchItemsInRange_result')
13640 
    if self.success is not None:
13641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13643 
      for iter248 in self.success:
13644 
        iter248.write(oprot)
5944 mandeep.dh 13645 
      oprot.writeListEnd()
13646 
      oprot.writeFieldEnd()
13647 
    oprot.writeFieldStop()
13648 
    oprot.writeStructEnd()
13649 
 
13650 
  def validate(self):
13651 
    return
13652 
 
13653 
 
13654 
  def __repr__(self):
13655 
    L = ['%s=%r' % (key, value)
13656 
      for key, value in self.__dict__.iteritems()]
13657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13658 
 
13659 
  def __eq__(self, other):
13660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13661 
 
13662 
  def __ne__(self, other):
13663 
    return not (self == other)
13664 
 
13665 
class getSearchResultCount_args:
13666 
  """
13667 
  Attributes:
13668 
   - searchTerms
13669 
  """
13670 
 
13671 
  thrift_spec = (
13672 
    None, # 0
13673 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13674 
  )
13675 
 
13676 
  def __init__(self, searchTerms=None,):
13677 
    self.searchTerms = searchTerms
13678 
 
13679 
  def read(self, iprot):
13680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13682 
      return
13683 
    iprot.readStructBegin()
13684 
    while True:
13685 
      (fname, ftype, fid) = iprot.readFieldBegin()
13686 
      if ftype == TType.STOP:
13687 
        break
13688 
      if fid == 1:
13689 
        if ftype == TType.LIST:
13690 
          self.searchTerms = []
6850 kshitij.so 13691 
          (_etype252, _size249) = iprot.readListBegin()
13692 
          for _i253 in xrange(_size249):
13693 
            _elem254 = iprot.readString();
13694 
            self.searchTerms.append(_elem254)
5944 mandeep.dh 13695 
          iprot.readListEnd()
13696 
        else:
13697 
          iprot.skip(ftype)
13698 
      else:
13699 
        iprot.skip(ftype)
13700 
      iprot.readFieldEnd()
13701 
    iprot.readStructEnd()
13702 
 
13703 
  def write(self, oprot):
13704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13706 
      return
13707 
    oprot.writeStructBegin('getSearchResultCount_args')
13708 
    if self.searchTerms is not None:
13709 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13710 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
6850 kshitij.so 13711 
      for iter255 in self.searchTerms:
13712 
        oprot.writeString(iter255)
5944 mandeep.dh 13713 
      oprot.writeListEnd()
13714 
      oprot.writeFieldEnd()
13715 
    oprot.writeFieldStop()
13716 
    oprot.writeStructEnd()
13717 
 
13718 
  def validate(self):
13719 
    return
13720 
 
13721 
 
13722 
  def __repr__(self):
13723 
    L = ['%s=%r' % (key, value)
13724 
      for key, value in self.__dict__.iteritems()]
13725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13726 
 
13727 
  def __eq__(self, other):
13728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13729 
 
13730 
  def __ne__(self, other):
13731 
    return not (self == other)
13732 
 
13733 
class getSearchResultCount_result:
13734 
  """
13735 
  Attributes:
13736 
   - success
13737 
  """
13738 
 
13739 
  thrift_spec = (
13740 
    (0, TType.I32, 'success', None, None, ), # 0
13741 
  )
13742 
 
13743 
  def __init__(self, success=None,):
13744 
    self.success = success
13745 
 
13746 
  def read(self, iprot):
13747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13749 
      return
13750 
    iprot.readStructBegin()
13751 
    while True:
13752 
      (fname, ftype, fid) = iprot.readFieldBegin()
13753 
      if ftype == TType.STOP:
13754 
        break
13755 
      if fid == 0:
13756 
        if ftype == TType.I32:
13757 
          self.success = iprot.readI32();
13758 
        else:
13759 
          iprot.skip(ftype)
13760 
      else:
13761 
        iprot.skip(ftype)
13762 
      iprot.readFieldEnd()
13763 
    iprot.readStructEnd()
13764 
 
13765 
  def write(self, oprot):
13766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13768 
      return
13769 
    oprot.writeStructBegin('getSearchResultCount_result')
13770 
    if self.success is not None:
13771 
      oprot.writeFieldBegin('success', TType.I32, 0)
13772 
      oprot.writeI32(self.success)
13773 
      oprot.writeFieldEnd()
13774 
    oprot.writeFieldStop()
13775 
    oprot.writeStructEnd()
13776 
 
13777 
  def validate(self):
13778 
    return
13779 
 
13780 
 
13781 
  def __repr__(self):
13782 
    L = ['%s=%r' % (key, value)
13783 
      for key, value in self.__dict__.iteritems()]
13784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13785 
 
13786 
  def __eq__(self, other):
13787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13788 
 
13789 
  def __ne__(self, other):
13790 
    return not (self == other)
13791 
 
13792 
class getProductNotifications_args:
13793 
  """
13794 
  Attributes:
13795 
   - startDateTime
13796 
  """
13797 
 
13798 
  thrift_spec = (
13799 
    None, # 0
13800 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13801 
  )
13802 
 
13803 
  def __init__(self, startDateTime=None,):
13804 
    self.startDateTime = startDateTime
13805 
 
13806 
  def read(self, iprot):
13807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13809 
      return
13810 
    iprot.readStructBegin()
13811 
    while True:
13812 
      (fname, ftype, fid) = iprot.readFieldBegin()
13813 
      if ftype == TType.STOP:
13814 
        break
13815 
      if fid == 1:
13816 
        if ftype == TType.I64:
13817 
          self.startDateTime = iprot.readI64();
13818 
        else:
13819 
          iprot.skip(ftype)
13820 
      else:
13821 
        iprot.skip(ftype)
13822 
      iprot.readFieldEnd()
13823 
    iprot.readStructEnd()
13824 
 
13825 
  def write(self, oprot):
13826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13828 
      return
13829 
    oprot.writeStructBegin('getProductNotifications_args')
13830 
    if self.startDateTime is not None:
13831 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13832 
      oprot.writeI64(self.startDateTime)
13833 
      oprot.writeFieldEnd()
13834 
    oprot.writeFieldStop()
13835 
    oprot.writeStructEnd()
13836 
 
13837 
  def validate(self):
13838 
    return
13839 
 
13840 
 
13841 
  def __repr__(self):
13842 
    L = ['%s=%r' % (key, value)
13843 
      for key, value in self.__dict__.iteritems()]
13844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13845 
 
13846 
  def __eq__(self, other):
13847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13848 
 
13849 
  def __ne__(self, other):
13850 
    return not (self == other)
13851 
 
13852 
class getProductNotifications_result:
13853 
  """
13854 
  Attributes:
13855 
   - success
13856 
  """
13857 
 
13858 
  thrift_spec = (
13859 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
13860 
  )
13861 
 
13862 
  def __init__(self, success=None,):
13863 
    self.success = success
13864 
 
13865 
  def read(self, iprot):
13866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13868 
      return
13869 
    iprot.readStructBegin()
13870 
    while True:
13871 
      (fname, ftype, fid) = iprot.readFieldBegin()
13872 
      if ftype == TType.STOP:
13873 
        break
13874 
      if fid == 0:
13875 
        if ftype == TType.LIST:
13876 
          self.success = []
6850 kshitij.so 13877 
          (_etype259, _size256) = iprot.readListBegin()
13878 
          for _i260 in xrange(_size256):
13879 
            _elem261 = ProductNotificationRequest()
13880 
            _elem261.read(iprot)
13881 
            self.success.append(_elem261)
5944 mandeep.dh 13882 
          iprot.readListEnd()
13883 
        else:
13884 
          iprot.skip(ftype)
13885 
      else:
13886 
        iprot.skip(ftype)
13887 
      iprot.readFieldEnd()
13888 
    iprot.readStructEnd()
13889 
 
13890 
  def write(self, oprot):
13891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13893 
      return
13894 
    oprot.writeStructBegin('getProductNotifications_result')
13895 
    if self.success is not None:
13896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 13898 
      for iter262 in self.success:
13899 
        iter262.write(oprot)
5944 mandeep.dh 13900 
      oprot.writeListEnd()
13901 
      oprot.writeFieldEnd()
13902 
    oprot.writeFieldStop()
13903 
    oprot.writeStructEnd()
13904 
 
13905 
  def validate(self):
13906 
    return
13907 
 
13908 
 
13909 
  def __repr__(self):
13910 
    L = ['%s=%r' % (key, value)
13911 
      for key, value in self.__dict__.iteritems()]
13912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13913 
 
13914 
  def __eq__(self, other):
13915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13916 
 
13917 
  def __ne__(self, other):
13918 
    return not (self == other)
13919 
 
13920 
class getProductNotificationRequestCount_args:
13921 
  """
13922 
  Attributes:
13923 
   - startDateTime
13924 
  """
13925 
 
13926 
  thrift_spec = (
13927 
    None, # 0
13928 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
13929 
  )
13930 
 
13931 
  def __init__(self, startDateTime=None,):
13932 
    self.startDateTime = startDateTime
13933 
 
13934 
  def read(self, iprot):
13935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13937 
      return
13938 
    iprot.readStructBegin()
13939 
    while True:
13940 
      (fname, ftype, fid) = iprot.readFieldBegin()
13941 
      if ftype == TType.STOP:
13942 
        break
13943 
      if fid == 1:
13944 
        if ftype == TType.I64:
13945 
          self.startDateTime = iprot.readI64();
13946 
        else:
13947 
          iprot.skip(ftype)
13948 
      else:
13949 
        iprot.skip(ftype)
13950 
      iprot.readFieldEnd()
13951 
    iprot.readStructEnd()
13952 
 
13953 
  def write(self, oprot):
13954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13956 
      return
13957 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
13958 
    if self.startDateTime is not None:
13959 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
13960 
      oprot.writeI64(self.startDateTime)
13961 
      oprot.writeFieldEnd()
13962 
    oprot.writeFieldStop()
13963 
    oprot.writeStructEnd()
13964 
 
13965 
  def validate(self):
13966 
    return
13967 
 
13968 
 
13969 
  def __repr__(self):
13970 
    L = ['%s=%r' % (key, value)
13971 
      for key, value in self.__dict__.iteritems()]
13972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13973 
 
13974 
  def __eq__(self, other):
13975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13976 
 
13977 
  def __ne__(self, other):
13978 
    return not (self == other)
13979 
 
13980 
class getProductNotificationRequestCount_result:
13981 
  """
13982 
  Attributes:
13983 
   - success
13984 
  """
13985 
 
13986 
  thrift_spec = (
13987 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
13988 
  )
13989 
 
13990 
  def __init__(self, success=None,):
13991 
    self.success = success
13992 
 
13993 
  def read(self, iprot):
13994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13996 
      return
13997 
    iprot.readStructBegin()
13998 
    while True:
13999 
      (fname, ftype, fid) = iprot.readFieldBegin()
14000 
      if ftype == TType.STOP:
14001 
        break
14002 
      if fid == 0:
14003 
        if ftype == TType.LIST:
14004 
          self.success = []
6850 kshitij.so 14005 
          (_etype266, _size263) = iprot.readListBegin()
14006 
          for _i267 in xrange(_size263):
14007 
            _elem268 = ProductNotificationRequestCount()
14008 
            _elem268.read(iprot)
14009 
            self.success.append(_elem268)
5944 mandeep.dh 14010 
          iprot.readListEnd()
14011 
        else:
14012 
          iprot.skip(ftype)
14013 
      else:
14014 
        iprot.skip(ftype)
14015 
      iprot.readFieldEnd()
14016 
    iprot.readStructEnd()
14017 
 
14018 
  def write(self, oprot):
14019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14021 
      return
14022 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14023 
    if self.success is not None:
14024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14025 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6850 kshitij.so 14026 
      for iter269 in self.success:
14027 
        iter269.write(oprot)
5944 mandeep.dh 14028 
      oprot.writeListEnd()
14029 
      oprot.writeFieldEnd()
14030 
    oprot.writeFieldStop()
14031 
    oprot.writeStructEnd()
14032 
 
14033 
  def validate(self):
14034 
    return
14035 
 
14036 
 
14037 
  def __repr__(self):
14038 
    L = ['%s=%r' % (key, value)
14039 
      for key, value in self.__dict__.iteritems()]
14040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14041 
 
14042 
  def __eq__(self, other):
14043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14044 
 
14045 
  def __ne__(self, other):
14046 
    return not (self == other)
14047 
 
14048 
class addAuthorizationLog_args:
14049 
  """
14050 
  Attributes:
14051 
   - itemId
14052 
   - username
14053 
   - reason
14054 
  """
14055 
 
14056 
  thrift_spec = (
14057 
    None, # 0
14058 
    (1, TType.I64, 'itemId', None, None, ), # 1
14059 
    (2, TType.STRING, 'username', None, None, ), # 2
14060 
    (3, TType.STRING, 'reason', None, None, ), # 3
14061 
  )
14062 
 
14063 
  def __init__(self, itemId=None, username=None, reason=None,):
14064 
    self.itemId = itemId
14065 
    self.username = username
14066 
    self.reason = reason
14067 
 
14068 
  def read(self, iprot):
14069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14071 
      return
14072 
    iprot.readStructBegin()
14073 
    while True:
14074 
      (fname, ftype, fid) = iprot.readFieldBegin()
14075 
      if ftype == TType.STOP:
14076 
        break
14077 
      if fid == 1:
14078 
        if ftype == TType.I64:
14079 
          self.itemId = iprot.readI64();
14080 
        else:
14081 
          iprot.skip(ftype)
14082 
      elif fid == 2:
14083 
        if ftype == TType.STRING:
14084 
          self.username = iprot.readString();
14085 
        else:
14086 
          iprot.skip(ftype)
14087 
      elif fid == 3:
14088 
        if ftype == TType.STRING:
14089 
          self.reason = iprot.readString();
14090 
        else:
14091 
          iprot.skip(ftype)
14092 
      else:
14093 
        iprot.skip(ftype)
14094 
      iprot.readFieldEnd()
14095 
    iprot.readStructEnd()
14096 
 
14097 
  def write(self, oprot):
14098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14100 
      return
14101 
    oprot.writeStructBegin('addAuthorizationLog_args')
14102 
    if self.itemId is not None:
14103 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14104 
      oprot.writeI64(self.itemId)
14105 
      oprot.writeFieldEnd()
14106 
    if self.username is not None:
14107 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14108 
      oprot.writeString(self.username)
14109 
      oprot.writeFieldEnd()
14110 
    if self.reason is not None:
14111 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14112 
      oprot.writeString(self.reason)
14113 
      oprot.writeFieldEnd()
14114 
    oprot.writeFieldStop()
14115 
    oprot.writeStructEnd()
14116 
 
14117 
  def validate(self):
14118 
    return
14119 
 
14120 
 
14121 
  def __repr__(self):
14122 
    L = ['%s=%r' % (key, value)
14123 
      for key, value in self.__dict__.iteritems()]
14124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14125 
 
14126 
  def __eq__(self, other):
14127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14128 
 
14129 
  def __ne__(self, other):
14130 
    return not (self == other)
14131 
 
14132 
class addAuthorizationLog_result:
14133 
  """
14134 
  Attributes:
14135 
   - success
14136 
   - cex
14137 
  """
14138 
 
14139 
  thrift_spec = (
14140 
    (0, TType.BOOL, 'success', None, None, ), # 0
14141 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14142 
  )
14143 
 
14144 
  def __init__(self, success=None, cex=None,):
14145 
    self.success = success
14146 
    self.cex = cex
14147 
 
14148 
  def read(self, iprot):
14149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14151 
      return
14152 
    iprot.readStructBegin()
14153 
    while True:
14154 
      (fname, ftype, fid) = iprot.readFieldBegin()
14155 
      if ftype == TType.STOP:
14156 
        break
14157 
      if fid == 0:
14158 
        if ftype == TType.BOOL:
14159 
          self.success = iprot.readBool();
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      elif fid == 1:
14163 
        if ftype == TType.STRUCT:
14164 
          self.cex = CatalogServiceException()
14165 
          self.cex.read(iprot)
14166 
        else:
14167 
          iprot.skip(ftype)
14168 
      else:
14169 
        iprot.skip(ftype)
14170 
      iprot.readFieldEnd()
14171 
    iprot.readStructEnd()
14172 
 
14173 
  def write(self, oprot):
14174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14176 
      return
14177 
    oprot.writeStructBegin('addAuthorizationLog_result')
14178 
    if self.success is not None:
14179 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14180 
      oprot.writeBool(self.success)
14181 
      oprot.writeFieldEnd()
14182 
    if self.cex is not None:
14183 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14184 
      self.cex.write(oprot)
14185 
      oprot.writeFieldEnd()
14186 
    oprot.writeFieldStop()
14187 
    oprot.writeStructEnd()
14188 
 
14189 
  def validate(self):
14190 
    return
14191 
 
14192 
 
14193 
  def __repr__(self):
14194 
    L = ['%s=%r' % (key, value)
14195 
      for key, value in self.__dict__.iteritems()]
14196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14197 
 
14198 
  def __eq__(self, other):
14199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14200 
 
14201 
  def __ne__(self, other):
14202 
    return not (self == other)
14203 
 
14204 
class addupdateVoucherForItem_args:
14205 
  """
14206 
  Attributes:
14207 
   - catalog_item_id
14208 
   - voucherType
14209 
   - voucherAmount
14210 
  """
14211 
 
14212 
  thrift_spec = (
14213 
    None, # 0
14214 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14215 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14216 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14217 
  )
14218 
 
14219 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14220 
    self.catalog_item_id = catalog_item_id
14221 
    self.voucherType = voucherType
14222 
    self.voucherAmount = voucherAmount
14223 
 
14224 
  def read(self, iprot):
14225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14227 
      return
14228 
    iprot.readStructBegin()
14229 
    while True:
14230 
      (fname, ftype, fid) = iprot.readFieldBegin()
14231 
      if ftype == TType.STOP:
14232 
        break
14233 
      if fid == 1:
14234 
        if ftype == TType.I64:
14235 
          self.catalog_item_id = iprot.readI64();
14236 
        else:
14237 
          iprot.skip(ftype)
14238 
      elif fid == 2:
14239 
        if ftype == TType.I64:
14240 
          self.voucherType = iprot.readI64();
14241 
        else:
14242 
          iprot.skip(ftype)
14243 
      elif fid == 3:
14244 
        if ftype == TType.I64:
14245 
          self.voucherAmount = iprot.readI64();
14246 
        else:
14247 
          iprot.skip(ftype)
14248 
      else:
14249 
        iprot.skip(ftype)
14250 
      iprot.readFieldEnd()
14251 
    iprot.readStructEnd()
14252 
 
14253 
  def write(self, oprot):
14254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14256 
      return
14257 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14258 
    if self.catalog_item_id is not None:
14259 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14260 
      oprot.writeI64(self.catalog_item_id)
14261 
      oprot.writeFieldEnd()
14262 
    if self.voucherType is not None:
14263 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14264 
      oprot.writeI64(self.voucherType)
14265 
      oprot.writeFieldEnd()
14266 
    if self.voucherAmount is not None:
14267 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14268 
      oprot.writeI64(self.voucherAmount)
14269 
      oprot.writeFieldEnd()
14270 
    oprot.writeFieldStop()
14271 
    oprot.writeStructEnd()
14272 
 
14273 
  def validate(self):
14274 
    return
14275 
 
14276 
 
14277 
  def __repr__(self):
14278 
    L = ['%s=%r' % (key, value)
14279 
      for key, value in self.__dict__.iteritems()]
14280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14281 
 
14282 
  def __eq__(self, other):
14283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14284 
 
14285 
  def __ne__(self, other):
14286 
    return not (self == other)
14287 
 
14288 
class addupdateVoucherForItem_result:
14289 
  """
14290 
  Attributes:
14291 
   - success
14292 
   - cex
14293 
  """
14294 
 
14295 
  thrift_spec = (
14296 
    (0, TType.BOOL, 'success', None, None, ), # 0
14297 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14298 
  )
14299 
 
14300 
  def __init__(self, success=None, cex=None,):
14301 
    self.success = success
14302 
    self.cex = cex
14303 
 
14304 
  def read(self, iprot):
14305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14307 
      return
14308 
    iprot.readStructBegin()
14309 
    while True:
14310 
      (fname, ftype, fid) = iprot.readFieldBegin()
14311 
      if ftype == TType.STOP:
14312 
        break
14313 
      if fid == 0:
14314 
        if ftype == TType.BOOL:
14315 
          self.success = iprot.readBool();
14316 
        else:
14317 
          iprot.skip(ftype)
14318 
      elif fid == 1:
14319 
        if ftype == TType.STRUCT:
14320 
          self.cex = CatalogServiceException()
14321 
          self.cex.read(iprot)
14322 
        else:
14323 
          iprot.skip(ftype)
14324 
      else:
14325 
        iprot.skip(ftype)
14326 
      iprot.readFieldEnd()
14327 
    iprot.readStructEnd()
14328 
 
14329 
  def write(self, oprot):
14330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14332 
      return
14333 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14334 
    if self.success is not None:
14335 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14336 
      oprot.writeBool(self.success)
14337 
      oprot.writeFieldEnd()
14338 
    if self.cex is not None:
14339 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14340 
      self.cex.write(oprot)
14341 
      oprot.writeFieldEnd()
14342 
    oprot.writeFieldStop()
14343 
    oprot.writeStructEnd()
14344 
 
14345 
  def validate(self):
14346 
    return
14347 
 
14348 
 
14349 
  def __repr__(self):
14350 
    L = ['%s=%r' % (key, value)
14351 
      for key, value in self.__dict__.iteritems()]
14352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14353 
 
14354 
  def __eq__(self, other):
14355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14356 
 
14357 
  def __ne__(self, other):
14358 
    return not (self == other)
14359 
 
14360 
class deleteVoucherForItem_args:
14361 
  """
14362 
  Attributes:
14363 
   - catalog_item_id
14364 
   - voucherType
14365 
  """
14366 
 
14367 
  thrift_spec = (
14368 
    None, # 0
14369 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14370 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14371 
  )
14372 
 
14373 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14374 
    self.catalog_item_id = catalog_item_id
14375 
    self.voucherType = voucherType
14376 
 
14377 
  def read(self, iprot):
14378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14380 
      return
14381 
    iprot.readStructBegin()
14382 
    while True:
14383 
      (fname, ftype, fid) = iprot.readFieldBegin()
14384 
      if ftype == TType.STOP:
14385 
        break
14386 
      if fid == 1:
14387 
        if ftype == TType.I64:
14388 
          self.catalog_item_id = iprot.readI64();
14389 
        else:
14390 
          iprot.skip(ftype)
14391 
      elif fid == 2:
14392 
        if ftype == TType.I64:
14393 
          self.voucherType = iprot.readI64();
14394 
        else:
14395 
          iprot.skip(ftype)
14396 
      else:
14397 
        iprot.skip(ftype)
14398 
      iprot.readFieldEnd()
14399 
    iprot.readStructEnd()
14400 
 
14401 
  def write(self, oprot):
14402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14404 
      return
14405 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14406 
    if self.catalog_item_id is not None:
14407 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14408 
      oprot.writeI64(self.catalog_item_id)
14409 
      oprot.writeFieldEnd()
14410 
    if self.voucherType is not None:
14411 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14412 
      oprot.writeI64(self.voucherType)
14413 
      oprot.writeFieldEnd()
14414 
    oprot.writeFieldStop()
14415 
    oprot.writeStructEnd()
14416 
 
14417 
  def validate(self):
14418 
    return
14419 
 
14420 
 
14421 
  def __repr__(self):
14422 
    L = ['%s=%r' % (key, value)
14423 
      for key, value in self.__dict__.iteritems()]
14424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14425 
 
14426 
  def __eq__(self, other):
14427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14428 
 
14429 
  def __ne__(self, other):
14430 
    return not (self == other)
14431 
 
14432 
class deleteVoucherForItem_result:
14433 
  """
14434 
  Attributes:
14435 
   - success
14436 
   - cex
14437 
  """
14438 
 
14439 
  thrift_spec = (
14440 
    (0, TType.BOOL, 'success', None, None, ), # 0
14441 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14442 
  )
14443 
 
14444 
  def __init__(self, success=None, cex=None,):
14445 
    self.success = success
14446 
    self.cex = cex
14447 
 
14448 
  def read(self, iprot):
14449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14451 
      return
14452 
    iprot.readStructBegin()
14453 
    while True:
14454 
      (fname, ftype, fid) = iprot.readFieldBegin()
14455 
      if ftype == TType.STOP:
14456 
        break
14457 
      if fid == 0:
14458 
        if ftype == TType.BOOL:
14459 
          self.success = iprot.readBool();
14460 
        else:
14461 
          iprot.skip(ftype)
14462 
      elif fid == 1:
14463 
        if ftype == TType.STRUCT:
14464 
          self.cex = CatalogServiceException()
14465 
          self.cex.read(iprot)
14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      else:
14469 
        iprot.skip(ftype)
14470 
      iprot.readFieldEnd()
14471 
    iprot.readStructEnd()
14472 
 
14473 
  def write(self, oprot):
14474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14476 
      return
14477 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14478 
    if self.success is not None:
14479 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14480 
      oprot.writeBool(self.success)
14481 
      oprot.writeFieldEnd()
14482 
    if self.cex is not None:
14483 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14484 
      self.cex.write(oprot)
14485 
      oprot.writeFieldEnd()
14486 
    oprot.writeFieldStop()
14487 
    oprot.writeStructEnd()
14488 
 
14489 
  def validate(self):
14490 
    return
14491 
 
14492 
 
14493 
  def __repr__(self):
14494 
    L = ['%s=%r' % (key, value)
14495 
      for key, value in self.__dict__.iteritems()]
14496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14497 
 
14498 
  def __eq__(self, other):
14499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14500 
 
14501 
  def __ne__(self, other):
14502 
    return not (self == other)
14503 
 
14504 
class getVoucherAmount_args:
14505 
  """
14506 
  Attributes:
14507 
   - itemId
14508 
   - voucherType
14509 
  """
14510 
 
14511 
  thrift_spec = (
14512 
    None, # 0
14513 
    (1, TType.I64, 'itemId', None, None, ), # 1
14514 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14515 
  )
14516 
 
14517 
  def __init__(self, itemId=None, voucherType=None,):
14518 
    self.itemId = itemId
14519 
    self.voucherType = voucherType
14520 
 
14521 
  def read(self, iprot):
14522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14524 
      return
14525 
    iprot.readStructBegin()
14526 
    while True:
14527 
      (fname, ftype, fid) = iprot.readFieldBegin()
14528 
      if ftype == TType.STOP:
14529 
        break
14530 
      if fid == 1:
14531 
        if ftype == TType.I64:
14532 
          self.itemId = iprot.readI64();
14533 
        else:
14534 
          iprot.skip(ftype)
14535 
      elif fid == 2:
14536 
        if ftype == TType.I64:
14537 
          self.voucherType = iprot.readI64();
14538 
        else:
14539 
          iprot.skip(ftype)
14540 
      else:
14541 
        iprot.skip(ftype)
14542 
      iprot.readFieldEnd()
14543 
    iprot.readStructEnd()
14544 
 
14545 
  def write(self, oprot):
14546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14548 
      return
14549 
    oprot.writeStructBegin('getVoucherAmount_args')
14550 
    if self.itemId is not None:
14551 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14552 
      oprot.writeI64(self.itemId)
14553 
      oprot.writeFieldEnd()
14554 
    if self.voucherType is not None:
14555 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14556 
      oprot.writeI64(self.voucherType)
14557 
      oprot.writeFieldEnd()
14558 
    oprot.writeFieldStop()
14559 
    oprot.writeStructEnd()
14560 
 
14561 
  def validate(self):
14562 
    return
14563 
 
14564 
 
14565 
  def __repr__(self):
14566 
    L = ['%s=%r' % (key, value)
14567 
      for key, value in self.__dict__.iteritems()]
14568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14569 
 
14570 
  def __eq__(self, other):
14571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14572 
 
14573 
  def __ne__(self, other):
14574 
    return not (self == other)
14575 
 
14576 
class getVoucherAmount_result:
14577 
  """
14578 
  Attributes:
14579 
   - success
14580 
  """
14581 
 
14582 
  thrift_spec = (
14583 
    (0, TType.I64, 'success', None, None, ), # 0
14584 
  )
14585 
 
14586 
  def __init__(self, success=None,):
14587 
    self.success = success
14588 
 
14589 
  def read(self, iprot):
14590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14592 
      return
14593 
    iprot.readStructBegin()
14594 
    while True:
14595 
      (fname, ftype, fid) = iprot.readFieldBegin()
14596 
      if ftype == TType.STOP:
14597 
        break
14598 
      if fid == 0:
14599 
        if ftype == TType.I64:
14600 
          self.success = iprot.readI64();
14601 
        else:
14602 
          iprot.skip(ftype)
14603 
      else:
14604 
        iprot.skip(ftype)
14605 
      iprot.readFieldEnd()
14606 
    iprot.readStructEnd()
14607 
 
14608 
  def write(self, oprot):
14609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14611 
      return
14612 
    oprot.writeStructBegin('getVoucherAmount_result')
14613 
    if self.success is not None:
14614 
      oprot.writeFieldBegin('success', TType.I64, 0)
14615 
      oprot.writeI64(self.success)
14616 
      oprot.writeFieldEnd()
14617 
    oprot.writeFieldStop()
14618 
    oprot.writeStructEnd()
14619 
 
14620 
  def validate(self):
14621 
    return
14622 
 
14623 
 
14624 
  def __repr__(self):
14625 
    L = ['%s=%r' % (key, value)
14626 
      for key, value in self.__dict__.iteritems()]
14627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14628 
 
14629 
  def __eq__(self, other):
14630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14631 
 
14632 
  def __ne__(self, other):
14633 
    return not (self == other)
14634 
 
14635 
class getAllItemVouchers_args:
14636 
  """
14637 
  Attributes:
14638 
   - itemId
14639 
  """
14640 
 
14641 
  thrift_spec = (
14642 
    None, # 0
14643 
    (1, TType.I64, 'itemId', None, None, ), # 1
14644 
  )
14645 
 
14646 
  def __init__(self, itemId=None,):
14647 
    self.itemId = itemId
14648 
 
14649 
  def read(self, iprot):
14650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14652 
      return
14653 
    iprot.readStructBegin()
14654 
    while True:
14655 
      (fname, ftype, fid) = iprot.readFieldBegin()
14656 
      if ftype == TType.STOP:
14657 
        break
14658 
      if fid == 1:
14659 
        if ftype == TType.I64:
14660 
          self.itemId = iprot.readI64();
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      else:
14664 
        iprot.skip(ftype)
14665 
      iprot.readFieldEnd()
14666 
    iprot.readStructEnd()
14667 
 
14668 
  def write(self, oprot):
14669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14671 
      return
14672 
    oprot.writeStructBegin('getAllItemVouchers_args')
14673 
    if self.itemId is not None:
14674 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14675 
      oprot.writeI64(self.itemId)
14676 
      oprot.writeFieldEnd()
14677 
    oprot.writeFieldStop()
14678 
    oprot.writeStructEnd()
14679 
 
14680 
  def validate(self):
14681 
    return
14682 
 
14683 
 
14684 
  def __repr__(self):
14685 
    L = ['%s=%r' % (key, value)
14686 
      for key, value in self.__dict__.iteritems()]
14687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14688 
 
14689 
  def __eq__(self, other):
14690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14691 
 
14692 
  def __ne__(self, other):
14693 
    return not (self == other)
14694 
 
14695 
class getAllItemVouchers_result:
14696 
  """
14697 
  Attributes:
14698 
   - success
14699 
  """
14700 
 
14701 
  thrift_spec = (
14702 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14703 
  )
14704 
 
14705 
  def __init__(self, success=None,):
14706 
    self.success = success
14707 
 
14708 
  def read(self, iprot):
14709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14711 
      return
14712 
    iprot.readStructBegin()
14713 
    while True:
14714 
      (fname, ftype, fid) = iprot.readFieldBegin()
14715 
      if ftype == TType.STOP:
14716 
        break
14717 
      if fid == 0:
14718 
        if ftype == TType.LIST:
14719 
          self.success = []
7256 rajveer 14720 
          (_etype273, _size270) = iprot.readListBegin()
14721 
          for _i274 in xrange(_size270):
14722 
            _elem275 = VoucherItemMapping()
14723 
            _elem275.read(iprot)
14724 
            self.success.append(_elem275)
5944 mandeep.dh 14725 
          iprot.readListEnd()
14726 
        else:
14727 
          iprot.skip(ftype)
14728 
      else:
14729 
        iprot.skip(ftype)
14730 
      iprot.readFieldEnd()
14731 
    iprot.readStructEnd()
14732 
 
14733 
  def write(self, oprot):
14734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14736 
      return
14737 
    oprot.writeStructBegin('getAllItemVouchers_result')
14738 
    if self.success is not None:
14739 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14740 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 14741 
      for iter276 in self.success:
14742 
        iter276.write(oprot)
5944 mandeep.dh 14743 
      oprot.writeListEnd()
14744 
      oprot.writeFieldEnd()
14745 
    oprot.writeFieldStop()
14746 
    oprot.writeStructEnd()
14747 
 
14748 
  def validate(self):
14749 
    return
14750 
 
14751 
 
14752 
  def __repr__(self):
14753 
    L = ['%s=%r' % (key, value)
14754 
      for key, value in self.__dict__.iteritems()]
14755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14756 
 
14757 
  def __eq__(self, other):
14758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14759 
 
14760 
  def __ne__(self, other):
14761 
    return not (self == other)
14762 
 
14763 
class isValidCatalogItemId_args:
14764 
  """
14765 
  Attributes:
14766 
   - catalog_item_id
14767 
  """
14768 
 
14769 
  thrift_spec = (
14770 
    None, # 0
14771 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14772 
  )
14773 
 
14774 
  def __init__(self, catalog_item_id=None,):
14775 
    self.catalog_item_id = catalog_item_id
14776 
 
14777 
  def read(self, iprot):
14778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14780 
      return
14781 
    iprot.readStructBegin()
14782 
    while True:
14783 
      (fname, ftype, fid) = iprot.readFieldBegin()
14784 
      if ftype == TType.STOP:
14785 
        break
14786 
      if fid == 1:
14787 
        if ftype == TType.I64:
14788 
          self.catalog_item_id = iprot.readI64();
14789 
        else:
14790 
          iprot.skip(ftype)
14791 
      else:
14792 
        iprot.skip(ftype)
14793 
      iprot.readFieldEnd()
14794 
    iprot.readStructEnd()
14795 
 
14796 
  def write(self, oprot):
14797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14799 
      return
14800 
    oprot.writeStructBegin('isValidCatalogItemId_args')
14801 
    if self.catalog_item_id is not None:
14802 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14803 
      oprot.writeI64(self.catalog_item_id)
14804 
      oprot.writeFieldEnd()
14805 
    oprot.writeFieldStop()
14806 
    oprot.writeStructEnd()
14807 
 
14808 
  def validate(self):
14809 
    return
14810 
 
14811 
 
14812 
  def __repr__(self):
14813 
    L = ['%s=%r' % (key, value)
14814 
      for key, value in self.__dict__.iteritems()]
14815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14816 
 
14817 
  def __eq__(self, other):
14818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14819 
 
14820 
  def __ne__(self, other):
14821 
    return not (self == other)
14822 
 
14823 
class isValidCatalogItemId_result:
14824 
  """
14825 
  Attributes:
14826 
   - success
14827 
  """
14828 
 
14829 
  thrift_spec = (
14830 
    (0, TType.BOOL, 'success', None, None, ), # 0
14831 
  )
14832 
 
14833 
  def __init__(self, success=None,):
14834 
    self.success = success
14835 
 
14836 
  def read(self, iprot):
14837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14839 
      return
14840 
    iprot.readStructBegin()
14841 
    while True:
14842 
      (fname, ftype, fid) = iprot.readFieldBegin()
14843 
      if ftype == TType.STOP:
14844 
        break
14845 
      if fid == 0:
14846 
        if ftype == TType.BOOL:
14847 
          self.success = iprot.readBool();
14848 
        else:
14849 
          iprot.skip(ftype)
14850 
      else:
14851 
        iprot.skip(ftype)
14852 
      iprot.readFieldEnd()
14853 
    iprot.readStructEnd()
14854 
 
14855 
  def write(self, oprot):
14856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14858 
      return
14859 
    oprot.writeStructBegin('isValidCatalogItemId_result')
14860 
    if self.success is not None:
14861 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14862 
      oprot.writeBool(self.success)
14863 
      oprot.writeFieldEnd()
14864 
    oprot.writeFieldStop()
14865 
    oprot.writeStructEnd()
14866 
 
14867 
  def validate(self):
14868 
    return
14869 
 
14870 
 
14871 
  def __repr__(self):
14872 
    L = ['%s=%r' % (key, value)
14873 
      for key, value in self.__dict__.iteritems()]
14874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14875 
 
14876 
  def __eq__(self, other):
14877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14878 
 
14879 
  def __ne__(self, other):
14880 
    return not (self == other)
6039 amit.gupta 14881 
 
14882 
class getVatPercentageForItem_args:
14883 
  """
14884 
  Attributes:
14885 
   - itemId
7330 amit.gupta 14886 
   - stateId
6039 amit.gupta 14887 
   - price
14888 
  """
14889 
 
14890 
  thrift_spec = (
14891 
    None, # 0
14892 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 14893 
    (2, TType.I64, 'stateId', None, None, ), # 2
14894 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 14895 
  )
14896 
 
7330 amit.gupta 14897 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 14898 
    self.itemId = itemId
7330 amit.gupta 14899 
    self.stateId = stateId
6039 amit.gupta 14900 
    self.price = price
14901 
 
14902 
  def read(self, iprot):
14903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14905 
      return
14906 
    iprot.readStructBegin()
14907 
    while True:
14908 
      (fname, ftype, fid) = iprot.readFieldBegin()
14909 
      if ftype == TType.STOP:
14910 
        break
14911 
      if fid == 1:
14912 
        if ftype == TType.I64:
14913 
          self.itemId = iprot.readI64();
14914 
        else:
14915 
          iprot.skip(ftype)
14916 
      elif fid == 2:
7330 amit.gupta 14917 
        if ftype == TType.I64:
14918 
          self.stateId = iprot.readI64();
14919 
        else:
14920 
          iprot.skip(ftype)
14921 
      elif fid == 3:
6039 amit.gupta 14922 
        if ftype == TType.DOUBLE:
14923 
          self.price = iprot.readDouble();
14924 
        else:
14925 
          iprot.skip(ftype)
14926 
      else:
14927 
        iprot.skip(ftype)
14928 
      iprot.readFieldEnd()
14929 
    iprot.readStructEnd()
14930 
 
14931 
  def write(self, oprot):
14932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14934 
      return
14935 
    oprot.writeStructBegin('getVatPercentageForItem_args')
14936 
    if self.itemId is not None:
14937 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14938 
      oprot.writeI64(self.itemId)
14939 
      oprot.writeFieldEnd()
7330 amit.gupta 14940 
    if self.stateId is not None:
14941 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
14942 
      oprot.writeI64(self.stateId)
14943 
      oprot.writeFieldEnd()
6039 amit.gupta 14944 
    if self.price is not None:
7330 amit.gupta 14945 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 14946 
      oprot.writeDouble(self.price)
14947 
      oprot.writeFieldEnd()
14948 
    oprot.writeFieldStop()
14949 
    oprot.writeStructEnd()
14950 
 
14951 
  def validate(self):
14952 
    return
14953 
 
14954 
 
14955 
  def __repr__(self):
14956 
    L = ['%s=%r' % (key, value)
14957 
      for key, value in self.__dict__.iteritems()]
14958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14959 
 
14960 
  def __eq__(self, other):
14961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14962 
 
14963 
  def __ne__(self, other):
14964 
    return not (self == other)
14965 
 
14966 
class getVatPercentageForItem_result:
14967 
  """
14968 
  Attributes:
14969 
   - success
7340 amit.gupta 14970 
   - cex
6039 amit.gupta 14971 
  """
14972 
 
14973 
  thrift_spec = (
14974 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 14975 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 14976 
  )
14977 
 
7340 amit.gupta 14978 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 14979 
    self.success = success
7340 amit.gupta 14980 
    self.cex = cex
6039 amit.gupta 14981 
 
14982 
  def read(self, iprot):
14983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14985 
      return
14986 
    iprot.readStructBegin()
14987 
    while True:
14988 
      (fname, ftype, fid) = iprot.readFieldBegin()
14989 
      if ftype == TType.STOP:
14990 
        break
14991 
      if fid == 0:
14992 
        if ftype == TType.DOUBLE:
14993 
          self.success = iprot.readDouble();
14994 
        else:
14995 
          iprot.skip(ftype)
7340 amit.gupta 14996 
      elif fid == 1:
14997 
        if ftype == TType.STRUCT:
14998 
          self.cex = CatalogServiceException()
14999 
          self.cex.read(iprot)
15000 
        else:
15001 
          iprot.skip(ftype)
6039 amit.gupta 15002 
      else:
15003 
        iprot.skip(ftype)
15004 
      iprot.readFieldEnd()
15005 
    iprot.readStructEnd()
15006 
 
15007 
  def write(self, oprot):
15008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15010 
      return
15011 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15012 
    if self.success is not None:
15013 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15014 
      oprot.writeDouble(self.success)
15015 
      oprot.writeFieldEnd()
7340 amit.gupta 15016 
    if self.cex is not None:
15017 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15018 
      self.cex.write(oprot)
15019 
      oprot.writeFieldEnd()
6039 amit.gupta 15020 
    oprot.writeFieldStop()
15021 
    oprot.writeStructEnd()
15022 
 
15023 
  def validate(self):
15024 
    return
15025 
 
15026 
 
15027 
  def __repr__(self):
15028 
    L = ['%s=%r' % (key, value)
15029 
      for key, value in self.__dict__.iteritems()]
15030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15031 
 
15032 
  def __eq__(self, other):
15033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15034 
 
15035 
  def __ne__(self, other):
15036 
    return not (self == other)
15037 
 
15038 
class getVatAmountForItem_args:
15039 
  """
15040 
  Attributes:
15041 
   - itemId
15042 
   - price
15043 
  """
15044 
 
15045 
  thrift_spec = (
15046 
    None, # 0
15047 
    (1, TType.I64, 'itemId', None, None, ), # 1
15048 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15049 
  )
15050 
 
15051 
  def __init__(self, itemId=None, price=None,):
15052 
    self.itemId = itemId
15053 
    self.price = price
15054 
 
15055 
  def read(self, iprot):
15056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15058 
      return
15059 
    iprot.readStructBegin()
15060 
    while True:
15061 
      (fname, ftype, fid) = iprot.readFieldBegin()
15062 
      if ftype == TType.STOP:
15063 
        break
15064 
      if fid == 1:
15065 
        if ftype == TType.I64:
15066 
          self.itemId = iprot.readI64();
15067 
        else:
15068 
          iprot.skip(ftype)
15069 
      elif fid == 2:
15070 
        if ftype == TType.DOUBLE:
15071 
          self.price = iprot.readDouble();
15072 
        else:
15073 
          iprot.skip(ftype)
15074 
      else:
15075 
        iprot.skip(ftype)
15076 
      iprot.readFieldEnd()
15077 
    iprot.readStructEnd()
15078 
 
15079 
  def write(self, oprot):
15080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15082 
      return
15083 
    oprot.writeStructBegin('getVatAmountForItem_args')
15084 
    if self.itemId is not None:
15085 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15086 
      oprot.writeI64(self.itemId)
15087 
      oprot.writeFieldEnd()
15088 
    if self.price is not None:
15089 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15090 
      oprot.writeDouble(self.price)
15091 
      oprot.writeFieldEnd()
15092 
    oprot.writeFieldStop()
15093 
    oprot.writeStructEnd()
15094 
 
15095 
  def validate(self):
15096 
    return
15097 
 
15098 
 
15099 
  def __repr__(self):
15100 
    L = ['%s=%r' % (key, value)
15101 
      for key, value in self.__dict__.iteritems()]
15102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15103 
 
15104 
  def __eq__(self, other):
15105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15106 
 
15107 
  def __ne__(self, other):
15108 
    return not (self == other)
15109 
 
15110 
class getVatAmountForItem_result:
15111 
  """
15112 
  Attributes:
15113 
   - success
15114 
  """
15115 
 
15116 
  thrift_spec = (
15117 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15118 
  )
15119 
 
15120 
  def __init__(self, success=None,):
15121 
    self.success = success
15122 
 
15123 
  def read(self, iprot):
15124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15126 
      return
15127 
    iprot.readStructBegin()
15128 
    while True:
15129 
      (fname, ftype, fid) = iprot.readFieldBegin()
15130 
      if ftype == TType.STOP:
15131 
        break
15132 
      if fid == 0:
15133 
        if ftype == TType.DOUBLE:
15134 
          self.success = iprot.readDouble();
15135 
        else:
15136 
          iprot.skip(ftype)
15137 
      else:
15138 
        iprot.skip(ftype)
15139 
      iprot.readFieldEnd()
15140 
    iprot.readStructEnd()
15141 
 
15142 
  def write(self, oprot):
15143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15145 
      return
15146 
    oprot.writeStructBegin('getVatAmountForItem_result')
15147 
    if self.success is not None:
15148 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15149 
      oprot.writeDouble(self.success)
15150 
      oprot.writeFieldEnd()
15151 
    oprot.writeFieldStop()
15152 
    oprot.writeStructEnd()
15153 
 
15154 
  def validate(self):
15155 
    return
15156 
 
15157 
 
15158 
  def __repr__(self):
15159 
    L = ['%s=%r' % (key, value)
15160 
      for key, value in self.__dict__.iteritems()]
15161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15162 
 
15163 
  def __eq__(self, other):
15164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15165 
 
15166 
  def __ne__(self, other):
15167 
    return not (self == other)
6531 vikram.rag 15168 
 
15169 
class getAllIgnoredInventoryUpdateItemsList_args:
15170 
  """
15171 
  Attributes:
15172 
   - offset
15173 
   - limit
15174 
  """
15175 
 
15176 
  thrift_spec = (
15177 
    None, # 0
15178 
    (1, TType.I32, 'offset', None, None, ), # 1
15179 
    (2, TType.I32, 'limit', None, None, ), # 2
15180 
  )
15181 
 
15182 
  def __init__(self, offset=None, limit=None,):
15183 
    self.offset = offset
15184 
    self.limit = limit
15185 
 
15186 
  def read(self, iprot):
15187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15189 
      return
15190 
    iprot.readStructBegin()
15191 
    while True:
15192 
      (fname, ftype, fid) = iprot.readFieldBegin()
15193 
      if ftype == TType.STOP:
15194 
        break
15195 
      if fid == 1:
15196 
        if ftype == TType.I32:
15197 
          self.offset = iprot.readI32();
15198 
        else:
15199 
          iprot.skip(ftype)
15200 
      elif fid == 2:
15201 
        if ftype == TType.I32:
15202 
          self.limit = iprot.readI32();
15203 
        else:
15204 
          iprot.skip(ftype)
15205 
      else:
15206 
        iprot.skip(ftype)
15207 
      iprot.readFieldEnd()
15208 
    iprot.readStructEnd()
15209 
 
15210 
  def write(self, oprot):
15211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15213 
      return
15214 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15215 
    if self.offset is not None:
15216 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15217 
      oprot.writeI32(self.offset)
15218 
      oprot.writeFieldEnd()
15219 
    if self.limit is not None:
15220 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15221 
      oprot.writeI32(self.limit)
15222 
      oprot.writeFieldEnd()
15223 
    oprot.writeFieldStop()
15224 
    oprot.writeStructEnd()
15225 
 
15226 
  def validate(self):
15227 
    return
15228 
 
15229 
 
15230 
  def __repr__(self):
15231 
    L = ['%s=%r' % (key, value)
15232 
      for key, value in self.__dict__.iteritems()]
15233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15234 
 
15235 
  def __eq__(self, other):
15236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15237 
 
15238 
  def __ne__(self, other):
15239 
    return not (self == other)
15240 
 
15241 
class getAllIgnoredInventoryUpdateItemsList_result:
15242 
  """
15243 
  Attributes:
15244 
   - success
15245 
  """
15246 
 
15247 
  thrift_spec = (
15248 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15249 
  )
15250 
 
15251 
  def __init__(self, success=None,):
15252 
    self.success = success
15253 
 
15254 
  def read(self, iprot):
15255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15257 
      return
15258 
    iprot.readStructBegin()
15259 
    while True:
15260 
      (fname, ftype, fid) = iprot.readFieldBegin()
15261 
      if ftype == TType.STOP:
15262 
        break
15263 
      if fid == 0:
15264 
        if ftype == TType.LIST:
15265 
          self.success = []
7256 rajveer 15266 
          (_etype280, _size277) = iprot.readListBegin()
15267 
          for _i281 in xrange(_size277):
15268 
            _elem282 = Item()
15269 
            _elem282.read(iprot)
15270 
            self.success.append(_elem282)
6531 vikram.rag 15271 
          iprot.readListEnd()
15272 
        else:
15273 
          iprot.skip(ftype)
15274 
      else:
15275 
        iprot.skip(ftype)
15276 
      iprot.readFieldEnd()
15277 
    iprot.readStructEnd()
15278 
 
15279 
  def write(self, oprot):
15280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15282 
      return
15283 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_result')
15284 
    if self.success is not None:
15285 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15286 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15287 
      for iter283 in self.success:
15288 
        iter283.write(oprot)
6531 vikram.rag 15289 
      oprot.writeListEnd()
15290 
      oprot.writeFieldEnd()
15291 
    oprot.writeFieldStop()
15292 
    oprot.writeStructEnd()
15293 
 
15294 
  def validate(self):
15295 
    return
15296 
 
15297 
 
15298 
  def __repr__(self):
15299 
    L = ['%s=%r' % (key, value)
15300 
      for key, value in self.__dict__.iteritems()]
15301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15302 
 
15303 
  def __eq__(self, other):
15304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15305 
 
15306 
  def __ne__(self, other):
15307 
    return not (self == other)
6805 anupam.sin 15308 
 
6821 amar.kumar 15309 
class getAllAliveItems_args:
15310 
 
15311 
  thrift_spec = (
15312 
  )
15313 
 
15314 
  def read(self, iprot):
15315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15317 
      return
15318 
    iprot.readStructBegin()
15319 
    while True:
15320 
      (fname, ftype, fid) = iprot.readFieldBegin()
15321 
      if ftype == TType.STOP:
15322 
        break
15323 
      else:
15324 
        iprot.skip(ftype)
15325 
      iprot.readFieldEnd()
15326 
    iprot.readStructEnd()
15327 
 
15328 
  def write(self, oprot):
15329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15331 
      return
15332 
    oprot.writeStructBegin('getAllAliveItems_args')
15333 
    oprot.writeFieldStop()
15334 
    oprot.writeStructEnd()
15335 
 
15336 
  def validate(self):
15337 
    return
15338 
 
15339 
 
15340 
  def __repr__(self):
15341 
    L = ['%s=%r' % (key, value)
15342 
      for key, value in self.__dict__.iteritems()]
15343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15344 
 
15345 
  def __eq__(self, other):
15346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15347 
 
15348 
  def __ne__(self, other):
15349 
    return not (self == other)
15350 
 
15351 
class getAllAliveItems_result:
15352 
  """
15353 
  Attributes:
15354 
   - success
15355 
  """
15356 
 
15357 
  thrift_spec = (
15358 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15359 
  )
15360 
 
15361 
  def __init__(self, success=None,):
15362 
    self.success = success
15363 
 
15364 
  def read(self, iprot):
15365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15367 
      return
15368 
    iprot.readStructBegin()
15369 
    while True:
15370 
      (fname, ftype, fid) = iprot.readFieldBegin()
15371 
      if ftype == TType.STOP:
15372 
        break
15373 
      if fid == 0:
15374 
        if ftype == TType.LIST:
15375 
          self.success = []
7256 rajveer 15376 
          (_etype287, _size284) = iprot.readListBegin()
15377 
          for _i288 in xrange(_size284):
15378 
            _elem289 = Item()
15379 
            _elem289.read(iprot)
15380 
            self.success.append(_elem289)
6821 amar.kumar 15381 
          iprot.readListEnd()
15382 
        else:
15383 
          iprot.skip(ftype)
15384 
      else:
15385 
        iprot.skip(ftype)
15386 
      iprot.readFieldEnd()
15387 
    iprot.readStructEnd()
15388 
 
15389 
  def write(self, oprot):
15390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15392 
      return
15393 
    oprot.writeStructBegin('getAllAliveItems_result')
15394 
    if self.success is not None:
15395 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15396 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15397 
      for iter290 in self.success:
15398 
        iter290.write(oprot)
6821 amar.kumar 15399 
      oprot.writeListEnd()
15400 
      oprot.writeFieldEnd()
15401 
    oprot.writeFieldStop()
15402 
    oprot.writeStructEnd()
15403 
 
15404 
  def validate(self):
15405 
    return
15406 
 
15407 
 
15408 
  def __repr__(self):
15409 
    L = ['%s=%r' % (key, value)
15410 
      for key, value in self.__dict__.iteritems()]
15411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15412 
 
15413 
  def __eq__(self, other):
15414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15415 
 
15416 
  def __ne__(self, other):
15417 
    return not (self == other)
15418 
 
6805 anupam.sin 15419 
class getInsuranceAmount_args:
15420 
  """
15421 
  Attributes:
15422 
   - itemId
6921 anupam.sin 15423 
   - price
6805 anupam.sin 15424 
   - insurerId
15425 
   - quantity
15426 
  """
15427 
 
15428 
  thrift_spec = (
15429 
    None, # 0
15430 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15431 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15432 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15433 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15434 
  )
15435 
 
6921 anupam.sin 15436 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15437 
    self.itemId = itemId
6921 anupam.sin 15438 
    self.price = price
6805 anupam.sin 15439 
    self.insurerId = insurerId
15440 
    self.quantity = quantity
15441 
 
15442 
  def read(self, iprot):
15443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15445 
      return
15446 
    iprot.readStructBegin()
15447 
    while True:
15448 
      (fname, ftype, fid) = iprot.readFieldBegin()
15449 
      if ftype == TType.STOP:
15450 
        break
15451 
      if fid == 1:
15452 
        if ftype == TType.I64:
15453 
          self.itemId = iprot.readI64();
15454 
        else:
15455 
          iprot.skip(ftype)
15456 
      elif fid == 2:
6921 anupam.sin 15457 
        if ftype == TType.DOUBLE:
15458 
          self.price = iprot.readDouble();
15459 
        else:
15460 
          iprot.skip(ftype)
15461 
      elif fid == 3:
6805 anupam.sin 15462 
        if ftype == TType.I64:
15463 
          self.insurerId = iprot.readI64();
15464 
        else:
15465 
          iprot.skip(ftype)
6921 anupam.sin 15466 
      elif fid == 4:
6805 anupam.sin 15467 
        if ftype == TType.I64:
15468 
          self.quantity = iprot.readI64();
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
15480 
    oprot.writeStructBegin('getInsuranceAmount_args')
15481 
    if self.itemId is not None:
15482 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15483 
      oprot.writeI64(self.itemId)
15484 
      oprot.writeFieldEnd()
6921 anupam.sin 15485 
    if self.price is not None:
15486 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15487 
      oprot.writeDouble(self.price)
15488 
      oprot.writeFieldEnd()
6805 anupam.sin 15489 
    if self.insurerId is not None:
6921 anupam.sin 15490 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15491 
      oprot.writeI64(self.insurerId)
15492 
      oprot.writeFieldEnd()
15493 
    if self.quantity is not None:
6921 anupam.sin 15494 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15495 
      oprot.writeI64(self.quantity)
15496 
      oprot.writeFieldEnd()
15497 
    oprot.writeFieldStop()
15498 
    oprot.writeStructEnd()
15499 
 
15500 
  def validate(self):
15501 
    return
15502 
 
15503 
 
15504 
  def __repr__(self):
15505 
    L = ['%s=%r' % (key, value)
15506 
      for key, value in self.__dict__.iteritems()]
15507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15508 
 
15509 
  def __eq__(self, other):
15510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15511 
 
15512 
  def __ne__(self, other):
15513 
    return not (self == other)
15514 
 
15515 
class getInsuranceAmount_result:
15516 
  """
15517 
  Attributes:
15518 
   - success
15519 
  """
15520 
 
15521 
  thrift_spec = (
15522 
    (0, TType.I64, 'success', None, None, ), # 0
15523 
  )
15524 
 
15525 
  def __init__(self, success=None,):
15526 
    self.success = success
15527 
 
15528 
  def read(self, iprot):
15529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15531 
      return
15532 
    iprot.readStructBegin()
15533 
    while True:
15534 
      (fname, ftype, fid) = iprot.readFieldBegin()
15535 
      if ftype == TType.STOP:
15536 
        break
15537 
      if fid == 0:
15538 
        if ftype == TType.I64:
15539 
          self.success = iprot.readI64();
15540 
        else:
15541 
          iprot.skip(ftype)
15542 
      else:
15543 
        iprot.skip(ftype)
15544 
      iprot.readFieldEnd()
15545 
    iprot.readStructEnd()
15546 
 
15547 
  def write(self, oprot):
15548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15550 
      return
15551 
    oprot.writeStructBegin('getInsuranceAmount_result')
15552 
    if self.success is not None:
15553 
      oprot.writeFieldBegin('success', TType.I64, 0)
15554 
      oprot.writeI64(self.success)
15555 
      oprot.writeFieldEnd()
15556 
    oprot.writeFieldStop()
15557 
    oprot.writeStructEnd()
15558 
 
15559 
  def validate(self):
15560 
    return
15561 
 
15562 
 
15563 
  def __repr__(self):
15564 
    L = ['%s=%r' % (key, value)
15565 
      for key, value in self.__dict__.iteritems()]
15566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15567 
 
15568 
  def __eq__(self, other):
15569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15570 
 
15571 
  def __ne__(self, other):
15572 
    return not (self == other)
15573 
 
15574 
class getInsurer_args:
15575 
  """
15576 
  Attributes:
15577 
   - insurerId
15578 
  """
15579 
 
15580 
  thrift_spec = (
15581 
    None, # 0
15582 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15583 
  )
15584 
 
15585 
  def __init__(self, insurerId=None,):
15586 
    self.insurerId = insurerId
15587 
 
15588 
  def read(self, iprot):
15589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15591 
      return
15592 
    iprot.readStructBegin()
15593 
    while True:
15594 
      (fname, ftype, fid) = iprot.readFieldBegin()
15595 
      if ftype == TType.STOP:
15596 
        break
15597 
      if fid == 1:
15598 
        if ftype == TType.I64:
15599 
          self.insurerId = iprot.readI64();
15600 
        else:
15601 
          iprot.skip(ftype)
15602 
      else:
15603 
        iprot.skip(ftype)
15604 
      iprot.readFieldEnd()
15605 
    iprot.readStructEnd()
15606 
 
15607 
  def write(self, oprot):
15608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15610 
      return
15611 
    oprot.writeStructBegin('getInsurer_args')
15612 
    if self.insurerId is not None:
15613 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15614 
      oprot.writeI64(self.insurerId)
15615 
      oprot.writeFieldEnd()
15616 
    oprot.writeFieldStop()
15617 
    oprot.writeStructEnd()
15618 
 
15619 
  def validate(self):
15620 
    return
15621 
 
15622 
 
15623 
  def __repr__(self):
15624 
    L = ['%s=%r' % (key, value)
15625 
      for key, value in self.__dict__.iteritems()]
15626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15627 
 
15628 
  def __eq__(self, other):
15629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15630 
 
15631 
  def __ne__(self, other):
15632 
    return not (self == other)
15633 
 
15634 
class getInsurer_result:
15635 
  """
15636 
  Attributes:
15637 
   - success
15638 
  """
15639 
 
15640 
  thrift_spec = (
15641 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15642 
  )
15643 
 
15644 
  def __init__(self, success=None,):
15645 
    self.success = success
15646 
 
15647 
  def read(self, iprot):
15648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15650 
      return
15651 
    iprot.readStructBegin()
15652 
    while True:
15653 
      (fname, ftype, fid) = iprot.readFieldBegin()
15654 
      if ftype == TType.STOP:
15655 
        break
15656 
      if fid == 0:
15657 
        if ftype == TType.STRUCT:
15658 
          self.success = Insurer()
15659 
          self.success.read(iprot)
15660 
        else:
15661 
          iprot.skip(ftype)
15662 
      else:
15663 
        iprot.skip(ftype)
15664 
      iprot.readFieldEnd()
15665 
    iprot.readStructEnd()
15666 
 
15667 
  def write(self, oprot):
15668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15670 
      return
15671 
    oprot.writeStructBegin('getInsurer_result')
15672 
    if self.success is not None:
15673 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15674 
      self.success.write(oprot)
15675 
      oprot.writeFieldEnd()
15676 
    oprot.writeFieldStop()
15677 
    oprot.writeStructEnd()
15678 
 
15679 
  def validate(self):
15680 
    return
15681 
 
15682 
 
15683 
  def __repr__(self):
15684 
    L = ['%s=%r' % (key, value)
15685 
      for key, value in self.__dict__.iteritems()]
15686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15687 
 
15688 
  def __eq__(self, other):
15689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15690 
 
15691 
  def __ne__(self, other):
15692 
    return not (self == other)
6838 vikram.rag 15693 
 
15694 
class getAllInsurers_args:
15695 
 
15696 
  thrift_spec = (
15697 
  )
15698 
 
15699 
  def read(self, iprot):
15700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15702 
      return
15703 
    iprot.readStructBegin()
15704 
    while True:
15705 
      (fname, ftype, fid) = iprot.readFieldBegin()
15706 
      if ftype == TType.STOP:
15707 
        break
15708 
      else:
15709 
        iprot.skip(ftype)
15710 
      iprot.readFieldEnd()
15711 
    iprot.readStructEnd()
15712 
 
15713 
  def write(self, oprot):
15714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15716 
      return
15717 
    oprot.writeStructBegin('getAllInsurers_args')
15718 
    oprot.writeFieldStop()
15719 
    oprot.writeStructEnd()
15720 
 
15721 
  def validate(self):
15722 
    return
15723 
 
15724 
 
15725 
  def __repr__(self):
15726 
    L = ['%s=%r' % (key, value)
15727 
      for key, value in self.__dict__.iteritems()]
15728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15729 
 
15730 
  def __eq__(self, other):
15731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15732 
 
15733 
  def __ne__(self, other):
15734 
    return not (self == other)
15735 
 
15736 
class getAllInsurers_result:
15737 
  """
15738 
  Attributes:
15739 
   - success
15740 
  """
15741 
 
15742 
  thrift_spec = (
15743 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
15744 
  )
15745 
 
15746 
  def __init__(self, success=None,):
15747 
    self.success = success
15748 
 
15749 
  def read(self, iprot):
15750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15752 
      return
15753 
    iprot.readStructBegin()
15754 
    while True:
15755 
      (fname, ftype, fid) = iprot.readFieldBegin()
15756 
      if ftype == TType.STOP:
15757 
        break
15758 
      if fid == 0:
15759 
        if ftype == TType.LIST:
15760 
          self.success = []
7256 rajveer 15761 
          (_etype294, _size291) = iprot.readListBegin()
15762 
          for _i295 in xrange(_size291):
15763 
            _elem296 = Insurer()
15764 
            _elem296.read(iprot)
15765 
            self.success.append(_elem296)
6838 vikram.rag 15766 
          iprot.readListEnd()
15767 
        else:
15768 
          iprot.skip(ftype)
15769 
      else:
15770 
        iprot.skip(ftype)
15771 
      iprot.readFieldEnd()
15772 
    iprot.readStructEnd()
15773 
 
15774 
  def write(self, oprot):
15775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15777 
      return
15778 
    oprot.writeStructBegin('getAllInsurers_result')
15779 
    if self.success is not None:
15780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15781 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7256 rajveer 15782 
      for iter297 in self.success:
15783 
        iter297.write(oprot)
6838 vikram.rag 15784 
      oprot.writeListEnd()
15785 
      oprot.writeFieldEnd()
15786 
    oprot.writeFieldStop()
15787 
    oprot.writeStructEnd()
15788 
 
15789 
  def validate(self):
15790 
    return
15791 
 
15792 
 
15793 
  def __repr__(self):
15794 
    L = ['%s=%r' % (key, value)
15795 
      for key, value in self.__dict__.iteritems()]
15796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15797 
 
15798 
  def __eq__(self, other):
15799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15800 
 
15801 
  def __ne__(self, other):
15802 
    return not (self == other)
6962 rajveer 15803 
 
15804 
class updateInsuranceDeclaredAmount_args:
15805 
  """
15806 
  Attributes:
15807 
   - insurerId
15808 
   - amount
15809 
  """
15810 
 
15811 
  thrift_spec = (
15812 
    None, # 0
15813 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15814 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
15815 
  )
15816 
 
15817 
  def __init__(self, insurerId=None, amount=None,):
15818 
    self.insurerId = insurerId
15819 
    self.amount = amount
15820 
 
15821 
  def read(self, iprot):
15822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15824 
      return
15825 
    iprot.readStructBegin()
15826 
    while True:
15827 
      (fname, ftype, fid) = iprot.readFieldBegin()
15828 
      if ftype == TType.STOP:
15829 
        break
15830 
      if fid == 1:
15831 
        if ftype == TType.I64:
15832 
          self.insurerId = iprot.readI64();
15833 
        else:
15834 
          iprot.skip(ftype)
15835 
      elif fid == 2:
15836 
        if ftype == TType.DOUBLE:
15837 
          self.amount = iprot.readDouble();
15838 
        else:
15839 
          iprot.skip(ftype)
15840 
      else:
15841 
        iprot.skip(ftype)
15842 
      iprot.readFieldEnd()
15843 
    iprot.readStructEnd()
15844 
 
15845 
  def write(self, oprot):
15846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15848 
      return
15849 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
15850 
    if self.insurerId is not None:
15851 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15852 
      oprot.writeI64(self.insurerId)
15853 
      oprot.writeFieldEnd()
15854 
    if self.amount is not None:
15855 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
15856 
      oprot.writeDouble(self.amount)
15857 
      oprot.writeFieldEnd()
15858 
    oprot.writeFieldStop()
15859 
    oprot.writeStructEnd()
15860 
 
15861 
  def validate(self):
15862 
    return
15863 
 
15864 
 
15865 
  def __repr__(self):
15866 
    L = ['%s=%r' % (key, value)
15867 
      for key, value in self.__dict__.iteritems()]
15868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15869 
 
15870 
  def __eq__(self, other):
15871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15872 
 
15873 
  def __ne__(self, other):
15874 
    return not (self == other)
15875 
 
15876 
class updateInsuranceDeclaredAmount_result:
15877 
 
15878 
  thrift_spec = (
15879 
  )
15880 
 
15881 
  def read(self, iprot):
15882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15884 
      return
15885 
    iprot.readStructBegin()
15886 
    while True:
15887 
      (fname, ftype, fid) = iprot.readFieldBegin()
15888 
      if ftype == TType.STOP:
15889 
        break
15890 
      else:
15891 
        iprot.skip(ftype)
15892 
      iprot.readFieldEnd()
15893 
    iprot.readStructEnd()
15894 
 
15895 
  def write(self, oprot):
15896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15898 
      return
15899 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
15900 
    oprot.writeFieldStop()
15901 
    oprot.writeStructEnd()
15902 
 
15903 
  def validate(self):
15904 
    return
15905 
 
15906 
 
15907 
  def __repr__(self):
15908 
    L = ['%s=%r' % (key, value)
15909 
      for key, value in self.__dict__.iteritems()]
15910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15911 
 
15912 
  def __eq__(self, other):
15913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15914 
 
15915 
  def __ne__(self, other):
15916 
    return not (self == other)
7190 amar.kumar 15917 
 
15918 
class getFreebieForItem_args:
15919 
  """
15920 
  Attributes:
15921 
   - itemId
15922 
  """
15923 
 
15924 
  thrift_spec = (
15925 
    None, # 0
15926 
    (1, TType.I64, 'itemId', None, None, ), # 1
15927 
  )
15928 
 
15929 
  def __init__(self, itemId=None,):
15930 
    self.itemId = itemId
15931 
 
15932 
  def read(self, iprot):
15933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15935 
      return
15936 
    iprot.readStructBegin()
15937 
    while True:
15938 
      (fname, ftype, fid) = iprot.readFieldBegin()
15939 
      if ftype == TType.STOP:
15940 
        break
15941 
      if fid == 1:
15942 
        if ftype == TType.I64:
15943 
          self.itemId = iprot.readI64();
15944 
        else:
15945 
          iprot.skip(ftype)
15946 
      else:
15947 
        iprot.skip(ftype)
15948 
      iprot.readFieldEnd()
15949 
    iprot.readStructEnd()
15950 
 
15951 
  def write(self, oprot):
15952 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15953 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15954 
      return
15955 
    oprot.writeStructBegin('getFreebieForItem_args')
15956 
    if self.itemId is not None:
15957 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15958 
      oprot.writeI64(self.itemId)
15959 
      oprot.writeFieldEnd()
15960 
    oprot.writeFieldStop()
15961 
    oprot.writeStructEnd()
15962 
 
15963 
  def validate(self):
15964 
    return
15965 
 
15966 
 
15967 
  def __repr__(self):
15968 
    L = ['%s=%r' % (key, value)
15969 
      for key, value in self.__dict__.iteritems()]
15970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15971 
 
15972 
  def __eq__(self, other):
15973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15974 
 
15975 
  def __ne__(self, other):
15976 
    return not (self == other)
15977 
 
15978 
class getFreebieForItem_result:
15979 
  """
15980 
  Attributes:
15981 
   - success
15982 
  """
15983 
 
15984 
  thrift_spec = (
15985 
    (0, TType.I64, 'success', None, None, ), # 0
15986 
  )
15987 
 
15988 
  def __init__(self, success=None,):
15989 
    self.success = success
15990 
 
15991 
  def read(self, iprot):
15992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15994 
      return
15995 
    iprot.readStructBegin()
15996 
    while True:
15997 
      (fname, ftype, fid) = iprot.readFieldBegin()
15998 
      if ftype == TType.STOP:
15999 
        break
16000 
      if fid == 0:
16001 
        if ftype == TType.I64:
16002 
          self.success = iprot.readI64();
16003 
        else:
16004 
          iprot.skip(ftype)
16005 
      else:
16006 
        iprot.skip(ftype)
16007 
      iprot.readFieldEnd()
16008 
    iprot.readStructEnd()
16009 
 
16010 
  def write(self, oprot):
16011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16013 
      return
16014 
    oprot.writeStructBegin('getFreebieForItem_result')
16015 
    if self.success is not None:
16016 
      oprot.writeFieldBegin('success', TType.I64, 0)
16017 
      oprot.writeI64(self.success)
16018 
      oprot.writeFieldEnd()
16019 
    oprot.writeFieldStop()
16020 
    oprot.writeStructEnd()
16021 
 
16022 
  def validate(self):
16023 
    return
16024 
 
16025 
 
16026 
  def __repr__(self):
16027 
    L = ['%s=%r' % (key, value)
16028 
      for key, value in self.__dict__.iteritems()]
16029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16030 
 
16031 
  def __eq__(self, other):
16032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16033 
 
16034 
  def __ne__(self, other):
16035 
    return not (self == other)
16036 
 
16037 
class addOrUpdateFreebieForItem_args:
16038 
  """
16039 
  Attributes:
16040 
   - freebieItem
16041 
  """
16042 
 
16043 
  thrift_spec = (
16044 
    None, # 0
16045 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16046 
  )
16047 
 
16048 
  def __init__(self, freebieItem=None,):
16049 
    self.freebieItem = freebieItem
16050 
 
16051 
  def read(self, iprot):
16052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16054 
      return
16055 
    iprot.readStructBegin()
16056 
    while True:
16057 
      (fname, ftype, fid) = iprot.readFieldBegin()
16058 
      if ftype == TType.STOP:
16059 
        break
16060 
      if fid == 1:
16061 
        if ftype == TType.STRUCT:
16062 
          self.freebieItem = FreebieItem()
16063 
          self.freebieItem.read(iprot)
16064 
        else:
16065 
          iprot.skip(ftype)
16066 
      else:
16067 
        iprot.skip(ftype)
16068 
      iprot.readFieldEnd()
16069 
    iprot.readStructEnd()
16070 
 
16071 
  def write(self, oprot):
16072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16074 
      return
16075 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16076 
    if self.freebieItem is not None:
16077 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16078 
      self.freebieItem.write(oprot)
16079 
      oprot.writeFieldEnd()
16080 
    oprot.writeFieldStop()
16081 
    oprot.writeStructEnd()
16082 
 
16083 
  def validate(self):
16084 
    return
16085 
 
16086 
 
16087 
  def __repr__(self):
16088 
    L = ['%s=%r' % (key, value)
16089 
      for key, value in self.__dict__.iteritems()]
16090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16091 
 
16092 
  def __eq__(self, other):
16093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16094 
 
16095 
  def __ne__(self, other):
16096 
    return not (self == other)
16097 
 
16098 
class addOrUpdateFreebieForItem_result:
16099 
 
16100 
  thrift_spec = (
16101 
  )
16102 
 
16103 
  def read(self, iprot):
16104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16106 
      return
16107 
    iprot.readStructBegin()
16108 
    while True:
16109 
      (fname, ftype, fid) = iprot.readFieldBegin()
16110 
      if ftype == TType.STOP:
16111 
        break
16112 
      else:
16113 
        iprot.skip(ftype)
16114 
      iprot.readFieldEnd()
16115 
    iprot.readStructEnd()
16116 
 
16117 
  def write(self, oprot):
16118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16120 
      return
16121 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16122 
    oprot.writeFieldStop()
16123 
    oprot.writeStructEnd()
16124 
 
16125 
  def validate(self):
16126 
    return
16127 
 
16128 
 
16129 
  def __repr__(self):
16130 
    L = ['%s=%r' % (key, value)
16131 
      for key, value in self.__dict__.iteritems()]
16132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16133 
 
16134 
  def __eq__(self, other):
16135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16136 
 
16137 
  def __ne__(self, other):
16138 
    return not (self == other)
7256 rajveer 16139 
 
7272 amit.gupta 16140 
class addOrUpdateBrandInfo_args:
16141 
  """
16142 
  Attributes:
16143 
   - brandInfo
16144 
  """
16145 
 
16146 
  thrift_spec = (
16147 
    None, # 0
16148 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16149 
  )
16150 
 
16151 
  def __init__(self, brandInfo=None,):
16152 
    self.brandInfo = brandInfo
16153 
 
16154 
  def read(self, iprot):
16155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16157 
      return
16158 
    iprot.readStructBegin()
16159 
    while True:
16160 
      (fname, ftype, fid) = iprot.readFieldBegin()
16161 
      if ftype == TType.STOP:
16162 
        break
16163 
      if fid == 1:
16164 
        if ftype == TType.STRUCT:
16165 
          self.brandInfo = BrandInfo()
16166 
          self.brandInfo.read(iprot)
16167 
        else:
16168 
          iprot.skip(ftype)
16169 
      else:
16170 
        iprot.skip(ftype)
16171 
      iprot.readFieldEnd()
16172 
    iprot.readStructEnd()
16173 
 
16174 
  def write(self, oprot):
16175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16177 
      return
16178 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16179 
    if self.brandInfo is not None:
16180 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16181 
      self.brandInfo.write(oprot)
16182 
      oprot.writeFieldEnd()
16183 
    oprot.writeFieldStop()
16184 
    oprot.writeStructEnd()
16185 
 
16186 
  def validate(self):
16187 
    return
16188 
 
16189 
 
16190 
  def __repr__(self):
16191 
    L = ['%s=%r' % (key, value)
16192 
      for key, value in self.__dict__.iteritems()]
16193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16194 
 
16195 
  def __eq__(self, other):
16196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16197 
 
16198 
  def __ne__(self, other):
16199 
    return not (self == other)
16200 
 
16201 
class addOrUpdateBrandInfo_result:
16202 
 
16203 
  thrift_spec = (
16204 
  )
16205 
 
16206 
  def read(self, iprot):
16207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16209 
      return
16210 
    iprot.readStructBegin()
16211 
    while True:
16212 
      (fname, ftype, fid) = iprot.readFieldBegin()
16213 
      if ftype == TType.STOP:
16214 
        break
16215 
      else:
16216 
        iprot.skip(ftype)
16217 
      iprot.readFieldEnd()
16218 
    iprot.readStructEnd()
16219 
 
16220 
  def write(self, oprot):
16221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16223 
      return
16224 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16225 
    oprot.writeFieldStop()
16226 
    oprot.writeStructEnd()
16227 
 
16228 
  def validate(self):
16229 
    return
16230 
 
16231 
 
16232 
  def __repr__(self):
16233 
    L = ['%s=%r' % (key, value)
16234 
      for key, value in self.__dict__.iteritems()]
16235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16236 
 
16237 
  def __eq__(self, other):
16238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16239 
 
16240 
  def __ne__(self, other):
16241 
    return not (self == other)
16242 
 
16243 
class getBrandInfo_args:
16244 
 
16245 
  thrift_spec = (
16246 
  )
16247 
 
16248 
  def read(self, iprot):
16249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16251 
      return
16252 
    iprot.readStructBegin()
16253 
    while True:
16254 
      (fname, ftype, fid) = iprot.readFieldBegin()
16255 
      if ftype == TType.STOP:
16256 
        break
16257 
      else:
16258 
        iprot.skip(ftype)
16259 
      iprot.readFieldEnd()
16260 
    iprot.readStructEnd()
16261 
 
16262 
  def write(self, oprot):
16263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16265 
      return
16266 
    oprot.writeStructBegin('getBrandInfo_args')
16267 
    oprot.writeFieldStop()
16268 
    oprot.writeStructEnd()
16269 
 
16270 
  def validate(self):
16271 
    return
16272 
 
16273 
 
16274 
  def __repr__(self):
16275 
    L = ['%s=%r' % (key, value)
16276 
      for key, value in self.__dict__.iteritems()]
16277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16278 
 
16279 
  def __eq__(self, other):
16280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16281 
 
16282 
  def __ne__(self, other):
16283 
    return not (self == other)
16284 
 
16285 
class getBrandInfo_result:
16286 
  """
16287 
  Attributes:
16288 
   - success
16289 
  """
16290 
 
16291 
  thrift_spec = (
16292 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16293 
  )
16294 
 
16295 
  def __init__(self, success=None,):
16296 
    self.success = success
16297 
 
16298 
  def read(self, iprot):
16299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16301 
      return
16302 
    iprot.readStructBegin()
16303 
    while True:
16304 
      (fname, ftype, fid) = iprot.readFieldBegin()
16305 
      if ftype == TType.STOP:
16306 
        break
16307 
      if fid == 0:
16308 
        if ftype == TType.MAP:
16309 
          self.success = {}
16310 
          (_ktype299, _vtype300, _size298 ) = iprot.readMapBegin()
16311 
          for _i302 in xrange(_size298):
16312 
            _key303 = iprot.readString();
16313 
            _val304 = BrandInfo()
16314 
            _val304.read(iprot)
16315 
            self.success[_key303] = _val304
16316 
          iprot.readMapEnd()
16317 
        else:
16318 
          iprot.skip(ftype)
16319 
      else:
16320 
        iprot.skip(ftype)
16321 
      iprot.readFieldEnd()
16322 
    iprot.readStructEnd()
16323 
 
16324 
  def write(self, oprot):
16325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16327 
      return
16328 
    oprot.writeStructBegin('getBrandInfo_result')
16329 
    if self.success is not None:
16330 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16331 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
16332 
      for kiter305,viter306 in self.success.items():
16333 
        oprot.writeString(kiter305)
16334 
        viter306.write(oprot)
16335 
      oprot.writeMapEnd()
16336 
      oprot.writeFieldEnd()
16337 
    oprot.writeFieldStop()
16338 
    oprot.writeStructEnd()
16339 
 
16340 
  def validate(self):
16341 
    return
16342 
 
16343 
 
16344 
  def __repr__(self):
16345 
    L = ['%s=%r' % (key, value)
16346 
      for key, value in self.__dict__.iteritems()]
16347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16348 
 
16349 
  def __eq__(self, other):
16350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16351 
 
16352 
  def __ne__(self, other):
16353 
    return not (self == other)
16354 
 
7256 rajveer 16355 
class getStorePricing_args:
16356 
  """
16357 
  Attributes:
16358 
   - itemId
16359 
  """
16360 
 
16361 
  thrift_spec = (
16362 
    None, # 0
16363 
    (1, TType.I64, 'itemId', None, None, ), # 1
16364 
  )
16365 
 
16366 
  def __init__(self, itemId=None,):
16367 
    self.itemId = itemId
16368 
 
16369 
  def read(self, iprot):
16370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16372 
      return
16373 
    iprot.readStructBegin()
16374 
    while True:
16375 
      (fname, ftype, fid) = iprot.readFieldBegin()
16376 
      if ftype == TType.STOP:
16377 
        break
16378 
      if fid == 1:
16379 
        if ftype == TType.I64:
16380 
          self.itemId = iprot.readI64();
16381 
        else:
16382 
          iprot.skip(ftype)
16383 
      else:
16384 
        iprot.skip(ftype)
16385 
      iprot.readFieldEnd()
16386 
    iprot.readStructEnd()
16387 
 
16388 
  def write(self, oprot):
16389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16391 
      return
16392 
    oprot.writeStructBegin('getStorePricing_args')
16393 
    if self.itemId is not None:
16394 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16395 
      oprot.writeI64(self.itemId)
16396 
      oprot.writeFieldEnd()
16397 
    oprot.writeFieldStop()
16398 
    oprot.writeStructEnd()
16399 
 
16400 
  def validate(self):
16401 
    return
16402 
 
16403 
 
16404 
  def __repr__(self):
16405 
    L = ['%s=%r' % (key, value)
16406 
      for key, value in self.__dict__.iteritems()]
16407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16408 
 
16409 
  def __eq__(self, other):
16410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16411 
 
16412 
  def __ne__(self, other):
16413 
    return not (self == other)
16414 
 
16415 
class getStorePricing_result:
16416 
  """
16417 
  Attributes:
16418 
   - success
16419 
  """
16420 
 
16421 
  thrift_spec = (
16422 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16423 
  )
16424 
 
16425 
  def __init__(self, success=None,):
16426 
    self.success = success
16427 
 
16428 
  def read(self, iprot):
16429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16431 
      return
16432 
    iprot.readStructBegin()
16433 
    while True:
16434 
      (fname, ftype, fid) = iprot.readFieldBegin()
16435 
      if ftype == TType.STOP:
16436 
        break
16437 
      if fid == 0:
16438 
        if ftype == TType.STRUCT:
16439 
          self.success = StorePricing()
16440 
          self.success.read(iprot)
16441 
        else:
16442 
          iprot.skip(ftype)
16443 
      else:
16444 
        iprot.skip(ftype)
16445 
      iprot.readFieldEnd()
16446 
    iprot.readStructEnd()
16447 
 
16448 
  def write(self, oprot):
16449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16451 
      return
16452 
    oprot.writeStructBegin('getStorePricing_result')
16453 
    if self.success is not None:
16454 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16455 
      self.success.write(oprot)
16456 
      oprot.writeFieldEnd()
16457 
    oprot.writeFieldStop()
16458 
    oprot.writeStructEnd()
16459 
 
16460 
  def validate(self):
16461 
    return
16462 
 
16463 
 
16464 
  def __repr__(self):
16465 
    L = ['%s=%r' % (key, value)
16466 
      for key, value in self.__dict__.iteritems()]
16467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16468 
 
16469 
  def __eq__(self, other):
16470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16471 
 
16472 
  def __ne__(self, other):
16473 
    return not (self == other)
7265 rajveer 16474 
 
7306 rajveer 16475 
class getStorePricings_args:
16476 
  """
16477 
  Attributes:
16478 
   - itemIds
16479 
  """
16480 
 
16481 
  thrift_spec = (
16482 
    None, # 0
16483 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16484 
  )
16485 
 
16486 
  def __init__(self, itemIds=None,):
16487 
    self.itemIds = itemIds
16488 
 
16489 
  def read(self, iprot):
16490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16492 
      return
16493 
    iprot.readStructBegin()
16494 
    while True:
16495 
      (fname, ftype, fid) = iprot.readFieldBegin()
16496 
      if ftype == TType.STOP:
16497 
        break
16498 
      if fid == 1:
16499 
        if ftype == TType.LIST:
16500 
          self.itemIds = []
16501 
          (_etype310, _size307) = iprot.readListBegin()
16502 
          for _i311 in xrange(_size307):
16503 
            _elem312 = iprot.readI64();
16504 
            self.itemIds.append(_elem312)
16505 
          iprot.readListEnd()
16506 
        else:
16507 
          iprot.skip(ftype)
16508 
      else:
16509 
        iprot.skip(ftype)
16510 
      iprot.readFieldEnd()
16511 
    iprot.readStructEnd()
16512 
 
16513 
  def write(self, oprot):
16514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16516 
      return
16517 
    oprot.writeStructBegin('getStorePricings_args')
16518 
    if self.itemIds is not None:
16519 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16520 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
16521 
      for iter313 in self.itemIds:
16522 
        oprot.writeI64(iter313)
16523 
      oprot.writeListEnd()
16524 
      oprot.writeFieldEnd()
16525 
    oprot.writeFieldStop()
16526 
    oprot.writeStructEnd()
16527 
 
16528 
  def validate(self):
16529 
    return
16530 
 
16531 
 
16532 
  def __repr__(self):
16533 
    L = ['%s=%r' % (key, value)
16534 
      for key, value in self.__dict__.iteritems()]
16535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16536 
 
16537 
  def __eq__(self, other):
16538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16539 
 
16540 
  def __ne__(self, other):
16541 
    return not (self == other)
16542 
 
16543 
class getStorePricings_result:
16544 
  """
16545 
  Attributes:
16546 
   - success
16547 
  """
16548 
 
16549 
  thrift_spec = (
16550 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16551 
  )
16552 
 
16553 
  def __init__(self, success=None,):
16554 
    self.success = success
16555 
 
16556 
  def read(self, iprot):
16557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16559 
      return
16560 
    iprot.readStructBegin()
16561 
    while True:
16562 
      (fname, ftype, fid) = iprot.readFieldBegin()
16563 
      if ftype == TType.STOP:
16564 
        break
16565 
      if fid == 0:
16566 
        if ftype == TType.LIST:
16567 
          self.success = []
16568 
          (_etype317, _size314) = iprot.readListBegin()
16569 
          for _i318 in xrange(_size314):
16570 
            _elem319 = StorePricing()
16571 
            _elem319.read(iprot)
16572 
            self.success.append(_elem319)
16573 
          iprot.readListEnd()
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      else:
16577 
        iprot.skip(ftype)
16578 
      iprot.readFieldEnd()
16579 
    iprot.readStructEnd()
16580 
 
16581 
  def write(self, oprot):
16582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16584 
      return
16585 
    oprot.writeStructBegin('getStorePricings_result')
16586 
    if self.success is not None:
16587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16588 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
16589 
      for iter320 in self.success:
16590 
        iter320.write(oprot)
16591 
      oprot.writeListEnd()
16592 
      oprot.writeFieldEnd()
16593 
    oprot.writeFieldStop()
16594 
    oprot.writeStructEnd()
16595 
 
16596 
  def validate(self):
16597 
    return
16598 
 
16599 
 
16600 
  def __repr__(self):
16601 
    L = ['%s=%r' % (key, value)
16602 
      for key, value in self.__dict__.iteritems()]
16603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16604 
 
16605 
  def __eq__(self, other):
16606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16607 
 
16608 
  def __ne__(self, other):
16609 
    return not (self == other)
16610 
 
7265 rajveer 16611 
class updateStorePricing_args:
16612 
  """
16613 
  Attributes:
16614 
   - sp
16615 
  """
16616 
 
16617 
  thrift_spec = (
16618 
    None, # 0
16619 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
16620 
  )
16621 
 
16622 
  def __init__(self, sp=None,):
16623 
    self.sp = sp
16624 
 
16625 
  def read(self, iprot):
16626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16628 
      return
16629 
    iprot.readStructBegin()
16630 
    while True:
16631 
      (fname, ftype, fid) = iprot.readFieldBegin()
16632 
      if ftype == TType.STOP:
16633 
        break
16634 
      if fid == 1:
16635 
        if ftype == TType.STRUCT:
16636 
          self.sp = StorePricing()
16637 
          self.sp.read(iprot)
16638 
        else:
16639 
          iprot.skip(ftype)
16640 
      else:
16641 
        iprot.skip(ftype)
16642 
      iprot.readFieldEnd()
16643 
    iprot.readStructEnd()
16644 
 
16645 
  def write(self, oprot):
16646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16648 
      return
16649 
    oprot.writeStructBegin('updateStorePricing_args')
16650 
    if self.sp is not None:
16651 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16652 
      self.sp.write(oprot)
16653 
      oprot.writeFieldEnd()
16654 
    oprot.writeFieldStop()
16655 
    oprot.writeStructEnd()
16656 
 
16657 
  def validate(self):
16658 
    return
16659 
 
16660 
 
16661 
  def __repr__(self):
16662 
    L = ['%s=%r' % (key, value)
16663 
      for key, value in self.__dict__.iteritems()]
16664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16665 
 
16666 
  def __eq__(self, other):
16667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16668 
 
16669 
  def __ne__(self, other):
16670 
    return not (self == other)
16671 
 
16672 
class updateStorePricing_result:
16673 
 
16674 
  thrift_spec = (
16675 
  )
16676 
 
16677 
  def read(self, iprot):
16678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16680 
      return
16681 
    iprot.readStructBegin()
16682 
    while True:
16683 
      (fname, ftype, fid) = iprot.readFieldBegin()
16684 
      if ftype == TType.STOP:
16685 
        break
16686 
      else:
16687 
        iprot.skip(ftype)
16688 
      iprot.readFieldEnd()
16689 
    iprot.readStructEnd()
16690 
 
16691 
  def write(self, oprot):
16692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16694 
      return
16695 
    oprot.writeStructBegin('updateStorePricing_result')
16696 
    oprot.writeFieldStop()
16697 
    oprot.writeStructEnd()
16698 
 
16699 
  def validate(self):
16700 
    return
16701 
 
16702 
 
16703 
  def __repr__(self):
16704 
    L = ['%s=%r' % (key, value)
16705 
      for key, value in self.__dict__.iteritems()]
16706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16707 
 
16708 
  def __eq__(self, other):
16709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16710 
 
16711 
  def __ne__(self, other):
16712 
    return not (self == other)
7281 kshitij.so 16713 
 
16714 
class getAllAmazonListedItems_args:
16715 
 
16716 
  thrift_spec = (
16717 
  )
16718 
 
16719 
  def read(self, iprot):
16720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16722 
      return
16723 
    iprot.readStructBegin()
16724 
    while True:
16725 
      (fname, ftype, fid) = iprot.readFieldBegin()
16726 
      if ftype == TType.STOP:
16727 
        break
16728 
      else:
16729 
        iprot.skip(ftype)
16730 
      iprot.readFieldEnd()
16731 
    iprot.readStructEnd()
16732 
 
16733 
  def write(self, oprot):
16734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16736 
      return
16737 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
16738 
    oprot.writeFieldStop()
16739 
    oprot.writeStructEnd()
16740 
 
16741 
  def validate(self):
16742 
    return
16743 
 
16744 
 
16745 
  def __repr__(self):
16746 
    L = ['%s=%r' % (key, value)
16747 
      for key, value in self.__dict__.iteritems()]
16748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16749 
 
16750 
  def __eq__(self, other):
16751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16752 
 
16753 
  def __ne__(self, other):
16754 
    return not (self == other)
16755 
 
16756 
class getAllAmazonListedItems_result:
16757 
  """
16758 
  Attributes:
16759 
   - success
16760 
  """
16761 
 
16762 
  thrift_spec = (
16763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
16764 
  )
16765 
 
16766 
  def __init__(self, success=None,):
16767 
    self.success = success
16768 
 
16769 
  def read(self, iprot):
16770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16772 
      return
16773 
    iprot.readStructBegin()
16774 
    while True:
16775 
      (fname, ftype, fid) = iprot.readFieldBegin()
16776 
      if ftype == TType.STOP:
16777 
        break
16778 
      if fid == 0:
16779 
        if ftype == TType.LIST:
16780 
          self.success = []
7306 rajveer 16781 
          (_etype324, _size321) = iprot.readListBegin()
16782 
          for _i325 in xrange(_size321):
16783 
            _elem326 = Amazonlisted()
16784 
            _elem326.read(iprot)
16785 
            self.success.append(_elem326)
7281 kshitij.so 16786 
          iprot.readListEnd()
16787 
        else:
16788 
          iprot.skip(ftype)
16789 
      else:
16790 
        iprot.skip(ftype)
16791 
      iprot.readFieldEnd()
16792 
    iprot.readStructEnd()
16793 
 
16794 
  def write(self, oprot):
16795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16797 
      return
16798 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
16799 
    if self.success is not None:
16800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 16802 
      for iter327 in self.success:
16803 
        iter327.write(oprot)
7281 kshitij.so 16804 
      oprot.writeListEnd()
16805 
      oprot.writeFieldEnd()
16806 
    oprot.writeFieldStop()
16807 
    oprot.writeStructEnd()
16808 
 
16809 
  def validate(self):
16810 
    return
16811 
 
16812 
 
16813 
  def __repr__(self):
16814 
    L = ['%s=%r' % (key, value)
16815 
      for key, value in self.__dict__.iteritems()]
16816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16817 
 
16818 
  def __eq__(self, other):
16819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16820 
 
16821 
  def __ne__(self, other):
16822 
    return not (self == other)
16823 
 
16824 
class getAmazonItemDetails_args:
16825 
  """
16826 
  Attributes:
16827 
   - itemId
16828 
  """
16829 
 
16830 
  thrift_spec = (
16831 
    None, # 0
16832 
    (1, TType.I64, 'itemId', None, None, ), # 1
16833 
  )
16834 
 
16835 
  def __init__(self, itemId=None,):
16836 
    self.itemId = itemId
16837 
 
16838 
  def read(self, iprot):
16839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16841 
      return
16842 
    iprot.readStructBegin()
16843 
    while True:
16844 
      (fname, ftype, fid) = iprot.readFieldBegin()
16845 
      if ftype == TType.STOP:
16846 
        break
16847 
      if fid == 1:
16848 
        if ftype == TType.I64:
16849 
          self.itemId = iprot.readI64();
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      else:
16853 
        iprot.skip(ftype)
16854 
      iprot.readFieldEnd()
16855 
    iprot.readStructEnd()
16856 
 
16857 
  def write(self, oprot):
16858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16860 
      return
16861 
    oprot.writeStructBegin('getAmazonItemDetails_args')
16862 
    if self.itemId is not None:
16863 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16864 
      oprot.writeI64(self.itemId)
16865 
      oprot.writeFieldEnd()
16866 
    oprot.writeFieldStop()
16867 
    oprot.writeStructEnd()
16868 
 
16869 
  def validate(self):
16870 
    return
16871 
 
16872 
 
16873 
  def __repr__(self):
16874 
    L = ['%s=%r' % (key, value)
16875 
      for key, value in self.__dict__.iteritems()]
16876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16877 
 
16878 
  def __eq__(self, other):
16879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16880 
 
16881 
  def __ne__(self, other):
16882 
    return not (self == other)
16883 
 
16884 
class getAmazonItemDetails_result:
16885 
  """
16886 
  Attributes:
16887 
   - success
16888 
  """
16889 
 
16890 
  thrift_spec = (
16891 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
16892 
  )
16893 
 
16894 
  def __init__(self, success=None,):
16895 
    self.success = success
16896 
 
16897 
  def read(self, iprot):
16898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16900 
      return
16901 
    iprot.readStructBegin()
16902 
    while True:
16903 
      (fname, ftype, fid) = iprot.readFieldBegin()
16904 
      if ftype == TType.STOP:
16905 
        break
16906 
      if fid == 0:
16907 
        if ftype == TType.STRUCT:
16908 
          self.success = Amazonlisted()
16909 
          self.success.read(iprot)
16910 
        else:
16911 
          iprot.skip(ftype)
16912 
      else:
16913 
        iprot.skip(ftype)
16914 
      iprot.readFieldEnd()
16915 
    iprot.readStructEnd()
16916 
 
16917 
  def write(self, oprot):
16918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16920 
      return
16921 
    oprot.writeStructBegin('getAmazonItemDetails_result')
16922 
    if self.success is not None:
16923 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16924 
      self.success.write(oprot)
16925 
      oprot.writeFieldEnd()
16926 
    oprot.writeFieldStop()
16927 
    oprot.writeStructEnd()
16928 
 
16929 
  def validate(self):
16930 
    return
16931 
 
16932 
 
16933 
  def __repr__(self):
16934 
    L = ['%s=%r' % (key, value)
16935 
      for key, value in self.__dict__.iteritems()]
16936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16937 
 
16938 
  def __eq__(self, other):
16939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16940 
 
16941 
  def __ne__(self, other):
16942 
    return not (self == other)
16943 
 
16944 
class updateAmazonItemDetails_args:
16945 
  """
16946 
  Attributes:
16947 
   - itemId
16948 
   - fbaPrice
16949 
   - sellingPrice
16950 
   - isFba
16951 
   - isNonFba
16952 
   - isInventoryOverride
16953 
  """
16954 
 
16955 
  thrift_spec = (
16956 
    None, # 0
16957 
    (1, TType.I64, 'itemId', None, None, ), # 1
16958 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
16959 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
16960 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
16961 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
16962 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
16963 
  )
16964 
 
16965 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None,):
16966 
    self.itemId = itemId
16967 
    self.fbaPrice = fbaPrice
16968 
    self.sellingPrice = sellingPrice
16969 
    self.isFba = isFba
16970 
    self.isNonFba = isNonFba
16971 
    self.isInventoryOverride = isInventoryOverride
16972 
 
16973 
  def read(self, iprot):
16974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16976 
      return
16977 
    iprot.readStructBegin()
16978 
    while True:
16979 
      (fname, ftype, fid) = iprot.readFieldBegin()
16980 
      if ftype == TType.STOP:
16981 
        break
16982 
      if fid == 1:
16983 
        if ftype == TType.I64:
16984 
          self.itemId = iprot.readI64();
16985 
        else:
16986 
          iprot.skip(ftype)
16987 
      elif fid == 2:
16988 
        if ftype == TType.DOUBLE:
16989 
          self.fbaPrice = iprot.readDouble();
16990 
        else:
16991 
          iprot.skip(ftype)
16992 
      elif fid == 3:
16993 
        if ftype == TType.DOUBLE:
16994 
          self.sellingPrice = iprot.readDouble();
16995 
        else:
16996 
          iprot.skip(ftype)
16997 
      elif fid == 4:
16998 
        if ftype == TType.BOOL:
16999 
          self.isFba = iprot.readBool();
17000 
        else:
17001 
          iprot.skip(ftype)
17002 
      elif fid == 5:
17003 
        if ftype == TType.BOOL:
17004 
          self.isNonFba = iprot.readBool();
17005 
        else:
17006 
          iprot.skip(ftype)
17007 
      elif fid == 6:
17008 
        if ftype == TType.BOOL:
17009 
          self.isInventoryOverride = iprot.readBool();
17010 
        else:
17011 
          iprot.skip(ftype)
17012 
      else:
17013 
        iprot.skip(ftype)
17014 
      iprot.readFieldEnd()
17015 
    iprot.readStructEnd()
17016 
 
17017 
  def write(self, oprot):
17018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17020 
      return
17021 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17022 
    if self.itemId is not None:
17023 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17024 
      oprot.writeI64(self.itemId)
17025 
      oprot.writeFieldEnd()
17026 
    if self.fbaPrice is not None:
17027 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17028 
      oprot.writeDouble(self.fbaPrice)
17029 
      oprot.writeFieldEnd()
17030 
    if self.sellingPrice is not None:
17031 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17032 
      oprot.writeDouble(self.sellingPrice)
17033 
      oprot.writeFieldEnd()
17034 
    if self.isFba is not None:
17035 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17036 
      oprot.writeBool(self.isFba)
17037 
      oprot.writeFieldEnd()
17038 
    if self.isNonFba is not None:
17039 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17040 
      oprot.writeBool(self.isNonFba)
17041 
      oprot.writeFieldEnd()
17042 
    if self.isInventoryOverride is not None:
17043 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17044 
      oprot.writeBool(self.isInventoryOverride)
17045 
      oprot.writeFieldEnd()
17046 
    oprot.writeFieldStop()
17047 
    oprot.writeStructEnd()
17048 
 
17049 
  def validate(self):
17050 
    return
17051 
 
17052 
 
17053 
  def __repr__(self):
17054 
    L = ['%s=%r' % (key, value)
17055 
      for key, value in self.__dict__.iteritems()]
17056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17057 
 
17058 
  def __eq__(self, other):
17059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17060 
 
17061 
  def __ne__(self, other):
17062 
    return not (self == other)
17063 
 
17064 
class updateAmazonItemDetails_result:
17065 
 
17066 
  thrift_spec = (
17067 
  )
17068 
 
17069 
  def read(self, iprot):
17070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17072 
      return
17073 
    iprot.readStructBegin()
17074 
    while True:
17075 
      (fname, ftype, fid) = iprot.readFieldBegin()
17076 
      if ftype == TType.STOP:
17077 
        break
17078 
      else:
17079 
        iprot.skip(ftype)
17080 
      iprot.readFieldEnd()
17081 
    iprot.readStructEnd()
17082 
 
17083 
  def write(self, oprot):
17084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17086 
      return
17087 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17088 
    oprot.writeFieldStop()
17089 
    oprot.writeStructEnd()
17090 
 
17091 
  def validate(self):
17092 
    return
17093 
 
17094 
 
17095 
  def __repr__(self):
17096 
    L = ['%s=%r' % (key, value)
17097 
      for key, value in self.__dict__.iteritems()]
17098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17099 
 
17100 
  def __eq__(self, other):
17101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17102 
 
17103 
  def __ne__(self, other):
17104 
    return not (self == other)
17105 
 
17106 
class addAmazonItem_args:
17107 
  """
17108 
  Attributes:
17109 
   - amazonlisted
17110 
  """
17111 
 
17112 
  thrift_spec = (
17113 
    None, # 0
17114 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17115 
  )
17116 
 
17117 
  def __init__(self, amazonlisted=None,):
17118 
    self.amazonlisted = amazonlisted
17119 
 
17120 
  def read(self, iprot):
17121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17123 
      return
17124 
    iprot.readStructBegin()
17125 
    while True:
17126 
      (fname, ftype, fid) = iprot.readFieldBegin()
17127 
      if ftype == TType.STOP:
17128 
        break
17129 
      if fid == 1:
17130 
        if ftype == TType.STRUCT:
17131 
          self.amazonlisted = Amazonlisted()
17132 
          self.amazonlisted.read(iprot)
17133 
        else:
17134 
          iprot.skip(ftype)
17135 
      else:
17136 
        iprot.skip(ftype)
17137 
      iprot.readFieldEnd()
17138 
    iprot.readStructEnd()
17139 
 
17140 
  def write(self, oprot):
17141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17143 
      return
17144 
    oprot.writeStructBegin('addAmazonItem_args')
17145 
    if self.amazonlisted is not None:
17146 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17147 
      self.amazonlisted.write(oprot)
17148 
      oprot.writeFieldEnd()
17149 
    oprot.writeFieldStop()
17150 
    oprot.writeStructEnd()
17151 
 
17152 
  def validate(self):
17153 
    return
17154 
 
17155 
 
17156 
  def __repr__(self):
17157 
    L = ['%s=%r' % (key, value)
17158 
      for key, value in self.__dict__.iteritems()]
17159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17160 
 
17161 
  def __eq__(self, other):
17162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17163 
 
17164 
  def __ne__(self, other):
17165 
    return not (self == other)
17166 
 
17167 
class addAmazonItem_result:
17168 
 
17169 
  thrift_spec = (
17170 
  )
17171 
 
17172 
  def read(self, iprot):
17173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17175 
      return
17176 
    iprot.readStructBegin()
17177 
    while True:
17178 
      (fname, ftype, fid) = iprot.readFieldBegin()
17179 
      if ftype == TType.STOP:
17180 
        break
17181 
      else:
17182 
        iprot.skip(ftype)
17183 
      iprot.readFieldEnd()
17184 
    iprot.readStructEnd()
17185 
 
17186 
  def write(self, oprot):
17187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17189 
      return
17190 
    oprot.writeStructBegin('addAmazonItem_result')
17191 
    oprot.writeFieldStop()
17192 
    oprot.writeStructEnd()
17193 
 
17194 
  def validate(self):
17195 
    return
17196 
 
17197 
 
17198 
  def __repr__(self):
17199 
    L = ['%s=%r' % (key, value)
17200 
      for key, value in self.__dict__.iteritems()]
17201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17202 
 
17203 
  def __eq__(self, other):
17204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17205 
 
17206 
  def __ne__(self, other):
17207 
    return not (self == other)
7291 vikram.rag 17208 
 
17209 
class getAsinItems_args:
17210 
 
17211 
  thrift_spec = (
17212 
  )
17213 
 
17214 
  def read(self, iprot):
17215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17217 
      return
17218 
    iprot.readStructBegin()
17219 
    while True:
17220 
      (fname, ftype, fid) = iprot.readFieldBegin()
17221 
      if ftype == TType.STOP:
17222 
        break
17223 
      else:
17224 
        iprot.skip(ftype)
17225 
      iprot.readFieldEnd()
17226 
    iprot.readStructEnd()
17227 
 
17228 
  def write(self, oprot):
17229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17231 
      return
17232 
    oprot.writeStructBegin('getAsinItems_args')
17233 
    oprot.writeFieldStop()
17234 
    oprot.writeStructEnd()
17235 
 
17236 
  def validate(self):
17237 
    return
17238 
 
17239 
 
17240 
  def __repr__(self):
17241 
    L = ['%s=%r' % (key, value)
17242 
      for key, value in self.__dict__.iteritems()]
17243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17244 
 
17245 
  def __eq__(self, other):
17246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17247 
 
17248 
  def __ne__(self, other):
17249 
    return not (self == other)
17250 
 
17251 
class getAsinItems_result:
17252 
  """
17253 
  Attributes:
17254 
   - success
17255 
  """
17256 
 
17257 
  thrift_spec = (
17258 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17259 
  )
17260 
 
17261 
  def __init__(self, success=None,):
17262 
    self.success = success
17263 
 
17264 
  def read(self, iprot):
17265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17267 
      return
17268 
    iprot.readStructBegin()
17269 
    while True:
17270 
      (fname, ftype, fid) = iprot.readFieldBegin()
17271 
      if ftype == TType.STOP:
17272 
        break
17273 
      if fid == 0:
17274 
        if ftype == TType.LIST:
17275 
          self.success = []
7306 rajveer 17276 
          (_etype331, _size328) = iprot.readListBegin()
17277 
          for _i332 in xrange(_size328):
17278 
            _elem333 = Item()
17279 
            _elem333.read(iprot)
17280 
            self.success.append(_elem333)
7291 vikram.rag 17281 
          iprot.readListEnd()
17282 
        else:
17283 
          iprot.skip(ftype)
17284 
      else:
17285 
        iprot.skip(ftype)
17286 
      iprot.readFieldEnd()
17287 
    iprot.readStructEnd()
17288 
 
17289 
  def write(self, oprot):
17290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17292 
      return
17293 
    oprot.writeStructBegin('getAsinItems_result')
17294 
    if self.success is not None:
17295 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17296 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17297 
      for iter334 in self.success:
17298 
        iter334.write(oprot)
7291 vikram.rag 17299 
      oprot.writeListEnd()
17300 
      oprot.writeFieldEnd()
17301 
    oprot.writeFieldStop()
17302 
    oprot.writeStructEnd()
17303 
 
17304 
  def validate(self):
17305 
    return
17306 
 
17307 
 
17308 
  def __repr__(self):
17309 
    L = ['%s=%r' % (key, value)
17310 
      for key, value in self.__dict__.iteritems()]
17311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17312 
 
17313 
  def __eq__(self, other):
17314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17315 
 
17316 
  def __ne__(self, other):
17317 
    return not (self == other)
17318 
 
17319 
class getAllFbaListedItems_args:
17320 
 
17321 
  thrift_spec = (
17322 
  )
17323 
 
17324 
  def read(self, iprot):
17325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17327 
      return
17328 
    iprot.readStructBegin()
17329 
    while True:
17330 
      (fname, ftype, fid) = iprot.readFieldBegin()
17331 
      if ftype == TType.STOP:
17332 
        break
17333 
      else:
17334 
        iprot.skip(ftype)
17335 
      iprot.readFieldEnd()
17336 
    iprot.readStructEnd()
17337 
 
17338 
  def write(self, oprot):
17339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17341 
      return
17342 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17343 
    oprot.writeFieldStop()
17344 
    oprot.writeStructEnd()
17345 
 
17346 
  def validate(self):
17347 
    return
17348 
 
17349 
 
17350 
  def __repr__(self):
17351 
    L = ['%s=%r' % (key, value)
17352 
      for key, value in self.__dict__.iteritems()]
17353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17354 
 
17355 
  def __eq__(self, other):
17356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17357 
 
17358 
  def __ne__(self, other):
17359 
    return not (self == other)
17360 
 
17361 
class getAllFbaListedItems_result:
17362 
  """
17363 
  Attributes:
17364 
   - success
17365 
  """
17366 
 
17367 
  thrift_spec = (
17368 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17369 
  )
17370 
 
17371 
  def __init__(self, success=None,):
17372 
    self.success = success
17373 
 
17374 
  def read(self, iprot):
17375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17377 
      return
17378 
    iprot.readStructBegin()
17379 
    while True:
17380 
      (fname, ftype, fid) = iprot.readFieldBegin()
17381 
      if ftype == TType.STOP:
17382 
        break
17383 
      if fid == 0:
17384 
        if ftype == TType.LIST:
17385 
          self.success = []
7306 rajveer 17386 
          (_etype338, _size335) = iprot.readListBegin()
17387 
          for _i339 in xrange(_size335):
17388 
            _elem340 = Amazonlisted()
17389 
            _elem340.read(iprot)
17390 
            self.success.append(_elem340)
7291 vikram.rag 17391 
          iprot.readListEnd()
17392 
        else:
17393 
          iprot.skip(ftype)
17394 
      else:
17395 
        iprot.skip(ftype)
17396 
      iprot.readFieldEnd()
17397 
    iprot.readStructEnd()
17398 
 
17399 
  def write(self, oprot):
17400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17402 
      return
17403 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17404 
    if self.success is not None:
17405 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17406 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17407 
      for iter341 in self.success:
17408 
        iter341.write(oprot)
7291 vikram.rag 17409 
      oprot.writeListEnd()
17410 
      oprot.writeFieldEnd()
17411 
    oprot.writeFieldStop()
17412 
    oprot.writeStructEnd()
17413 
 
17414 
  def validate(self):
17415 
    return
17416 
 
17417 
 
17418 
  def __repr__(self):
17419 
    L = ['%s=%r' % (key, value)
17420 
      for key, value in self.__dict__.iteritems()]
17421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17422 
 
17423 
  def __eq__(self, other):
17424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17425 
 
17426 
  def __ne__(self, other):
17427 
    return not (self == other)
17428 
 
17429 
class getAllNonFbaListedItems_args:
17430 
 
17431 
  thrift_spec = (
17432 
  )
17433 
 
17434 
  def read(self, iprot):
17435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17437 
      return
17438 
    iprot.readStructBegin()
17439 
    while True:
17440 
      (fname, ftype, fid) = iprot.readFieldBegin()
17441 
      if ftype == TType.STOP:
17442 
        break
17443 
      else:
17444 
        iprot.skip(ftype)
17445 
      iprot.readFieldEnd()
17446 
    iprot.readStructEnd()
17447 
 
17448 
  def write(self, oprot):
17449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17451 
      return
17452 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17453 
    oprot.writeFieldStop()
17454 
    oprot.writeStructEnd()
17455 
 
17456 
  def validate(self):
17457 
    return
17458 
 
17459 
 
17460 
  def __repr__(self):
17461 
    L = ['%s=%r' % (key, value)
17462 
      for key, value in self.__dict__.iteritems()]
17463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17464 
 
17465 
  def __eq__(self, other):
17466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17467 
 
17468 
  def __ne__(self, other):
17469 
    return not (self == other)
17470 
 
17471 
class getAllNonFbaListedItems_result:
17472 
  """
17473 
  Attributes:
17474 
   - success
17475 
  """
17476 
 
17477 
  thrift_spec = (
17478 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17479 
  )
17480 
 
17481 
  def __init__(self, success=None,):
17482 
    self.success = success
17483 
 
17484 
  def read(self, iprot):
17485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17487 
      return
17488 
    iprot.readStructBegin()
17489 
    while True:
17490 
      (fname, ftype, fid) = iprot.readFieldBegin()
17491 
      if ftype == TType.STOP:
17492 
        break
17493 
      if fid == 0:
17494 
        if ftype == TType.LIST:
17495 
          self.success = []
7306 rajveer 17496 
          (_etype345, _size342) = iprot.readListBegin()
17497 
          for _i346 in xrange(_size342):
17498 
            _elem347 = Amazonlisted()
17499 
            _elem347.read(iprot)
17500 
            self.success.append(_elem347)
7291 vikram.rag 17501 
          iprot.readListEnd()
17502 
        else:
17503 
          iprot.skip(ftype)
17504 
      else:
17505 
        iprot.skip(ftype)
17506 
      iprot.readFieldEnd()
17507 
    iprot.readStructEnd()
17508 
 
17509 
  def write(self, oprot):
17510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17512 
      return
17513 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17514 
    if self.success is not None:
17515 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17516 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7306 rajveer 17517 
      for iter348 in self.success:
17518 
        iter348.write(oprot)
7291 vikram.rag 17519 
      oprot.writeListEnd()
17520 
      oprot.writeFieldEnd()
17521 
    oprot.writeFieldStop()
17522 
    oprot.writeStructEnd()
17523 
 
17524 
  def validate(self):
17525 
    return
17526 
 
17527 
 
17528 
  def __repr__(self):
17529 
    L = ['%s=%r' % (key, value)
17530 
      for key, value in self.__dict__.iteritems()]
17531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17532 
 
17533 
  def __eq__(self, other):
17534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17535 
 
17536 
  def __ne__(self, other):
17537 
    return not (self == other)