Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
5944 mandeep.dh 1 
#
2 
# Autogenerated by Thrift Compiler (0.7.0)
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
import shop2020.thriftpy.generic.GenericService
9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol, TProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
20 
  def addItem(self, item):
21 
    """
22 
    Availability and inventory attributes
23 
 
24 
    Parameters:
25 
     - item
26 
    """
27 
    pass
28 
 
29 
  def updateItem(self, item):
30 
    """
31 
    Parameters:
32 
     - item
33 
    """
34 
    pass
35 
 
36 
  def isActive(self, itemId):
37 
    """
38 
    Checks if the item given to the corresponding itemId is active. If it's active,
39 
    whether it's risky and if it's risky, its inventory position.
40 
 
41 
    Parameters:
42 
     - itemId
43 
    """
44 
    pass
45 
 
7438 amit.gupta 46 
  def getItemsStatus(self, itemIds):
47 
    """
48 
    Parameters:
49 
     - itemIds
50 
    """
51 
    pass
52 
 
5944 mandeep.dh 53 
  def getItemStatusDescription(self, itemId):
54 
    """
55 
    Parameters:
56 
     - itemId
57 
    """
58 
    pass
59 
 
60 
  def startItemOn(self, item_id, timestamp):
61 
    """
62 
    Parameters:
63 
     - item_id
64 
     - timestamp
65 
    """
66 
    pass
67 
 
68 
  def retireItemOn(self, item_id, timestamp):
69 
    """
70 
    Parameters:
71 
     - item_id
72 
     - timestamp
73 
    """
74 
    pass
75 
 
76 
  def changeItemStatus(self, item_id, timestamp, newstatus):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
     - timestamp
81 
     - newstatus
82 
    """
83 
    pass
84 
 
85 
  def getItem(self, item_id):
86 
    """
87 
    Parameters:
88 
     - item_id
89 
    """
90 
    pass
91 
 
92 
  def getItemsByCatalogId(self, catalog_item_id):
93 
    """
94 
    Parameters:
95 
     - catalog_item_id
96 
    """
97 
    pass
98 
 
99 
  def getValidItemsByCatalogId(self, catalog_item_id):
100 
    """
101 
    Parameters:
102 
     - catalog_item_id
103 
    """
104 
    pass
105 
 
106 
  def getAllItems(self, isActive):
107 
    """
108 
    Parameters:
109 
     - isActive
110 
    """
111 
    pass
112 
 
113 
  def getAllItemsByStatus(self, itemStatus):
114 
    """
115 
    Parameters:
116 
     - itemStatus
117 
    """
118 
    pass
119 
 
120 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
121 
    """
122 
    Parameters:
123 
     - entityId
124 
     - category
125 
     - brand
126 
     - modelName
127 
     - modelNumber
128 
    """
129 
    pass
130 
 
131 
  def getAllItemsInRange(self, offset, limit):
132 
    """
133 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
134 
 
135 
    Parameters:
136 
     - offset
137 
     - limit
138 
    """
139 
    pass
140 
 
141 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
142 
    """
143 
    Gets at most 'limit' items starting at the given offset in the given status. Returns an empty list if there are no more items at the given offset.
144 
 
145 
    Parameters:
146 
     - itemStatus
147 
     - offset
148 
     - limit
149 
    """
150 
    pass
151 
 
152 
  def getItemCountByStatus(self, useStatus, itemStatus):
153 
    """
154 
    Gets a count of all items by status
155 
 
156 
    Parameters:
157 
     - useStatus
158 
     - itemStatus
159 
    """
160 
    pass
161 
 
162 
  def getBestSellers(self, ):
163 
    pass
164 
 
165 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
166 
    """
167 
    Parameters:
168 
     - beginIndex
169 
     - totalItems
170 
     - brand
171 
     - category
172 
    """
173 
    pass
174 
 
175 
  def getBestSellersCount(self, ):
176 
    pass
177 
 
178 
  def getBestDeals(self, ):
179 
    pass
180 
 
181 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
182 
    """
183 
    Parameters:
184 
     - beginIndex
185 
     - totalItems
186 
     - brand
187 
     - category
188 
    """
189 
    pass
190 
 
191 
  def getBestDealsCount(self, ):
192 
    pass
193 
 
194 
  def getComingSoon(self, ):
195 
    pass
196 
 
197 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
198 
    """
199 
    Parameters:
200 
     - beginIndex
201 
     - totalItems
202 
     - brand
203 
     - category
204 
    """
205 
    pass
206 
 
207 
  def getComingSoonCount(self, ):
208 
    pass
209 
 
210 
  def getLatestArrivals(self, ):
211 
    """
212 
    Returns a list of items sorted in the descending order by start date.
213 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
214 
    """
215 
    pass
216 
 
217 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
218 
    """
219 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
220 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
221 
 
222 
    Parameters:
223 
     - beginIndex
224 
     - totalItems
225 
     - brand
226 
     - categories
227 
    """
228 
    pass
229 
 
230 
  def getLatestArrivalsCount(self, ):
231 
    """
232 
    Get the total number of latest arrivals we are willing to show.
233 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
234 
    """
235 
    pass
236 
 
237 
  def generateNewEntityID(self, ):
238 
    pass
239 
 
240 
  def addCategory(self, category):
241 
    """
242 
    All category related functions
243 
 
244 
    Parameters:
245 
     - category
246 
    """
247 
    pass
248 
 
249 
  def getCategory(self, id):
250 
    """
251 
    Parameters:
252 
     - id
253 
    """
254 
    pass
255 
 
256 
  def getAllCategories(self, ):
257 
    pass
258 
 
259 
  def getAllSimilarItems(self, itemId):
260 
    """
261 
    Returns the list of similar items.
262 
 
263 
    Parameters:
264 
     - itemId
265 
    """
266 
    pass
267 
 
268 
  def addSimilarItem(self, itemId, catalogItemId):
269 
    """
270 
    Adds similar item.
271 
 
272 
    Parameters:
273 
     - itemId
274 
     - catalogItemId
275 
    """
276 
    pass
277 
 
6512 kshitij.so 278 
  def addTag(self, displayName, itemId):
279 
    """
280 
    Tag Related
281 
 
282 
    Parameters:
283 
     - displayName
284 
     - itemId
285 
    """
286 
    pass
287 
 
288 
  def deleteEntityTag(self, displayName, itemId):
289 
    """
290 
    Parameters:
291 
     - displayName
292 
     - itemId
293 
    """
294 
    pass
295 
 
296 
  def deleteTag(self, displayName):
297 
    """
298 
    Parameters:
299 
     - displayName
300 
    """
301 
    pass
302 
 
303 
  def getAllTags(self, ):
304 
    pass
305 
 
306 
  def getAllEntitiesByTagName(self, displayName):
307 
    """
308 
    Parameters:
309 
     - displayName
310 
    """
311 
    pass
312 
 
6845 amit.gupta 313 
  def getAllEntityTags(self, ):
314 
    pass
315 
 
6850 kshitij.so 316 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
317 
    """
318 
    Parameters:
319 
     - bannerName
320 
     - imageName
321 
     - link
322 
     - priority
323 
     - isActive
324 
     - hasMap
325 
    """
326 
    pass
327 
 
328 
  def getAllBanners(self, ):
329 
    pass
330 
 
331 
  def deleteBanner(self, bannerName):
332 
    """
333 
    Parameters:
334 
     - bannerName
335 
    """
336 
    pass
337 
 
338 
  def getBannerDetails(self, bannerName):
339 
    """
340 
    Parameters:
341 
     - bannerName
342 
    """
343 
    pass
344 
 
345 
  def getActiveBanners(self, ):
346 
    pass
347 
 
6849 kshitij.so 348 
  def addBannerMap(self, bannerName, mapLink, coordinates):
349 
    """
350 
    Parameters:
351 
     - bannerName
352 
     - mapLink
353 
     - coordinates
354 
    """
355 
    pass
356 
 
357 
  def deleteBannerMap(self, bannerName):
358 
    """
359 
    Parameters:
360 
     - bannerName
361 
    """
362 
    pass
363 
 
364 
  def getBannerMapDetails(self, bannerName):
365 
    """
366 
    Parameters:
367 
     - bannerName
368 
    """
369 
    pass
370 
 
5944 mandeep.dh 371 
  def deleteSimilarItem(self, itemId, catalogItemId):
372 
    """
373 
    Delete similar item.
374 
 
375 
    Parameters:
376 
     - itemId
377 
     - catalogItemId
378 
    """
379 
    pass
380 
 
381 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
382 
    """
383 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
384 
    If yes, returns the itemId else returns 0
385 
 
386 
    Parameters:
387 
     - brand
388 
     - modelNumber
389 
     - modelName
390 
     - color
391 
    """
392 
    pass
393 
 
394 
  def validateRiskyStatus(self, itemId):
395 
    """
396 
    Check wether item is risky and change status if inventory is not available for risky items
397 
 
398 
    Parameters:
399 
     - itemId
400 
    """
401 
    pass
402 
 
403 
  def changeItemRiskyFlag(self, itemId, risky):
404 
    """
405 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
406 
 
407 
    Parameters:
408 
     - itemId
409 
     - risky
410 
    """
411 
    pass
412 
 
413 
  def getItemsByRiskyFlag(self, ):
414 
    """
415 
    Returns list of items marked as risky.
416 
    """
417 
    pass
418 
 
419 
  def getItemsForMasterSheet(self, category, brand):
420 
    """
421 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
422 
 
423 
    Parameters:
424 
     - category
425 
     - brand
426 
    """
427 
    pass
428 
 
429 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
430 
    """
431 
    Returns list of catalog ids of items with same similarity index as of the given itemId
432 
 
433 
    Parameters:
434 
     - beginIndex
435 
     - totalItems
436 
     - itemId
437 
    """
438 
    pass
439 
 
440 
  def addProductNotification(self, itemId, email):
441 
    """
442 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
443 
 
444 
    Parameters:
445 
     - itemId
446 
     - email
447 
    """
448 
    pass
449 
 
450 
  def sendProductNotifications(self, ):
451 
    """
452 
    Send the product notifications to the users for items which has stock.
453 
    """
454 
    pass
455 
 
456 
  def getAllBrandsByCategory(self, categoryId):
457 
    """
458 
    Returns list of brand names for a given category Id
459 
 
460 
    Parameters:
461 
     - categoryId
462 
    """
463 
    pass
464 
 
465 
  def getAllBrands(self, ):
466 
    """
467 
    Returns list of brand names
468 
    """
469 
    pass
470 
 
471 
  def getAllSources(self, ):
472 
    """
473 
    Return list of all sources
474 
    """
475 
    pass
476 
 
477 
  def getItemPricingBySource(self, itemId, sourceId):
478 
    """
479 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
480 
 
481 
    Parameters:
482 
     - itemId
483 
     - sourceId
484 
    """
485 
    pass
486 
 
487 
  def addSourceItemPricing(self, sourceItemPricing):
488 
    """
489 
    Adds prices to be displayed corresponding to the item if user comes from a source.
490 
    If item is not found or source is not found, it will throw exception.
491 
 
492 
    Parameters:
493 
     - sourceItemPricing
494 
    """
495 
    pass
496 
 
497 
  def getAllSourcePricing(self, itemId):
498 
    """
499 
    Returns the list of source pricing information of an item.
500 
    Raises an exception if item not found corresponding to itemId
501 
 
502 
    Parameters:
503 
     - itemId
504 
    """
505 
    pass
506 
 
507 
  def getItemForSource(self, item_id, sourceId):
508 
    """
509 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
510 
 
511 
    Parameters:
512 
     - item_id
513 
     - sourceId
514 
    """
515 
    pass
516 
 
517 
  def searchItemsInRange(self, searchTerms, offset, limit):
518 
    """
519 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
520 
 
521 
    Parameters:
522 
     - searchTerms
523 
     - offset
524 
     - limit
525 
    """
526 
    pass
527 
 
528 
  def getSearchResultCount(self, searchTerms):
529 
    """
530 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
531 
 
532 
    Parameters:
533 
     - searchTerms
534 
    """
535 
    pass
536 
 
537 
  def getProductNotifications(self, startDateTime):
538 
    """
539 
    Returns a list of product notifications added after a supplied datetime
540 
 
541 
    Parameters:
542 
     - startDateTime
543 
    """
544 
    pass
545 
 
546 
  def getProductNotificationRequestCount(self, startDateTime):
547 
    """
548 
    Returns a list of count of requests for product notification against each item
549 
 
550 
    Parameters:
551 
     - startDateTime
552 
    """
553 
    pass
554 
 
555 
  def addAuthorizationLog(self, itemId, username, reason):
556 
    """
557 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
558 
 
559 
    Parameters:
560 
     - itemId
561 
     - username
562 
     - reason
563 
    """
564 
    pass
565 
 
566 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
567 
    """
568 
    Parameters:
569 
     - catalog_item_id
570 
     - voucherType
571 
     - voucherAmount
572 
    """
573 
    pass
574 
 
575 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
576 
    """
577 
    Parameters:
578 
     - catalog_item_id
579 
     - voucherType
580 
    """
581 
    pass
582 
 
583 
  def getVoucherAmount(self, itemId, voucherType):
584 
    """
585 
    Parameters:
586 
     - itemId
587 
     - voucherType
588 
    """
589 
    pass
590 
 
591 
  def getAllItemVouchers(self, itemId):
592 
    """
593 
    Parameters:
594 
     - itemId
595 
    """
596 
    pass
597 
 
598 
  def isValidCatalogItemId(self, catalog_item_id):
599 
    """
600 
    Parameters:
601 
     - catalog_item_id
602 
    """
603 
    pass
604 
 
7330 amit.gupta 605 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 606 
    """
607 
    Parameters:
608 
     - itemId
7330 amit.gupta 609 
     - stateId
6039 amit.gupta 610 
     - price
611 
    """
612 
    pass
5944 mandeep.dh 613 
 
6039 amit.gupta 614 
  def getVatAmountForItem(self, itemId, price):
615 
    """
616 
    Parameters:
617 
     - itemId
618 
     - price
619 
    """
620 
    pass
621 
 
6531 vikram.rag 622 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
623 
    """
624 
    Parameters:
625 
     - offset
626 
     - limit
627 
    """
628 
    pass
6039 amit.gupta 629 
 
6821 amar.kumar 630 
  def getAllAliveItems(self, ):
631 
    pass
632 
 
6921 anupam.sin 633 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 634 
    """
635 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 636 
 
6805 anupam.sin 637 
    Parameters:
638 
     - itemId
6921 anupam.sin 639 
     - price
6805 anupam.sin 640 
     - insurerId
641 
     - quantity
642 
    """
643 
    pass
644 
 
645 
  def getInsurer(self, insurerId):
646 
    """
647 
    Parameters:
648 
     - insurerId
649 
    """
650 
    pass
651 
 
6838 vikram.rag 652 
  def getAllInsurers(self, ):
653 
    pass
6805 anupam.sin 654 
 
6962 rajveer 655 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
656 
    """
657 
    Parameters:
658 
     - insurerId
659 
     - amount
660 
    """
661 
    pass
6838 vikram.rag 662 
 
7190 amar.kumar 663 
  def getFreebieForItem(self, itemId):
664 
    """
665 
    Parameters:
666 
     - itemId
667 
    """
668 
    pass
6962 rajveer 669 
 
7190 amar.kumar 670 
  def addOrUpdateFreebieForItem(self, freebieItem):
671 
    """
672 
    Parameters:
673 
     - freebieItem
674 
    """
675 
    pass
676 
 
7272 amit.gupta 677 
  def addOrUpdateBrandInfo(self, brandInfo):
678 
    """
679 
    Parameters:
680 
     - brandInfo
681 
    """
682 
    pass
683 
 
684 
  def getBrandInfo(self, ):
685 
    pass
686 
 
7256 rajveer 687 
  def getStorePricing(self, itemId):
688 
    """
689 
    Parameters:
690 
     - itemId
691 
    """
692 
    pass
7190 amar.kumar 693 
 
7306 rajveer 694 
  def getStorePricings(self, itemIds):
695 
    """
696 
    Parameters:
697 
     - itemIds
698 
    """
699 
    pass
700 
 
7382 rajveer 701 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 702 
    """
703 
    Parameters:
704 
     - sp
7382 rajveer 705 
     - allColors
7265 rajveer 706 
    """
707 
    pass
7256 rajveer 708 
 
7281 kshitij.so 709 
  def getAllAmazonListedItems(self, ):
710 
    pass
7265 rajveer 711 
 
7281 kshitij.so 712 
  def getAmazonItemDetails(self, itemId):
713 
    """
714 
    Parameters:
715 
     - itemId
716 
    """
717 
    pass
718 
 
7367 kshitij.so 719 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 720 
    """
721 
    Parameters:
722 
     - itemId
723 
     - fbaPrice
724 
     - sellingPrice
725 
     - isFba
726 
     - isNonFba
727 
     - isInventoryOverride
7367 kshitij.so 728 
     - handlingTime
729 
     - isCustomTime
7281 kshitij.so 730 
    """
731 
    pass
732 
 
733 
  def addAmazonItem(self, amazonlisted):
734 
    """
735 
    Parameters:
736 
     - amazonlisted
737 
    """
738 
    pass
739 
 
7291 vikram.rag 740 
  def getAsinItems(self, ):
741 
    pass
7281 kshitij.so 742 
 
7291 vikram.rag 743 
  def getAllFbaListedItems(self, ):
744 
    pass
745 
 
746 
  def getAllNonFbaListedItems(self, ):
747 
    pass
748 
 
7460 kshitij.so 749 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
750 
    """
751 
    Parameters:
752 
     - itemId
753 
     - holdInventory
754 
     - defaultInventory
755 
    """
756 
    pass
7291 vikram.rag 757 
 
7460 kshitij.so 758 
 
5944 mandeep.dh 759 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
760 
  def __init__(self, iprot, oprot=None):
761 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
762 
 
763 
  def addItem(self, item):
764 
    """
765 
    Availability and inventory attributes
766 
 
767 
    Parameters:
768 
     - item
769 
    """
770 
    self.send_addItem(item)
771 
    return self.recv_addItem()
772 
 
773 
  def send_addItem(self, item):
774 
    self._oprot.writeMessageBegin('addItem', TMessageType.CALL, self._seqid)
775 
    args = addItem_args()
776 
    args.item = item
777 
    args.write(self._oprot)
778 
    self._oprot.writeMessageEnd()
779 
    self._oprot.trans.flush()
780 
 
781 
  def recv_addItem(self, ):
782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
783 
    if mtype == TMessageType.EXCEPTION:
784 
      x = TApplicationException()
785 
      x.read(self._iprot)
786 
      self._iprot.readMessageEnd()
787 
      raise x
788 
    result = addItem_result()
789 
    result.read(self._iprot)
790 
    self._iprot.readMessageEnd()
791 
    if result.success is not None:
792 
      return result.success
793 
    if result.cex is not None:
794 
      raise result.cex
795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItem failed: unknown result");
796 
 
797 
  def updateItem(self, item):
798 
    """
799 
    Parameters:
800 
     - item
801 
    """
802 
    self.send_updateItem(item)
803 
    return self.recv_updateItem()
804 
 
805 
  def send_updateItem(self, item):
806 
    self._oprot.writeMessageBegin('updateItem', TMessageType.CALL, self._seqid)
807 
    args = updateItem_args()
808 
    args.item = item
809 
    args.write(self._oprot)
810 
    self._oprot.writeMessageEnd()
811 
    self._oprot.trans.flush()
812 
 
813 
  def recv_updateItem(self, ):
814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
815 
    if mtype == TMessageType.EXCEPTION:
816 
      x = TApplicationException()
817 
      x.read(self._iprot)
818 
      self._iprot.readMessageEnd()
819 
      raise x
820 
    result = updateItem_result()
821 
    result.read(self._iprot)
822 
    self._iprot.readMessageEnd()
823 
    if result.success is not None:
824 
      return result.success
825 
    if result.cex is not None:
826 
      raise result.cex
827 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItem failed: unknown result");
828 
 
829 
  def isActive(self, itemId):
830 
    """
831 
    Checks if the item given to the corresponding itemId is active. If it's active,
832 
    whether it's risky and if it's risky, its inventory position.
833 
 
834 
    Parameters:
835 
     - itemId
836 
    """
837 
    self.send_isActive(itemId)
838 
    return self.recv_isActive()
839 
 
840 
  def send_isActive(self, itemId):
841 
    self._oprot.writeMessageBegin('isActive', TMessageType.CALL, self._seqid)
842 
    args = isActive_args()
843 
    args.itemId = itemId
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_isActive(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = isActive_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
858 
    if result.success is not None:
859 
      return result.success
860 
    if result.isex is not None:
861 
      raise result.isex
862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isActive failed: unknown result");
863 
 
7438 amit.gupta 864 
  def getItemsStatus(self, itemIds):
865 
    """
866 
    Parameters:
867 
     - itemIds
868 
    """
869 
    self.send_getItemsStatus(itemIds)
870 
    return self.recv_getItemsStatus()
871 
 
872 
  def send_getItemsStatus(self, itemIds):
873 
    self._oprot.writeMessageBegin('getItemsStatus', TMessageType.CALL, self._seqid)
874 
    args = getItemsStatus_args()
875 
    args.itemIds = itemIds
876 
    args.write(self._oprot)
877 
    self._oprot.writeMessageEnd()
878 
    self._oprot.trans.flush()
879 
 
880 
  def recv_getItemsStatus(self, ):
881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
882 
    if mtype == TMessageType.EXCEPTION:
883 
      x = TApplicationException()
884 
      x.read(self._iprot)
885 
      self._iprot.readMessageEnd()
886 
      raise x
887 
    result = getItemsStatus_result()
888 
    result.read(self._iprot)
889 
    self._iprot.readMessageEnd()
890 
    if result.success is not None:
891 
      return result.success
892 
    if result.isex is not None:
893 
      raise result.isex
894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsStatus failed: unknown result");
895 
 
5944 mandeep.dh 896 
  def getItemStatusDescription(self, itemId):
897 
    """
898 
    Parameters:
899 
     - itemId
900 
    """
901 
    self.send_getItemStatusDescription(itemId)
902 
    return self.recv_getItemStatusDescription()
903 
 
904 
  def send_getItemStatusDescription(self, itemId):
905 
    self._oprot.writeMessageBegin('getItemStatusDescription', TMessageType.CALL, self._seqid)
906 
    args = getItemStatusDescription_args()
907 
    args.itemId = itemId
908 
    args.write(self._oprot)
909 
    self._oprot.writeMessageEnd()
910 
    self._oprot.trans.flush()
911 
 
912 
  def recv_getItemStatusDescription(self, ):
913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
914 
    if mtype == TMessageType.EXCEPTION:
915 
      x = TApplicationException()
916 
      x.read(self._iprot)
917 
      self._iprot.readMessageEnd()
918 
      raise x
919 
    result = getItemStatusDescription_result()
920 
    result.read(self._iprot)
921 
    self._iprot.readMessageEnd()
922 
    if result.success is not None:
923 
      return result.success
924 
    if result.isex is not None:
925 
      raise result.isex
926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStatusDescription failed: unknown result");
927 
 
928 
  def startItemOn(self, item_id, timestamp):
929 
    """
930 
    Parameters:
931 
     - item_id
932 
     - timestamp
933 
    """
934 
    self.send_startItemOn(item_id, timestamp)
935 
    self.recv_startItemOn()
936 
 
937 
  def send_startItemOn(self, item_id, timestamp):
938 
    self._oprot.writeMessageBegin('startItemOn', TMessageType.CALL, self._seqid)
939 
    args = startItemOn_args()
940 
    args.item_id = item_id
941 
    args.timestamp = timestamp
942 
    args.write(self._oprot)
943 
    self._oprot.writeMessageEnd()
944 
    self._oprot.trans.flush()
945 
 
946 
  def recv_startItemOn(self, ):
947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
948 
    if mtype == TMessageType.EXCEPTION:
949 
      x = TApplicationException()
950 
      x.read(self._iprot)
951 
      self._iprot.readMessageEnd()
952 
      raise x
953 
    result = startItemOn_result()
954 
    result.read(self._iprot)
955 
    self._iprot.readMessageEnd()
956 
    if result.cex is not None:
957 
      raise result.cex
958 
    return
959 
 
960 
  def retireItemOn(self, item_id, timestamp):
961 
    """
962 
    Parameters:
963 
     - item_id
964 
     - timestamp
965 
    """
966 
    self.send_retireItemOn(item_id, timestamp)
967 
    self.recv_retireItemOn()
968 
 
969 
  def send_retireItemOn(self, item_id, timestamp):
970 
    self._oprot.writeMessageBegin('retireItemOn', TMessageType.CALL, self._seqid)
971 
    args = retireItemOn_args()
972 
    args.item_id = item_id
973 
    args.timestamp = timestamp
974 
    args.write(self._oprot)
975 
    self._oprot.writeMessageEnd()
976 
    self._oprot.trans.flush()
977 
 
978 
  def recv_retireItemOn(self, ):
979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
980 
    if mtype == TMessageType.EXCEPTION:
981 
      x = TApplicationException()
982 
      x.read(self._iprot)
983 
      self._iprot.readMessageEnd()
984 
      raise x
985 
    result = retireItemOn_result()
986 
    result.read(self._iprot)
987 
    self._iprot.readMessageEnd()
988 
    if result.cex is not None:
989 
      raise result.cex
990 
    return
991 
 
992 
  def changeItemStatus(self, item_id, timestamp, newstatus):
993 
    """
994 
    Parameters:
995 
     - item_id
996 
     - timestamp
997 
     - newstatus
998 
    """
999 
    self.send_changeItemStatus(item_id, timestamp, newstatus)
1000 
    self.recv_changeItemStatus()
1001 
 
1002 
  def send_changeItemStatus(self, item_id, timestamp, newstatus):
1003 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
1004 
    args = changeItemStatus_args()
1005 
    args.item_id = item_id
1006 
    args.timestamp = timestamp
1007 
    args.newstatus = newstatus
1008 
    args.write(self._oprot)
1009 
    self._oprot.writeMessageEnd()
1010 
    self._oprot.trans.flush()
1011 
 
1012 
  def recv_changeItemStatus(self, ):
1013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1014 
    if mtype == TMessageType.EXCEPTION:
1015 
      x = TApplicationException()
1016 
      x.read(self._iprot)
1017 
      self._iprot.readMessageEnd()
1018 
      raise x
1019 
    result = changeItemStatus_result()
1020 
    result.read(self._iprot)
1021 
    self._iprot.readMessageEnd()
1022 
    if result.cex is not None:
1023 
      raise result.cex
1024 
    return
1025 
 
1026 
  def getItem(self, item_id):
1027 
    """
1028 
    Parameters:
1029 
     - item_id
1030 
    """
1031 
    self.send_getItem(item_id)
1032 
    return self.recv_getItem()
1033 
 
1034 
  def send_getItem(self, item_id):
1035 
    self._oprot.writeMessageBegin('getItem', TMessageType.CALL, self._seqid)
1036 
    args = getItem_args()
1037 
    args.item_id = item_id
1038 
    args.write(self._oprot)
1039 
    self._oprot.writeMessageEnd()
1040 
    self._oprot.trans.flush()
1041 
 
1042 
  def recv_getItem(self, ):
1043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1044 
    if mtype == TMessageType.EXCEPTION:
1045 
      x = TApplicationException()
1046 
      x.read(self._iprot)
1047 
      self._iprot.readMessageEnd()
1048 
      raise x
1049 
    result = getItem_result()
1050 
    result.read(self._iprot)
1051 
    self._iprot.readMessageEnd()
1052 
    if result.success is not None:
1053 
      return result.success
1054 
    if result.cex is not None:
1055 
      raise result.cex
1056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItem failed: unknown result");
1057 
 
1058 
  def getItemsByCatalogId(self, catalog_item_id):
1059 
    """
1060 
    Parameters:
1061 
     - catalog_item_id
1062 
    """
1063 
    self.send_getItemsByCatalogId(catalog_item_id)
1064 
    return self.recv_getItemsByCatalogId()
1065 
 
1066 
  def send_getItemsByCatalogId(self, catalog_item_id):
1067 
    self._oprot.writeMessageBegin('getItemsByCatalogId', TMessageType.CALL, self._seqid)
1068 
    args = getItemsByCatalogId_args()
1069 
    args.catalog_item_id = catalog_item_id
1070 
    args.write(self._oprot)
1071 
    self._oprot.writeMessageEnd()
1072 
    self._oprot.trans.flush()
1073 
 
1074 
  def recv_getItemsByCatalogId(self, ):
1075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1076 
    if mtype == TMessageType.EXCEPTION:
1077 
      x = TApplicationException()
1078 
      x.read(self._iprot)
1079 
      self._iprot.readMessageEnd()
1080 
      raise x
1081 
    result = getItemsByCatalogId_result()
1082 
    result.read(self._iprot)
1083 
    self._iprot.readMessageEnd()
1084 
    if result.success is not None:
1085 
      return result.success
1086 
    if result.cex is not None:
1087 
      raise result.cex
1088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByCatalogId failed: unknown result");
1089 
 
1090 
  def getValidItemsByCatalogId(self, catalog_item_id):
1091 
    """
1092 
    Parameters:
1093 
     - catalog_item_id
1094 
    """
1095 
    self.send_getValidItemsByCatalogId(catalog_item_id)
1096 
    return self.recv_getValidItemsByCatalogId()
1097 
 
1098 
  def send_getValidItemsByCatalogId(self, catalog_item_id):
1099 
    self._oprot.writeMessageBegin('getValidItemsByCatalogId', TMessageType.CALL, self._seqid)
1100 
    args = getValidItemsByCatalogId_args()
1101 
    args.catalog_item_id = catalog_item_id
1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_getValidItemsByCatalogId(self, ):
1107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1108 
    if mtype == TMessageType.EXCEPTION:
1109 
      x = TApplicationException()
1110 
      x.read(self._iprot)
1111 
      self._iprot.readMessageEnd()
1112 
      raise x
1113 
    result = getValidItemsByCatalogId_result()
1114 
    result.read(self._iprot)
1115 
    self._iprot.readMessageEnd()
1116 
    if result.success is not None:
1117 
      return result.success
1118 
    if result.cex is not None:
1119 
      raise result.cex
1120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidItemsByCatalogId failed: unknown result");
1121 
 
1122 
  def getAllItems(self, isActive):
1123 
    """
1124 
    Parameters:
1125 
     - isActive
1126 
    """
1127 
    self.send_getAllItems(isActive)
1128 
    return self.recv_getAllItems()
1129 
 
1130 
  def send_getAllItems(self, isActive):
1131 
    self._oprot.writeMessageBegin('getAllItems', TMessageType.CALL, self._seqid)
1132 
    args = getAllItems_args()
1133 
    args.isActive = isActive
1134 
    args.write(self._oprot)
1135 
    self._oprot.writeMessageEnd()
1136 
    self._oprot.trans.flush()
1137 
 
1138 
  def recv_getAllItems(self, ):
1139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1140 
    if mtype == TMessageType.EXCEPTION:
1141 
      x = TApplicationException()
1142 
      x.read(self._iprot)
1143 
      self._iprot.readMessageEnd()
1144 
      raise x
1145 
    result = getAllItems_result()
1146 
    result.read(self._iprot)
1147 
    self._iprot.readMessageEnd()
1148 
    if result.success is not None:
1149 
      return result.success
1150 
    if result.cex is not None:
1151 
      raise result.cex
1152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItems failed: unknown result");
1153 
 
1154 
  def getAllItemsByStatus(self, itemStatus):
1155 
    """
1156 
    Parameters:
1157 
     - itemStatus
1158 
    """
1159 
    self.send_getAllItemsByStatus(itemStatus)
1160 
    return self.recv_getAllItemsByStatus()
1161 
 
1162 
  def send_getAllItemsByStatus(self, itemStatus):
1163 
    self._oprot.writeMessageBegin('getAllItemsByStatus', TMessageType.CALL, self._seqid)
1164 
    args = getAllItemsByStatus_args()
1165 
    args.itemStatus = itemStatus
1166 
    args.write(self._oprot)
1167 
    self._oprot.writeMessageEnd()
1168 
    self._oprot.trans.flush()
1169 
 
1170 
  def recv_getAllItemsByStatus(self, ):
1171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1172 
    if mtype == TMessageType.EXCEPTION:
1173 
      x = TApplicationException()
1174 
      x.read(self._iprot)
1175 
      self._iprot.readMessageEnd()
1176 
      raise x
1177 
    result = getAllItemsByStatus_result()
1178 
    result.read(self._iprot)
1179 
    self._iprot.readMessageEnd()
1180 
    if result.success is not None:
1181 
      return result.success
1182 
    if result.cex is not None:
1183 
      raise result.cex
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatus failed: unknown result");
1185 
 
1186 
  def markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1187 
    """
1188 
    Parameters:
1189 
     - entityId
1190 
     - category
1191 
     - brand
1192 
     - modelName
1193 
     - modelNumber
1194 
    """
1195 
    self.send_markItemAsContentComplete(entityId, category, brand, modelName, modelNumber)
1196 
    return self.recv_markItemAsContentComplete()
1197 
 
1198 
  def send_markItemAsContentComplete(self, entityId, category, brand, modelName, modelNumber):
1199 
    self._oprot.writeMessageBegin('markItemAsContentComplete', TMessageType.CALL, self._seqid)
1200 
    args = markItemAsContentComplete_args()
1201 
    args.entityId = entityId
1202 
    args.category = category
1203 
    args.brand = brand
1204 
    args.modelName = modelName
1205 
    args.modelNumber = modelNumber
1206 
    args.write(self._oprot)
1207 
    self._oprot.writeMessageEnd()
1208 
    self._oprot.trans.flush()
1209 
 
1210 
  def recv_markItemAsContentComplete(self, ):
1211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1212 
    if mtype == TMessageType.EXCEPTION:
1213 
      x = TApplicationException()
1214 
      x.read(self._iprot)
1215 
      self._iprot.readMessageEnd()
1216 
      raise x
1217 
    result = markItemAsContentComplete_result()
1218 
    result.read(self._iprot)
1219 
    self._iprot.readMessageEnd()
1220 
    if result.success is not None:
1221 
      return result.success
1222 
    if result.cex is not None:
1223 
      raise result.cex
1224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markItemAsContentComplete failed: unknown result");
1225 
 
1226 
  def getAllItemsInRange(self, offset, limit):
1227 
    """
1228 
    Gets at most 'limit' items starting at the given offset. Returns an empty list if there are no more items at the given offset.
1229 
 
1230 
    Parameters:
1231 
     - offset
1232 
     - limit
1233 
    """
1234 
    self.send_getAllItemsInRange(offset, limit)
1235 
    return self.recv_getAllItemsInRange()
1236 
 
1237 
  def send_getAllItemsInRange(self, offset, limit):
1238 
    self._oprot.writeMessageBegin('getAllItemsInRange', TMessageType.CALL, self._seqid)
1239 
    args = getAllItemsInRange_args()
1240 
    args.offset = offset
1241 
    args.limit = limit
1242 
    args.write(self._oprot)
1243 
    self._oprot.writeMessageEnd()
1244 
    self._oprot.trans.flush()
1245 
 
1246 
  def recv_getAllItemsInRange(self, ):
1247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1248 
    if mtype == TMessageType.EXCEPTION:
1249 
      x = TApplicationException()
1250 
      x.read(self._iprot)
1251 
      self._iprot.readMessageEnd()
1252 
      raise x
1253 
    result = getAllItemsInRange_result()
1254 
    result.read(self._iprot)
1255 
    self._iprot.readMessageEnd()
1256 
    if result.success is not None:
1257 
      return result.success
1258 
    if result.cex is not None:
1259 
      raise result.cex
1260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsInRange failed: unknown result");
1261 
 
1262 
  def getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1263 
    """
1264 
    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.
1265 
 
1266 
    Parameters:
1267 
     - itemStatus
1268 
     - offset
1269 
     - limit
1270 
    """
1271 
    self.send_getAllItemsByStatusInRange(itemStatus, offset, limit)
1272 
    return self.recv_getAllItemsByStatusInRange()
1273 
 
1274 
  def send_getAllItemsByStatusInRange(self, itemStatus, offset, limit):
1275 
    self._oprot.writeMessageBegin('getAllItemsByStatusInRange', TMessageType.CALL, self._seqid)
1276 
    args = getAllItemsByStatusInRange_args()
1277 
    args.itemStatus = itemStatus
1278 
    args.offset = offset
1279 
    args.limit = limit
1280 
    args.write(self._oprot)
1281 
    self._oprot.writeMessageEnd()
1282 
    self._oprot.trans.flush()
1283 
 
1284 
  def recv_getAllItemsByStatusInRange(self, ):
1285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1286 
    if mtype == TMessageType.EXCEPTION:
1287 
      x = TApplicationException()
1288 
      x.read(self._iprot)
1289 
      self._iprot.readMessageEnd()
1290 
      raise x
1291 
    result = getAllItemsByStatusInRange_result()
1292 
    result.read(self._iprot)
1293 
    self._iprot.readMessageEnd()
1294 
    if result.success is not None:
1295 
      return result.success
1296 
    if result.cex is not None:
1297 
      raise result.cex
1298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsByStatusInRange failed: unknown result");
1299 
 
1300 
  def getItemCountByStatus(self, useStatus, itemStatus):
1301 
    """
1302 
    Gets a count of all items by status
1303 
 
1304 
    Parameters:
1305 
     - useStatus
1306 
     - itemStatus
1307 
    """
1308 
    self.send_getItemCountByStatus(useStatus, itemStatus)
1309 
    return self.recv_getItemCountByStatus()
1310 
 
1311 
  def send_getItemCountByStatus(self, useStatus, itemStatus):
1312 
    self._oprot.writeMessageBegin('getItemCountByStatus', TMessageType.CALL, self._seqid)
1313 
    args = getItemCountByStatus_args()
1314 
    args.useStatus = useStatus
1315 
    args.itemStatus = itemStatus
1316 
    args.write(self._oprot)
1317 
    self._oprot.writeMessageEnd()
1318 
    self._oprot.trans.flush()
1319 
 
1320 
  def recv_getItemCountByStatus(self, ):
1321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1322 
    if mtype == TMessageType.EXCEPTION:
1323 
      x = TApplicationException()
1324 
      x.read(self._iprot)
1325 
      self._iprot.readMessageEnd()
1326 
      raise x
1327 
    result = getItemCountByStatus_result()
1328 
    result.read(self._iprot)
1329 
    self._iprot.readMessageEnd()
1330 
    if result.success is not None:
1331 
      return result.success
1332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemCountByStatus failed: unknown result");
1333 
 
1334 
  def getBestSellers(self, ):
1335 
    self.send_getBestSellers()
1336 
    return self.recv_getBestSellers()
1337 
 
1338 
  def send_getBestSellers(self, ):
1339 
    self._oprot.writeMessageBegin('getBestSellers', TMessageType.CALL, self._seqid)
1340 
    args = getBestSellers_args()
1341 
    args.write(self._oprot)
1342 
    self._oprot.writeMessageEnd()
1343 
    self._oprot.trans.flush()
1344 
 
1345 
  def recv_getBestSellers(self, ):
1346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1347 
    if mtype == TMessageType.EXCEPTION:
1348 
      x = TApplicationException()
1349 
      x.read(self._iprot)
1350 
      self._iprot.readMessageEnd()
1351 
      raise x
1352 
    result = getBestSellers_result()
1353 
    result.read(self._iprot)
1354 
    self._iprot.readMessageEnd()
1355 
    if result.success is not None:
1356 
      return result.success
1357 
    if result.isex is not None:
1358 
      raise result.isex
1359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellers failed: unknown result");
1360 
 
1361 
  def getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1362 
    """
1363 
    Parameters:
1364 
     - beginIndex
1365 
     - totalItems
1366 
     - brand
1367 
     - category
1368 
    """
1369 
    self.send_getBestSellersCatalogIds(beginIndex, totalItems, brand, category)
1370 
    return self.recv_getBestSellersCatalogIds()
1371 
 
1372 
  def send_getBestSellersCatalogIds(self, beginIndex, totalItems, brand, category):
1373 
    self._oprot.writeMessageBegin('getBestSellersCatalogIds', TMessageType.CALL, self._seqid)
1374 
    args = getBestSellersCatalogIds_args()
1375 
    args.beginIndex = beginIndex
1376 
    args.totalItems = totalItems
1377 
    args.brand = brand
1378 
    args.category = category
1379 
    args.write(self._oprot)
1380 
    self._oprot.writeMessageEnd()
1381 
    self._oprot.trans.flush()
1382 
 
1383 
  def recv_getBestSellersCatalogIds(self, ):
1384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1385 
    if mtype == TMessageType.EXCEPTION:
1386 
      x = TApplicationException()
1387 
      x.read(self._iprot)
1388 
      self._iprot.readMessageEnd()
1389 
      raise x
1390 
    result = getBestSellersCatalogIds_result()
1391 
    result.read(self._iprot)
1392 
    self._iprot.readMessageEnd()
1393 
    if result.success is not None:
1394 
      return result.success
1395 
    if result.cex is not None:
1396 
      raise result.cex
1397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCatalogIds failed: unknown result");
1398 
 
1399 
  def getBestSellersCount(self, ):
1400 
    self.send_getBestSellersCount()
1401 
    return self.recv_getBestSellersCount()
1402 
 
1403 
  def send_getBestSellersCount(self, ):
1404 
    self._oprot.writeMessageBegin('getBestSellersCount', TMessageType.CALL, self._seqid)
1405 
    args = getBestSellersCount_args()
1406 
    args.write(self._oprot)
1407 
    self._oprot.writeMessageEnd()
1408 
    self._oprot.trans.flush()
1409 
 
1410 
  def recv_getBestSellersCount(self, ):
1411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1412 
    if mtype == TMessageType.EXCEPTION:
1413 
      x = TApplicationException()
1414 
      x.read(self._iprot)
1415 
      self._iprot.readMessageEnd()
1416 
      raise x
1417 
    result = getBestSellersCount_result()
1418 
    result.read(self._iprot)
1419 
    self._iprot.readMessageEnd()
1420 
    if result.success is not None:
1421 
      return result.success
1422 
    if result.cex is not None:
1423 
      raise result.cex
1424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestSellersCount failed: unknown result");
1425 
 
1426 
  def getBestDeals(self, ):
1427 
    self.send_getBestDeals()
1428 
    return self.recv_getBestDeals()
1429 
 
1430 
  def send_getBestDeals(self, ):
1431 
    self._oprot.writeMessageBegin('getBestDeals', TMessageType.CALL, self._seqid)
1432 
    args = getBestDeals_args()
1433 
    args.write(self._oprot)
1434 
    self._oprot.writeMessageEnd()
1435 
    self._oprot.trans.flush()
1436 
 
1437 
  def recv_getBestDeals(self, ):
1438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1439 
    if mtype == TMessageType.EXCEPTION:
1440 
      x = TApplicationException()
1441 
      x.read(self._iprot)
1442 
      self._iprot.readMessageEnd()
1443 
      raise x
1444 
    result = getBestDeals_result()
1445 
    result.read(self._iprot)
1446 
    self._iprot.readMessageEnd()
1447 
    if result.success is not None:
1448 
      return result.success
1449 
    if result.isex is not None:
1450 
      raise result.isex
1451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDeals failed: unknown result");
1452 
 
1453 
  def getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1454 
    """
1455 
    Parameters:
1456 
     - beginIndex
1457 
     - totalItems
1458 
     - brand
1459 
     - category
1460 
    """
1461 
    self.send_getBestDealsCatalogIds(beginIndex, totalItems, brand, category)
1462 
    return self.recv_getBestDealsCatalogIds()
1463 
 
1464 
  def send_getBestDealsCatalogIds(self, beginIndex, totalItems, brand, category):
1465 
    self._oprot.writeMessageBegin('getBestDealsCatalogIds', TMessageType.CALL, self._seqid)
1466 
    args = getBestDealsCatalogIds_args()
1467 
    args.beginIndex = beginIndex
1468 
    args.totalItems = totalItems
1469 
    args.brand = brand
1470 
    args.category = category
1471 
    args.write(self._oprot)
1472 
    self._oprot.writeMessageEnd()
1473 
    self._oprot.trans.flush()
1474 
 
1475 
  def recv_getBestDealsCatalogIds(self, ):
1476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1477 
    if mtype == TMessageType.EXCEPTION:
1478 
      x = TApplicationException()
1479 
      x.read(self._iprot)
1480 
      self._iprot.readMessageEnd()
1481 
      raise x
1482 
    result = getBestDealsCatalogIds_result()
1483 
    result.read(self._iprot)
1484 
    self._iprot.readMessageEnd()
1485 
    if result.success is not None:
1486 
      return result.success
1487 
    if result.cex is not None:
1488 
      raise result.cex
1489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCatalogIds failed: unknown result");
1490 
 
1491 
  def getBestDealsCount(self, ):
1492 
    self.send_getBestDealsCount()
1493 
    return self.recv_getBestDealsCount()
1494 
 
1495 
  def send_getBestDealsCount(self, ):
1496 
    self._oprot.writeMessageBegin('getBestDealsCount', TMessageType.CALL, self._seqid)
1497 
    args = getBestDealsCount_args()
1498 
    args.write(self._oprot)
1499 
    self._oprot.writeMessageEnd()
1500 
    self._oprot.trans.flush()
1501 
 
1502 
  def recv_getBestDealsCount(self, ):
1503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1504 
    if mtype == TMessageType.EXCEPTION:
1505 
      x = TApplicationException()
1506 
      x.read(self._iprot)
1507 
      self._iprot.readMessageEnd()
1508 
      raise x
1509 
    result = getBestDealsCount_result()
1510 
    result.read(self._iprot)
1511 
    self._iprot.readMessageEnd()
1512 
    if result.success is not None:
1513 
      return result.success
1514 
    if result.cex is not None:
1515 
      raise result.cex
1516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBestDealsCount failed: unknown result");
1517 
 
1518 
  def getComingSoon(self, ):
1519 
    self.send_getComingSoon()
1520 
    return self.recv_getComingSoon()
1521 
 
1522 
  def send_getComingSoon(self, ):
1523 
    self._oprot.writeMessageBegin('getComingSoon', TMessageType.CALL, self._seqid)
1524 
    args = getComingSoon_args()
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getComingSoon(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getComingSoon_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
1539 
    if result.success is not None:
1540 
      return result.success
1541 
    if result.isex is not None:
1542 
      raise result.isex
1543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoon failed: unknown result");
1544 
 
1545 
  def getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1546 
    """
1547 
    Parameters:
1548 
     - beginIndex
1549 
     - totalItems
1550 
     - brand
1551 
     - category
1552 
    """
1553 
    self.send_getComingSoonCatalogIds(beginIndex, totalItems, brand, category)
1554 
    return self.recv_getComingSoonCatalogIds()
1555 
 
1556 
  def send_getComingSoonCatalogIds(self, beginIndex, totalItems, brand, category):
1557 
    self._oprot.writeMessageBegin('getComingSoonCatalogIds', TMessageType.CALL, self._seqid)
1558 
    args = getComingSoonCatalogIds_args()
1559 
    args.beginIndex = beginIndex
1560 
    args.totalItems = totalItems
1561 
    args.brand = brand
1562 
    args.category = category
1563 
    args.write(self._oprot)
1564 
    self._oprot.writeMessageEnd()
1565 
    self._oprot.trans.flush()
1566 
 
1567 
  def recv_getComingSoonCatalogIds(self, ):
1568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1569 
    if mtype == TMessageType.EXCEPTION:
1570 
      x = TApplicationException()
1571 
      x.read(self._iprot)
1572 
      self._iprot.readMessageEnd()
1573 
      raise x
1574 
    result = getComingSoonCatalogIds_result()
1575 
    result.read(self._iprot)
1576 
    self._iprot.readMessageEnd()
1577 
    if result.success is not None:
1578 
      return result.success
1579 
    if result.cex is not None:
1580 
      raise result.cex
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCatalogIds failed: unknown result");
1582 
 
1583 
  def getComingSoonCount(self, ):
1584 
    self.send_getComingSoonCount()
1585 
    return self.recv_getComingSoonCount()
1586 
 
1587 
  def send_getComingSoonCount(self, ):
1588 
    self._oprot.writeMessageBegin('getComingSoonCount', TMessageType.CALL, self._seqid)
1589 
    args = getComingSoonCount_args()
1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
1594 
  def recv_getComingSoonCount(self, ):
1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
1601 
    result = getComingSoonCount_result()
1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
1604 
    if result.success is not None:
1605 
      return result.success
1606 
    if result.cex is not None:
1607 
      raise result.cex
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getComingSoonCount failed: unknown result");
1609 
 
1610 
  def getLatestArrivals(self, ):
1611 
    """
1612 
    Returns a list of items sorted in the descending order by start date.
1613 
    The list is limited to the 'latest_arrivals_count' configuraiton parameter.
1614 
    """
1615 
    self.send_getLatestArrivals()
1616 
    return self.recv_getLatestArrivals()
1617 
 
1618 
  def send_getLatestArrivals(self, ):
1619 
    self._oprot.writeMessageBegin('getLatestArrivals', TMessageType.CALL, self._seqid)
1620 
    args = getLatestArrivals_args()
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getLatestArrivals(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getLatestArrivals_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
1635 
    if result.success is not None:
1636 
      return result.success
1637 
    if result.isex is not None:
1638 
      raise result.isex
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivals failed: unknown result");
1640 
 
1641 
  def getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1642 
    """
1643 
    Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
1644 
    To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
1645 
 
1646 
    Parameters:
1647 
     - beginIndex
1648 
     - totalItems
1649 
     - brand
1650 
     - categories
1651 
    """
1652 
    self.send_getLatestArrivalsCatalogIds(beginIndex, totalItems, brand, categories)
1653 
    return self.recv_getLatestArrivalsCatalogIds()
1654 
 
1655 
  def send_getLatestArrivalsCatalogIds(self, beginIndex, totalItems, brand, categories):
1656 
    self._oprot.writeMessageBegin('getLatestArrivalsCatalogIds', TMessageType.CALL, self._seqid)
1657 
    args = getLatestArrivalsCatalogIds_args()
1658 
    args.beginIndex = beginIndex
1659 
    args.totalItems = totalItems
1660 
    args.brand = brand
1661 
    args.categories = categories
1662 
    args.write(self._oprot)
1663 
    self._oprot.writeMessageEnd()
1664 
    self._oprot.trans.flush()
1665 
 
1666 
  def recv_getLatestArrivalsCatalogIds(self, ):
1667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1668 
    if mtype == TMessageType.EXCEPTION:
1669 
      x = TApplicationException()
1670 
      x.read(self._iprot)
1671 
      self._iprot.readMessageEnd()
1672 
      raise x
1673 
    result = getLatestArrivalsCatalogIds_result()
1674 
    result.read(self._iprot)
1675 
    self._iprot.readMessageEnd()
1676 
    if result.success is not None:
1677 
      return result.success
1678 
    if result.cex is not None:
1679 
      raise result.cex
1680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCatalogIds failed: unknown result");
1681 
 
1682 
  def getLatestArrivalsCount(self, ):
1683 
    """
1684 
    Get the total number of latest arrivals we are willing to show.
1685 
    The count's upper bound is the 'latest_arrivals_count' configuraiton parameter.
1686 
    """
1687 
    self.send_getLatestArrivalsCount()
1688 
    return self.recv_getLatestArrivalsCount()
1689 
 
1690 
  def send_getLatestArrivalsCount(self, ):
1691 
    self._oprot.writeMessageBegin('getLatestArrivalsCount', TMessageType.CALL, self._seqid)
1692 
    args = getLatestArrivalsCount_args()
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getLatestArrivalsCount(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getLatestArrivalsCount_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
1707 
    if result.success is not None:
1708 
      return result.success
1709 
    if result.cex is not None:
1710 
      raise result.cex
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLatestArrivalsCount failed: unknown result");
1712 
 
1713 
  def generateNewEntityID(self, ):
1714 
    self.send_generateNewEntityID()
1715 
    return self.recv_generateNewEntityID()
1716 
 
1717 
  def send_generateNewEntityID(self, ):
1718 
    self._oprot.writeMessageBegin('generateNewEntityID', TMessageType.CALL, self._seqid)
1719 
    args = generateNewEntityID_args()
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_generateNewEntityID(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = generateNewEntityID_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
1734 
    if result.success is not None:
1735 
      return result.success
1736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "generateNewEntityID failed: unknown result");
1737 
 
1738 
  def addCategory(self, category):
1739 
    """
1740 
    All category related functions
1741 
 
1742 
    Parameters:
1743 
     - category
1744 
    """
1745 
    self.send_addCategory(category)
1746 
    return self.recv_addCategory()
1747 
 
1748 
  def send_addCategory(self, category):
1749 
    self._oprot.writeMessageBegin('addCategory', TMessageType.CALL, self._seqid)
1750 
    args = addCategory_args()
1751 
    args.category = category
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_addCategory(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = addCategory_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
1766 
    if result.success is not None:
1767 
      return result.success
1768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addCategory failed: unknown result");
1769 
 
1770 
  def getCategory(self, id):
1771 
    """
1772 
    Parameters:
1773 
     - id
1774 
    """
1775 
    self.send_getCategory(id)
1776 
    return self.recv_getCategory()
1777 
 
1778 
  def send_getCategory(self, id):
1779 
    self._oprot.writeMessageBegin('getCategory', TMessageType.CALL, self._seqid)
1780 
    args = getCategory_args()
1781 
    args.id = id
1782 
    args.write(self._oprot)
1783 
    self._oprot.writeMessageEnd()
1784 
    self._oprot.trans.flush()
1785 
 
1786 
  def recv_getCategory(self, ):
1787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1788 
    if mtype == TMessageType.EXCEPTION:
1789 
      x = TApplicationException()
1790 
      x.read(self._iprot)
1791 
      self._iprot.readMessageEnd()
1792 
      raise x
1793 
    result = getCategory_result()
1794 
    result.read(self._iprot)
1795 
    self._iprot.readMessageEnd()
1796 
    if result.success is not None:
1797 
      return result.success
1798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCategory failed: unknown result");
1799 
 
1800 
  def getAllCategories(self, ):
1801 
    self.send_getAllCategories()
1802 
    return self.recv_getAllCategories()
1803 
 
1804 
  def send_getAllCategories(self, ):
1805 
    self._oprot.writeMessageBegin('getAllCategories', TMessageType.CALL, self._seqid)
1806 
    args = getAllCategories_args()
1807 
    args.write(self._oprot)
1808 
    self._oprot.writeMessageEnd()
1809 
    self._oprot.trans.flush()
1810 
 
1811 
  def recv_getAllCategories(self, ):
1812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1813 
    if mtype == TMessageType.EXCEPTION:
1814 
      x = TApplicationException()
1815 
      x.read(self._iprot)
1816 
      self._iprot.readMessageEnd()
1817 
      raise x
1818 
    result = getAllCategories_result()
1819 
    result.read(self._iprot)
1820 
    self._iprot.readMessageEnd()
1821 
    if result.success is not None:
1822 
      return result.success
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllCategories failed: unknown result");
1824 
 
1825 
  def getAllSimilarItems(self, itemId):
1826 
    """
1827 
    Returns the list of similar items.
1828 
 
1829 
    Parameters:
1830 
     - itemId
1831 
    """
1832 
    self.send_getAllSimilarItems(itemId)
1833 
    return self.recv_getAllSimilarItems()
1834 
 
1835 
  def send_getAllSimilarItems(self, itemId):
1836 
    self._oprot.writeMessageBegin('getAllSimilarItems', TMessageType.CALL, self._seqid)
1837 
    args = getAllSimilarItems_args()
1838 
    args.itemId = itemId
1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
1843 
  def recv_getAllSimilarItems(self, ):
1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
1850 
    result = getAllSimilarItems_result()
1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
1853 
    if result.success is not None:
1854 
      return result.success
1855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSimilarItems failed: unknown result");
1856 
 
1857 
  def addSimilarItem(self, itemId, catalogItemId):
1858 
    """
1859 
    Adds similar item.
1860 
 
1861 
    Parameters:
1862 
     - itemId
1863 
     - catalogItemId
1864 
    """
1865 
    self.send_addSimilarItem(itemId, catalogItemId)
1866 
    return self.recv_addSimilarItem()
1867 
 
1868 
  def send_addSimilarItem(self, itemId, catalogItemId):
1869 
    self._oprot.writeMessageBegin('addSimilarItem', TMessageType.CALL, self._seqid)
1870 
    args = addSimilarItem_args()
1871 
    args.itemId = itemId
1872 
    args.catalogItemId = catalogItemId
1873 
    args.write(self._oprot)
1874 
    self._oprot.writeMessageEnd()
1875 
    self._oprot.trans.flush()
1876 
 
1877 
  def recv_addSimilarItem(self, ):
1878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1879 
    if mtype == TMessageType.EXCEPTION:
1880 
      x = TApplicationException()
1881 
      x.read(self._iprot)
1882 
      self._iprot.readMessageEnd()
1883 
      raise x
1884 
    result = addSimilarItem_result()
1885 
    result.read(self._iprot)
1886 
    self._iprot.readMessageEnd()
1887 
    if result.success is not None:
1888 
      return result.success
1889 
    if result.cex is not None:
1890 
      raise result.cex
1891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addSimilarItem failed: unknown result");
1892 
 
6512 kshitij.so 1893 
  def addTag(self, displayName, itemId):
1894 
    """
1895 
    Tag Related
1896 
 
1897 
    Parameters:
1898 
     - displayName
1899 
     - itemId
1900 
    """
1901 
    self.send_addTag(displayName, itemId)
1902 
    return self.recv_addTag()
1903 
 
1904 
  def send_addTag(self, displayName, itemId):
1905 
    self._oprot.writeMessageBegin('addTag', TMessageType.CALL, self._seqid)
1906 
    args = addTag_args()
1907 
    args.displayName = displayName
1908 
    args.itemId = itemId
1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
1913 
  def recv_addTag(self, ):
1914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1915 
    if mtype == TMessageType.EXCEPTION:
1916 
      x = TApplicationException()
1917 
      x.read(self._iprot)
1918 
      self._iprot.readMessageEnd()
1919 
      raise x
1920 
    result = addTag_result()
1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
1923 
    if result.success is not None:
1924 
      return result.success
1925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTag failed: unknown result");
1926 
 
1927 
  def deleteEntityTag(self, displayName, itemId):
1928 
    """
1929 
    Parameters:
1930 
     - displayName
1931 
     - itemId
1932 
    """
1933 
    self.send_deleteEntityTag(displayName, itemId)
1934 
    return self.recv_deleteEntityTag()
1935 
 
1936 
  def send_deleteEntityTag(self, displayName, itemId):
1937 
    self._oprot.writeMessageBegin('deleteEntityTag', TMessageType.CALL, self._seqid)
1938 
    args = deleteEntityTag_args()
1939 
    args.displayName = displayName
1940 
    args.itemId = itemId
1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
1945 
  def recv_deleteEntityTag(self, ):
1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
1952 
    result = deleteEntityTag_result()
1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
1955 
    if result.success is not None:
1956 
      return result.success
1957 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteEntityTag failed: unknown result");
1958 
 
1959 
  def deleteTag(self, displayName):
1960 
    """
1961 
    Parameters:
1962 
     - displayName
1963 
    """
1964 
    self.send_deleteTag(displayName)
1965 
    return self.recv_deleteTag()
1966 
 
1967 
  def send_deleteTag(self, displayName):
1968 
    self._oprot.writeMessageBegin('deleteTag', TMessageType.CALL, self._seqid)
1969 
    args = deleteTag_args()
1970 
    args.displayName = displayName
1971 
    args.write(self._oprot)
1972 
    self._oprot.writeMessageEnd()
1973 
    self._oprot.trans.flush()
1974 
 
1975 
  def recv_deleteTag(self, ):
1976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1977 
    if mtype == TMessageType.EXCEPTION:
1978 
      x = TApplicationException()
1979 
      x.read(self._iprot)
1980 
      self._iprot.readMessageEnd()
1981 
      raise x
1982 
    result = deleteTag_result()
1983 
    result.read(self._iprot)
1984 
    self._iprot.readMessageEnd()
1985 
    if result.success is not None:
1986 
      return result.success
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteTag failed: unknown result");
1988 
 
1989 
  def getAllTags(self, ):
1990 
    self.send_getAllTags()
1991 
    return self.recv_getAllTags()
1992 
 
1993 
  def send_getAllTags(self, ):
1994 
    self._oprot.writeMessageBegin('getAllTags', TMessageType.CALL, self._seqid)
1995 
    args = getAllTags_args()
1996 
    args.write(self._oprot)
1997 
    self._oprot.writeMessageEnd()
1998 
    self._oprot.trans.flush()
1999 
 
2000 
  def recv_getAllTags(self, ):
2001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2002 
    if mtype == TMessageType.EXCEPTION:
2003 
      x = TApplicationException()
2004 
      x.read(self._iprot)
2005 
      self._iprot.readMessageEnd()
2006 
      raise x
2007 
    result = getAllTags_result()
2008 
    result.read(self._iprot)
2009 
    self._iprot.readMessageEnd()
2010 
    if result.success is not None:
2011 
      return result.success
2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllTags failed: unknown result");
2013 
 
2014 
  def getAllEntitiesByTagName(self, displayName):
2015 
    """
2016 
    Parameters:
2017 
     - displayName
2018 
    """
2019 
    self.send_getAllEntitiesByTagName(displayName)
2020 
    return self.recv_getAllEntitiesByTagName()
2021 
 
2022 
  def send_getAllEntitiesByTagName(self, displayName):
2023 
    self._oprot.writeMessageBegin('getAllEntitiesByTagName', TMessageType.CALL, self._seqid)
2024 
    args = getAllEntitiesByTagName_args()
2025 
    args.displayName = displayName
2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
2030 
  def recv_getAllEntitiesByTagName(self, ):
2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
2037 
    result = getAllEntitiesByTagName_result()
2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
2040 
    if result.success is not None:
2041 
      return result.success
2042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntitiesByTagName failed: unknown result");
2043 
 
6845 amit.gupta 2044 
  def getAllEntityTags(self, ):
2045 
    self.send_getAllEntityTags()
2046 
    return self.recv_getAllEntityTags()
2047 
 
2048 
  def send_getAllEntityTags(self, ):
2049 
    self._oprot.writeMessageBegin('getAllEntityTags', TMessageType.CALL, self._seqid)
2050 
    args = getAllEntityTags_args()
2051 
    args.write(self._oprot)
2052 
    self._oprot.writeMessageEnd()
2053 
    self._oprot.trans.flush()
2054 
 
2055 
  def recv_getAllEntityTags(self, ):
2056 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2057 
    if mtype == TMessageType.EXCEPTION:
2058 
      x = TApplicationException()
2059 
      x.read(self._iprot)
2060 
      self._iprot.readMessageEnd()
2061 
      raise x
2062 
    result = getAllEntityTags_result()
2063 
    result.read(self._iprot)
2064 
    self._iprot.readMessageEnd()
2065 
    if result.success is not None:
2066 
      return result.success
2067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllEntityTags failed: unknown result");
2068 
 
6850 kshitij.so 2069 
  def addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2070 
    """
2071 
    Parameters:
2072 
     - bannerName
2073 
     - imageName
2074 
     - link
2075 
     - priority
2076 
     - isActive
2077 
     - hasMap
2078 
    """
2079 
    self.send_addBanner(bannerName, imageName, link, priority, isActive, hasMap)
2080 
    return self.recv_addBanner()
2081 
 
2082 
  def send_addBanner(self, bannerName, imageName, link, priority, isActive, hasMap):
2083 
    self._oprot.writeMessageBegin('addBanner', TMessageType.CALL, self._seqid)
2084 
    args = addBanner_args()
2085 
    args.bannerName = bannerName
2086 
    args.imageName = imageName
2087 
    args.link = link
2088 
    args.priority = priority
2089 
    args.isActive = isActive
2090 
    args.hasMap = hasMap
2091 
    args.write(self._oprot)
2092 
    self._oprot.writeMessageEnd()
2093 
    self._oprot.trans.flush()
2094 
 
2095 
  def recv_addBanner(self, ):
2096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2097 
    if mtype == TMessageType.EXCEPTION:
2098 
      x = TApplicationException()
2099 
      x.read(self._iprot)
2100 
      self._iprot.readMessageEnd()
2101 
      raise x
2102 
    result = addBanner_result()
2103 
    result.read(self._iprot)
2104 
    self._iprot.readMessageEnd()
2105 
    if result.success is not None:
2106 
      return result.success
2107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBanner failed: unknown result");
2108 
 
2109 
  def getAllBanners(self, ):
2110 
    self.send_getAllBanners()
2111 
    return self.recv_getAllBanners()
2112 
 
2113 
  def send_getAllBanners(self, ):
2114 
    self._oprot.writeMessageBegin('getAllBanners', TMessageType.CALL, self._seqid)
2115 
    args = getAllBanners_args()
2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
2120 
  def recv_getAllBanners(self, ):
2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
2127 
    result = getAllBanners_result()
2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
2130 
    if result.success is not None:
2131 
      return result.success
2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBanners failed: unknown result");
2133 
 
2134 
  def deleteBanner(self, bannerName):
2135 
    """
2136 
    Parameters:
2137 
     - bannerName
2138 
    """
2139 
    self.send_deleteBanner(bannerName)
2140 
    return self.recv_deleteBanner()
2141 
 
2142 
  def send_deleteBanner(self, bannerName):
2143 
    self._oprot.writeMessageBegin('deleteBanner', TMessageType.CALL, self._seqid)
2144 
    args = deleteBanner_args()
2145 
    args.bannerName = bannerName
2146 
    args.write(self._oprot)
2147 
    self._oprot.writeMessageEnd()
2148 
    self._oprot.trans.flush()
2149 
 
2150 
  def recv_deleteBanner(self, ):
2151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2152 
    if mtype == TMessageType.EXCEPTION:
2153 
      x = TApplicationException()
2154 
      x.read(self._iprot)
2155 
      self._iprot.readMessageEnd()
2156 
      raise x
2157 
    result = deleteBanner_result()
2158 
    result.read(self._iprot)
2159 
    self._iprot.readMessageEnd()
2160 
    if result.success is not None:
2161 
      return result.success
2162 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBanner failed: unknown result");
2163 
 
2164 
  def getBannerDetails(self, bannerName):
2165 
    """
2166 
    Parameters:
2167 
     - bannerName
2168 
    """
2169 
    self.send_getBannerDetails(bannerName)
2170 
    return self.recv_getBannerDetails()
2171 
 
2172 
  def send_getBannerDetails(self, bannerName):
2173 
    self._oprot.writeMessageBegin('getBannerDetails', TMessageType.CALL, self._seqid)
2174 
    args = getBannerDetails_args()
2175 
    args.bannerName = bannerName
2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
2180 
  def recv_getBannerDetails(self, ):
2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
2187 
    result = getBannerDetails_result()
2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
2190 
    if result.success is not None:
2191 
      return result.success
2192 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerDetails failed: unknown result");
2193 
 
2194 
  def getActiveBanners(self, ):
2195 
    self.send_getActiveBanners()
2196 
    return self.recv_getActiveBanners()
2197 
 
2198 
  def send_getActiveBanners(self, ):
2199 
    self._oprot.writeMessageBegin('getActiveBanners', TMessageType.CALL, self._seqid)
2200 
    args = getActiveBanners_args()
2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
2205 
  def recv_getActiveBanners(self, ):
2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
2212 
    result = getActiveBanners_result()
2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
2215 
    if result.success is not None:
2216 
      return result.success
2217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getActiveBanners failed: unknown result");
2218 
 
6849 kshitij.so 2219 
  def addBannerMap(self, bannerName, mapLink, coordinates):
2220 
    """
2221 
    Parameters:
2222 
     - bannerName
2223 
     - mapLink
2224 
     - coordinates
2225 
    """
2226 
    self.send_addBannerMap(bannerName, mapLink, coordinates)
2227 
    return self.recv_addBannerMap()
2228 
 
2229 
  def send_addBannerMap(self, bannerName, mapLink, coordinates):
2230 
    self._oprot.writeMessageBegin('addBannerMap', TMessageType.CALL, self._seqid)
2231 
    args = addBannerMap_args()
2232 
    args.bannerName = bannerName
2233 
    args.mapLink = mapLink
2234 
    args.coordinates = coordinates
2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
2239 
  def recv_addBannerMap(self, ):
2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
2246 
    result = addBannerMap_result()
2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
2249 
    if result.success is not None:
2250 
      return result.success
2251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBannerMap failed: unknown result");
2252 
 
2253 
  def deleteBannerMap(self, bannerName):
2254 
    """
2255 
    Parameters:
2256 
     - bannerName
2257 
    """
2258 
    self.send_deleteBannerMap(bannerName)
2259 
    return self.recv_deleteBannerMap()
2260 
 
2261 
  def send_deleteBannerMap(self, bannerName):
2262 
    self._oprot.writeMessageBegin('deleteBannerMap', TMessageType.CALL, self._seqid)
2263 
    args = deleteBannerMap_args()
2264 
    args.bannerName = bannerName
2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
2269 
  def recv_deleteBannerMap(self, ):
2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
2276 
    result = deleteBannerMap_result()
2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
2279 
    if result.success is not None:
2280 
      return result.success
2281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteBannerMap failed: unknown result");
2282 
 
2283 
  def getBannerMapDetails(self, bannerName):
2284 
    """
2285 
    Parameters:
2286 
     - bannerName
2287 
    """
2288 
    self.send_getBannerMapDetails(bannerName)
2289 
    return self.recv_getBannerMapDetails()
2290 
 
2291 
  def send_getBannerMapDetails(self, bannerName):
2292 
    self._oprot.writeMessageBegin('getBannerMapDetails', TMessageType.CALL, self._seqid)
2293 
    args = getBannerMapDetails_args()
2294 
    args.bannerName = bannerName
2295 
    args.write(self._oprot)
2296 
    self._oprot.writeMessageEnd()
2297 
    self._oprot.trans.flush()
2298 
 
2299 
  def recv_getBannerMapDetails(self, ):
2300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2301 
    if mtype == TMessageType.EXCEPTION:
2302 
      x = TApplicationException()
2303 
      x.read(self._iprot)
2304 
      self._iprot.readMessageEnd()
2305 
      raise x
2306 
    result = getBannerMapDetails_result()
2307 
    result.read(self._iprot)
2308 
    self._iprot.readMessageEnd()
2309 
    if result.success is not None:
2310 
      return result.success
2311 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBannerMapDetails failed: unknown result");
2312 
 
5944 mandeep.dh 2313 
  def deleteSimilarItem(self, itemId, catalogItemId):
2314 
    """
2315 
    Delete similar item.
2316 
 
2317 
    Parameters:
2318 
     - itemId
2319 
     - catalogItemId
2320 
    """
2321 
    self.send_deleteSimilarItem(itemId, catalogItemId)
2322 
    return self.recv_deleteSimilarItem()
2323 
 
2324 
  def send_deleteSimilarItem(self, itemId, catalogItemId):
2325 
    self._oprot.writeMessageBegin('deleteSimilarItem', TMessageType.CALL, self._seqid)
2326 
    args = deleteSimilarItem_args()
2327 
    args.itemId = itemId
2328 
    args.catalogItemId = catalogItemId
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
2333 
  def recv_deleteSimilarItem(self, ):
2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
2340 
    result = deleteSimilarItem_result()
2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
2343 
    if result.success is not None:
2344 
      return result.success
2345 
    if result.cex is not None:
2346 
      raise result.cex
2347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteSimilarItem failed: unknown result");
2348 
 
2349 
  def checkSimilarItem(self, brand, modelNumber, modelName, color):
2350 
    """
2351 
    Checks if similar item exists (with same Brand, ModelNumber, ModelName, Color)
2352 
    If yes, returns the itemId else returns 0
2353 
 
2354 
    Parameters:
2355 
     - brand
2356 
     - modelNumber
2357 
     - modelName
2358 
     - color
2359 
    """
2360 
    self.send_checkSimilarItem(brand, modelNumber, modelName, color)
2361 
    return self.recv_checkSimilarItem()
2362 
 
2363 
  def send_checkSimilarItem(self, brand, modelNumber, modelName, color):
2364 
    self._oprot.writeMessageBegin('checkSimilarItem', TMessageType.CALL, self._seqid)
2365 
    args = checkSimilarItem_args()
2366 
    args.brand = brand
2367 
    args.modelNumber = modelNumber
2368 
    args.modelName = modelName
2369 
    args.color = color
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_checkSimilarItem(self, ):
2375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2376 
    if mtype == TMessageType.EXCEPTION:
2377 
      x = TApplicationException()
2378 
      x.read(self._iprot)
2379 
      self._iprot.readMessageEnd()
2380 
      raise x
2381 
    result = checkSimilarItem_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
2384 
    if result.success is not None:
2385 
      return result.success
2386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkSimilarItem failed: unknown result");
2387 
 
2388 
  def validateRiskyStatus(self, itemId):
2389 
    """
2390 
    Check wether item is risky and change status if inventory is not available for risky items
2391 
 
2392 
    Parameters:
2393 
     - itemId
2394 
    """
2395 
    self.send_validateRiskyStatus(itemId)
2396 
    self.recv_validateRiskyStatus()
2397 
 
2398 
  def send_validateRiskyStatus(self, itemId):
2399 
    self._oprot.writeMessageBegin('validateRiskyStatus', TMessageType.CALL, self._seqid)
2400 
    args = validateRiskyStatus_args()
2401 
    args.itemId = itemId
2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
2406 
  def recv_validateRiskyStatus(self, ):
2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
2413 
    result = validateRiskyStatus_result()
2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
2416 
    return
2417 
 
2418 
  def changeItemRiskyFlag(self, itemId, risky):
2419 
    """
2420 
    Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
2421 
 
2422 
    Parameters:
2423 
     - itemId
2424 
     - risky
2425 
    """
2426 
    self.send_changeItemRiskyFlag(itemId, risky)
2427 
    self.recv_changeItemRiskyFlag()
2428 
 
2429 
  def send_changeItemRiskyFlag(self, itemId, risky):
2430 
    self._oprot.writeMessageBegin('changeItemRiskyFlag', TMessageType.CALL, self._seqid)
2431 
    args = changeItemRiskyFlag_args()
2432 
    args.itemId = itemId
2433 
    args.risky = risky
2434 
    args.write(self._oprot)
2435 
    self._oprot.writeMessageEnd()
2436 
    self._oprot.trans.flush()
2437 
 
2438 
  def recv_changeItemRiskyFlag(self, ):
2439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2440 
    if mtype == TMessageType.EXCEPTION:
2441 
      x = TApplicationException()
2442 
      x.read(self._iprot)
2443 
      self._iprot.readMessageEnd()
2444 
      raise x
2445 
    result = changeItemRiskyFlag_result()
2446 
    result.read(self._iprot)
2447 
    self._iprot.readMessageEnd()
2448 
    return
2449 
 
2450 
  def getItemsByRiskyFlag(self, ):
2451 
    """
2452 
    Returns list of items marked as risky.
2453 
    """
2454 
    self.send_getItemsByRiskyFlag()
2455 
    return self.recv_getItemsByRiskyFlag()
2456 
 
2457 
  def send_getItemsByRiskyFlag(self, ):
2458 
    self._oprot.writeMessageBegin('getItemsByRiskyFlag', TMessageType.CALL, self._seqid)
2459 
    args = getItemsByRiskyFlag_args()
2460 
    args.write(self._oprot)
2461 
    self._oprot.writeMessageEnd()
2462 
    self._oprot.trans.flush()
2463 
 
2464 
  def recv_getItemsByRiskyFlag(self, ):
2465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2466 
    if mtype == TMessageType.EXCEPTION:
2467 
      x = TApplicationException()
2468 
      x.read(self._iprot)
2469 
      self._iprot.readMessageEnd()
2470 
      raise x
2471 
    result = getItemsByRiskyFlag_result()
2472 
    result.read(self._iprot)
2473 
    self._iprot.readMessageEnd()
2474 
    if result.success is not None:
2475 
      return result.success
2476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsByRiskyFlag failed: unknown result");
2477 
 
2478 
  def getItemsForMasterSheet(self, category, brand):
2479 
    """
2480 
    Returns list of items with any status except PHASED_OUT and filtered by category, brand.
2481 
 
2482 
    Parameters:
2483 
     - category
2484 
     - brand
2485 
    """
2486 
    self.send_getItemsForMasterSheet(category, brand)
2487 
    return self.recv_getItemsForMasterSheet()
2488 
 
2489 
  def send_getItemsForMasterSheet(self, category, brand):
2490 
    self._oprot.writeMessageBegin('getItemsForMasterSheet', TMessageType.CALL, self._seqid)
2491 
    args = getItemsForMasterSheet_args()
2492 
    args.category = category
2493 
    args.brand = brand
2494 
    args.write(self._oprot)
2495 
    self._oprot.writeMessageEnd()
2496 
    self._oprot.trans.flush()
2497 
 
2498 
  def recv_getItemsForMasterSheet(self, ):
2499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2500 
    if mtype == TMessageType.EXCEPTION:
2501 
      x = TApplicationException()
2502 
      x.read(self._iprot)
2503 
      self._iprot.readMessageEnd()
2504 
      raise x
2505 
    result = getItemsForMasterSheet_result()
2506 
    result.read(self._iprot)
2507 
    self._iprot.readMessageEnd()
2508 
    if result.success is not None:
2509 
      return result.success
2510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsForMasterSheet failed: unknown result");
2511 
 
2512 
  def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2513 
    """
2514 
    Returns list of catalog ids of items with same similarity index as of the given itemId
2515 
 
2516 
    Parameters:
2517 
     - beginIndex
2518 
     - totalItems
2519 
     - itemId
2520 
    """
2521 
    self.send_getSimilarItemsCatalogIds(beginIndex, totalItems, itemId)
2522 
    return self.recv_getSimilarItemsCatalogIds()
2523 
 
2524 
  def send_getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
2525 
    self._oprot.writeMessageBegin('getSimilarItemsCatalogIds', TMessageType.CALL, self._seqid)
2526 
    args = getSimilarItemsCatalogIds_args()
2527 
    args.beginIndex = beginIndex
2528 
    args.totalItems = totalItems
2529 
    args.itemId = itemId
2530 
    args.write(self._oprot)
2531 
    self._oprot.writeMessageEnd()
2532 
    self._oprot.trans.flush()
2533 
 
2534 
  def recv_getSimilarItemsCatalogIds(self, ):
2535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2536 
    if mtype == TMessageType.EXCEPTION:
2537 
      x = TApplicationException()
2538 
      x.read(self._iprot)
2539 
      self._iprot.readMessageEnd()
2540 
      raise x
2541 
    result = getSimilarItemsCatalogIds_result()
2542 
    result.read(self._iprot)
2543 
    self._iprot.readMessageEnd()
2544 
    if result.success is not None:
2545 
      return result.success
2546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSimilarItemsCatalogIds failed: unknown result");
2547 
 
2548 
  def addProductNotification(self, itemId, email):
2549 
    """
2550 
    Add user requests for out of stock items. Once user will ask for notify me an entry will
2551 
 
2552 
    Parameters:
2553 
     - itemId
2554 
     - email
2555 
    """
2556 
    self.send_addProductNotification(itemId, email)
2557 
    return self.recv_addProductNotification()
2558 
 
2559 
  def send_addProductNotification(self, itemId, email):
2560 
    self._oprot.writeMessageBegin('addProductNotification', TMessageType.CALL, self._seqid)
2561 
    args = addProductNotification_args()
2562 
    args.itemId = itemId
2563 
    args.email = email
2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
2568 
  def recv_addProductNotification(self, ):
2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
2575 
    result = addProductNotification_result()
2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
2578 
    if result.success is not None:
2579 
      return result.success
2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addProductNotification failed: unknown result");
2581 
 
2582 
  def sendProductNotifications(self, ):
2583 
    """
2584 
    Send the product notifications to the users for items which has stock.
2585 
    """
2586 
    self.send_sendProductNotifications()
2587 
    return self.recv_sendProductNotifications()
2588 
 
2589 
  def send_sendProductNotifications(self, ):
2590 
    self._oprot.writeMessageBegin('sendProductNotifications', TMessageType.CALL, self._seqid)
2591 
    args = sendProductNotifications_args()
2592 
    args.write(self._oprot)
2593 
    self._oprot.writeMessageEnd()
2594 
    self._oprot.trans.flush()
2595 
 
2596 
  def recv_sendProductNotifications(self, ):
2597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2598 
    if mtype == TMessageType.EXCEPTION:
2599 
      x = TApplicationException()
2600 
      x.read(self._iprot)
2601 
      self._iprot.readMessageEnd()
2602 
      raise x
2603 
    result = sendProductNotifications_result()
2604 
    result.read(self._iprot)
2605 
    self._iprot.readMessageEnd()
2606 
    if result.success is not None:
2607 
      return result.success
2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "sendProductNotifications failed: unknown result");
2609 
 
2610 
  def getAllBrandsByCategory(self, categoryId):
2611 
    """
2612 
    Returns list of brand names for a given category Id
2613 
 
2614 
    Parameters:
2615 
     - categoryId
2616 
    """
2617 
    self.send_getAllBrandsByCategory(categoryId)
2618 
    return self.recv_getAllBrandsByCategory()
2619 
 
2620 
  def send_getAllBrandsByCategory(self, categoryId):
2621 
    self._oprot.writeMessageBegin('getAllBrandsByCategory', TMessageType.CALL, self._seqid)
2622 
    args = getAllBrandsByCategory_args()
2623 
    args.categoryId = categoryId
2624 
    args.write(self._oprot)
2625 
    self._oprot.writeMessageEnd()
2626 
    self._oprot.trans.flush()
2627 
 
2628 
  def recv_getAllBrandsByCategory(self, ):
2629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2630 
    if mtype == TMessageType.EXCEPTION:
2631 
      x = TApplicationException()
2632 
      x.read(self._iprot)
2633 
      self._iprot.readMessageEnd()
2634 
      raise x
2635 
    result = getAllBrandsByCategory_result()
2636 
    result.read(self._iprot)
2637 
    self._iprot.readMessageEnd()
2638 
    if result.success is not None:
2639 
      return result.success
2640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrandsByCategory failed: unknown result");
2641 
 
2642 
  def getAllBrands(self, ):
2643 
    """
2644 
    Returns list of brand names
2645 
    """
2646 
    self.send_getAllBrands()
2647 
    return self.recv_getAllBrands()
2648 
 
2649 
  def send_getAllBrands(self, ):
2650 
    self._oprot.writeMessageBegin('getAllBrands', TMessageType.CALL, self._seqid)
2651 
    args = getAllBrands_args()
2652 
    args.write(self._oprot)
2653 
    self._oprot.writeMessageEnd()
2654 
    self._oprot.trans.flush()
2655 
 
2656 
  def recv_getAllBrands(self, ):
2657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2658 
    if mtype == TMessageType.EXCEPTION:
2659 
      x = TApplicationException()
2660 
      x.read(self._iprot)
2661 
      self._iprot.readMessageEnd()
2662 
      raise x
2663 
    result = getAllBrands_result()
2664 
    result.read(self._iprot)
2665 
    self._iprot.readMessageEnd()
2666 
    if result.success is not None:
2667 
      return result.success
2668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllBrands failed: unknown result");
2669 
 
2670 
  def getAllSources(self, ):
2671 
    """
2672 
    Return list of all sources
2673 
    """
2674 
    self.send_getAllSources()
2675 
    return self.recv_getAllSources()
2676 
 
2677 
  def send_getAllSources(self, ):
2678 
    self._oprot.writeMessageBegin('getAllSources', TMessageType.CALL, self._seqid)
2679 
    args = getAllSources_args()
2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2684 
  def recv_getAllSources(self, ):
2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2691 
    result = getAllSources_result()
2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success is not None:
2695 
      return result.success
2696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSources failed: unknown result");
2697 
 
2698 
  def getItemPricingBySource(self, itemId, sourceId):
2699 
    """
2700 
    Returns the pricing information of an item. If no information is found, exception will be thrown.
2701 
 
2702 
    Parameters:
2703 
     - itemId
2704 
     - sourceId
2705 
    """
2706 
    self.send_getItemPricingBySource(itemId, sourceId)
2707 
    return self.recv_getItemPricingBySource()
2708 
 
2709 
  def send_getItemPricingBySource(self, itemId, sourceId):
2710 
    self._oprot.writeMessageBegin('getItemPricingBySource', TMessageType.CALL, self._seqid)
2711 
    args = getItemPricingBySource_args()
2712 
    args.itemId = itemId
2713 
    args.sourceId = sourceId
2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2718 
  def recv_getItemPricingBySource(self, ):
2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2725 
    result = getItemPricingBySource_result()
2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success is not None:
2729 
      return result.success
2730 
    if result.cex is not None:
2731 
      raise result.cex
2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricingBySource failed: unknown result");
2733 
 
2734 
  def addSourceItemPricing(self, sourceItemPricing):
2735 
    """
2736 
    Adds prices to be displayed corresponding to the item if user comes from a source.
2737 
    If item is not found or source is not found, it will throw exception.
2738 
 
2739 
    Parameters:
2740 
     - sourceItemPricing
2741 
    """
2742 
    self.send_addSourceItemPricing(sourceItemPricing)
2743 
    self.recv_addSourceItemPricing()
2744 
 
2745 
  def send_addSourceItemPricing(self, sourceItemPricing):
2746 
    self._oprot.writeMessageBegin('addSourceItemPricing', TMessageType.CALL, self._seqid)
2747 
    args = addSourceItemPricing_args()
2748 
    args.sourceItemPricing = sourceItemPricing
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_addSourceItemPricing(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = addSourceItemPricing_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.cex is not None:
2764 
      raise result.cex
2765 
    return
2766 
 
2767 
  def getAllSourcePricing(self, itemId):
2768 
    """
2769 
    Returns the list of source pricing information of an item.
2770 
    Raises an exception if item not found corresponding to itemId
2771 
 
2772 
    Parameters:
2773 
     - itemId
2774 
    """
2775 
    self.send_getAllSourcePricing(itemId)
2776 
    return self.recv_getAllSourcePricing()
2777 
 
2778 
  def send_getAllSourcePricing(self, itemId):
2779 
    self._oprot.writeMessageBegin('getAllSourcePricing', TMessageType.CALL, self._seqid)
2780 
    args = getAllSourcePricing_args()
2781 
    args.itemId = itemId
2782 
    args.write(self._oprot)
2783 
    self._oprot.writeMessageEnd()
2784 
    self._oprot.trans.flush()
2785 
 
2786 
  def recv_getAllSourcePricing(self, ):
2787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2788 
    if mtype == TMessageType.EXCEPTION:
2789 
      x = TApplicationException()
2790 
      x.read(self._iprot)
2791 
      self._iprot.readMessageEnd()
2792 
      raise x
2793 
    result = getAllSourcePricing_result()
2794 
    result.read(self._iprot)
2795 
    self._iprot.readMessageEnd()
2796 
    if result.success is not None:
2797 
      return result.success
2798 
    if result.cex is not None:
2799 
      raise result.cex
2800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllSourcePricing failed: unknown result");
2801 
 
2802 
  def getItemForSource(self, item_id, sourceId):
2803 
    """
2804 
    Get the item for a given itemId and sourceId. MRP and sellingPrice will be updated for source if we have different prices for source.
2805 
 
2806 
    Parameters:
2807 
     - item_id
2808 
     - sourceId
2809 
    """
2810 
    self.send_getItemForSource(item_id, sourceId)
2811 
    return self.recv_getItemForSource()
2812 
 
2813 
  def send_getItemForSource(self, item_id, sourceId):
2814 
    self._oprot.writeMessageBegin('getItemForSource', TMessageType.CALL, self._seqid)
2815 
    args = getItemForSource_args()
2816 
    args.item_id = item_id
2817 
    args.sourceId = sourceId
2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2822 
  def recv_getItemForSource(self, ):
2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2829 
    result = getItemForSource_result()
2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success is not None:
2833 
      return result.success
2834 
    if result.cex is not None:
2835 
      raise result.cex
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemForSource failed: unknown result");
2837 
 
2838 
  def searchItemsInRange(self, searchTerms, offset, limit):
2839 
    """
2840 
    Searches items matching the the given terms in the catalog and returns results within the specified range.
2841 
 
2842 
    Parameters:
2843 
     - searchTerms
2844 
     - offset
2845 
     - limit
2846 
    """
2847 
    self.send_searchItemsInRange(searchTerms, offset, limit)
2848 
    return self.recv_searchItemsInRange()
2849 
 
2850 
  def send_searchItemsInRange(self, searchTerms, offset, limit):
2851 
    self._oprot.writeMessageBegin('searchItemsInRange', TMessageType.CALL, self._seqid)
2852 
    args = searchItemsInRange_args()
2853 
    args.searchTerms = searchTerms
2854 
    args.offset = offset
2855 
    args.limit = limit
2856 
    args.write(self._oprot)
2857 
    self._oprot.writeMessageEnd()
2858 
    self._oprot.trans.flush()
2859 
 
2860 
  def recv_searchItemsInRange(self, ):
2861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2862 
    if mtype == TMessageType.EXCEPTION:
2863 
      x = TApplicationException()
2864 
      x.read(self._iprot)
2865 
      self._iprot.readMessageEnd()
2866 
      raise x
2867 
    result = searchItemsInRange_result()
2868 
    result.read(self._iprot)
2869 
    self._iprot.readMessageEnd()
2870 
    if result.success is not None:
2871 
      return result.success
2872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "searchItemsInRange failed: unknown result");
2873 
 
2874 
  def getSearchResultCount(self, searchTerms):
2875 
    """
2876 
    Gets the count of search results for the given search terms so that the user can go through all the pages.
2877 
 
2878 
    Parameters:
2879 
     - searchTerms
2880 
    """
2881 
    self.send_getSearchResultCount(searchTerms)
2882 
    return self.recv_getSearchResultCount()
2883 
 
2884 
  def send_getSearchResultCount(self, searchTerms):
2885 
    self._oprot.writeMessageBegin('getSearchResultCount', TMessageType.CALL, self._seqid)
2886 
    args = getSearchResultCount_args()
2887 
    args.searchTerms = searchTerms
2888 
    args.write(self._oprot)
2889 
    self._oprot.writeMessageEnd()
2890 
    self._oprot.trans.flush()
2891 
 
2892 
  def recv_getSearchResultCount(self, ):
2893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2894 
    if mtype == TMessageType.EXCEPTION:
2895 
      x = TApplicationException()
2896 
      x.read(self._iprot)
2897 
      self._iprot.readMessageEnd()
2898 
      raise x
2899 
    result = getSearchResultCount_result()
2900 
    result.read(self._iprot)
2901 
    self._iprot.readMessageEnd()
2902 
    if result.success is not None:
2903 
      return result.success
2904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSearchResultCount failed: unknown result");
2905 
 
2906 
  def getProductNotifications(self, startDateTime):
2907 
    """
2908 
    Returns a list of product notifications added after a supplied datetime
2909 
 
2910 
    Parameters:
2911 
     - startDateTime
2912 
    """
2913 
    self.send_getProductNotifications(startDateTime)
2914 
    return self.recv_getProductNotifications()
2915 
 
2916 
  def send_getProductNotifications(self, startDateTime):
2917 
    self._oprot.writeMessageBegin('getProductNotifications', TMessageType.CALL, self._seqid)
2918 
    args = getProductNotifications_args()
2919 
    args.startDateTime = startDateTime
2920 
    args.write(self._oprot)
2921 
    self._oprot.writeMessageEnd()
2922 
    self._oprot.trans.flush()
2923 
 
2924 
  def recv_getProductNotifications(self, ):
2925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2926 
    if mtype == TMessageType.EXCEPTION:
2927 
      x = TApplicationException()
2928 
      x.read(self._iprot)
2929 
      self._iprot.readMessageEnd()
2930 
      raise x
2931 
    result = getProductNotifications_result()
2932 
    result.read(self._iprot)
2933 
    self._iprot.readMessageEnd()
2934 
    if result.success is not None:
2935 
      return result.success
2936 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotifications failed: unknown result");
2937 
 
2938 
  def getProductNotificationRequestCount(self, startDateTime):
2939 
    """
2940 
    Returns a list of count of requests for product notification against each item
2941 
 
2942 
    Parameters:
2943 
     - startDateTime
2944 
    """
2945 
    self.send_getProductNotificationRequestCount(startDateTime)
2946 
    return self.recv_getProductNotificationRequestCount()
2947 
 
2948 
  def send_getProductNotificationRequestCount(self, startDateTime):
2949 
    self._oprot.writeMessageBegin('getProductNotificationRequestCount', TMessageType.CALL, self._seqid)
2950 
    args = getProductNotificationRequestCount_args()
2951 
    args.startDateTime = startDateTime
2952 
    args.write(self._oprot)
2953 
    self._oprot.writeMessageEnd()
2954 
    self._oprot.trans.flush()
2955 
 
2956 
  def recv_getProductNotificationRequestCount(self, ):
2957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2958 
    if mtype == TMessageType.EXCEPTION:
2959 
      x = TApplicationException()
2960 
      x.read(self._iprot)
2961 
      self._iprot.readMessageEnd()
2962 
      raise x
2963 
    result = getProductNotificationRequestCount_result()
2964 
    result.read(self._iprot)
2965 
    self._iprot.readMessageEnd()
2966 
    if result.success is not None:
2967 
      return result.success
2968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getProductNotificationRequestCount failed: unknown result");
2969 
 
2970 
  def addAuthorizationLog(self, itemId, username, reason):
2971 
    """
2972 
    This method adds a log to authorize table with Item Id, username who authorized the change, reason.
2973 
 
2974 
    Parameters:
2975 
     - itemId
2976 
     - username
2977 
     - reason
2978 
    """
2979 
    self.send_addAuthorizationLog(itemId, username, reason)
2980 
    return self.recv_addAuthorizationLog()
2981 
 
2982 
  def send_addAuthorizationLog(self, itemId, username, reason):
2983 
    self._oprot.writeMessageBegin('addAuthorizationLog', TMessageType.CALL, self._seqid)
2984 
    args = addAuthorizationLog_args()
2985 
    args.itemId = itemId
2986 
    args.username = username
2987 
    args.reason = reason
2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
2992 
  def recv_addAuthorizationLog(self, ):
2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
2999 
    result = addAuthorizationLog_result()
3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
3002 
    if result.success is not None:
3003 
      return result.success
3004 
    if result.cex is not None:
3005 
      raise result.cex
3006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAuthorizationLog failed: unknown result");
3007 
 
3008 
  def addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3009 
    """
3010 
    Parameters:
3011 
     - catalog_item_id
3012 
     - voucherType
3013 
     - voucherAmount
3014 
    """
3015 
    self.send_addupdateVoucherForItem(catalog_item_id, voucherType, voucherAmount)
3016 
    return self.recv_addupdateVoucherForItem()
3017 
 
3018 
  def send_addupdateVoucherForItem(self, catalog_item_id, voucherType, voucherAmount):
3019 
    self._oprot.writeMessageBegin('addupdateVoucherForItem', TMessageType.CALL, self._seqid)
3020 
    args = addupdateVoucherForItem_args()
3021 
    args.catalog_item_id = catalog_item_id
3022 
    args.voucherType = voucherType
3023 
    args.voucherAmount = voucherAmount
3024 
    args.write(self._oprot)
3025 
    self._oprot.writeMessageEnd()
3026 
    self._oprot.trans.flush()
3027 
 
3028 
  def recv_addupdateVoucherForItem(self, ):
3029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3030 
    if mtype == TMessageType.EXCEPTION:
3031 
      x = TApplicationException()
3032 
      x.read(self._iprot)
3033 
      self._iprot.readMessageEnd()
3034 
      raise x
3035 
    result = addupdateVoucherForItem_result()
3036 
    result.read(self._iprot)
3037 
    self._iprot.readMessageEnd()
3038 
    if result.success is not None:
3039 
      return result.success
3040 
    if result.cex is not None:
3041 
      raise result.cex
3042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addupdateVoucherForItem failed: unknown result");
3043 
 
3044 
  def deleteVoucherForItem(self, catalog_item_id, voucherType):
3045 
    """
3046 
    Parameters:
3047 
     - catalog_item_id
3048 
     - voucherType
3049 
    """
3050 
    self.send_deleteVoucherForItem(catalog_item_id, voucherType)
3051 
    return self.recv_deleteVoucherForItem()
3052 
 
3053 
  def send_deleteVoucherForItem(self, catalog_item_id, voucherType):
3054 
    self._oprot.writeMessageBegin('deleteVoucherForItem', TMessageType.CALL, self._seqid)
3055 
    args = deleteVoucherForItem_args()
3056 
    args.catalog_item_id = catalog_item_id
3057 
    args.voucherType = voucherType
3058 
    args.write(self._oprot)
3059 
    self._oprot.writeMessageEnd()
3060 
    self._oprot.trans.flush()
3061 
 
3062 
  def recv_deleteVoucherForItem(self, ):
3063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3064 
    if mtype == TMessageType.EXCEPTION:
3065 
      x = TApplicationException()
3066 
      x.read(self._iprot)
3067 
      self._iprot.readMessageEnd()
3068 
      raise x
3069 
    result = deleteVoucherForItem_result()
3070 
    result.read(self._iprot)
3071 
    self._iprot.readMessageEnd()
3072 
    if result.success is not None:
3073 
      return result.success
3074 
    if result.cex is not None:
3075 
      raise result.cex
3076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteVoucherForItem failed: unknown result");
3077 
 
3078 
  def getVoucherAmount(self, itemId, voucherType):
3079 
    """
3080 
    Parameters:
3081 
     - itemId
3082 
     - voucherType
3083 
    """
3084 
    self.send_getVoucherAmount(itemId, voucherType)
3085 
    return self.recv_getVoucherAmount()
3086 
 
3087 
  def send_getVoucherAmount(self, itemId, voucherType):
3088 
    self._oprot.writeMessageBegin('getVoucherAmount', TMessageType.CALL, self._seqid)
3089 
    args = getVoucherAmount_args()
3090 
    args.itemId = itemId
3091 
    args.voucherType = voucherType
3092 
    args.write(self._oprot)
3093 
    self._oprot.writeMessageEnd()
3094 
    self._oprot.trans.flush()
3095 
 
3096 
  def recv_getVoucherAmount(self, ):
3097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3098 
    if mtype == TMessageType.EXCEPTION:
3099 
      x = TApplicationException()
3100 
      x.read(self._iprot)
3101 
      self._iprot.readMessageEnd()
3102 
      raise x
3103 
    result = getVoucherAmount_result()
3104 
    result.read(self._iprot)
3105 
    self._iprot.readMessageEnd()
3106 
    if result.success is not None:
3107 
      return result.success
3108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVoucherAmount failed: unknown result");
3109 
 
3110 
  def getAllItemVouchers(self, itemId):
3111 
    """
3112 
    Parameters:
3113 
     - itemId
3114 
    """
3115 
    self.send_getAllItemVouchers(itemId)
3116 
    return self.recv_getAllItemVouchers()
3117 
 
3118 
  def send_getAllItemVouchers(self, itemId):
3119 
    self._oprot.writeMessageBegin('getAllItemVouchers', TMessageType.CALL, self._seqid)
3120 
    args = getAllItemVouchers_args()
3121 
    args.itemId = itemId
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_getAllItemVouchers(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = getAllItemVouchers_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.success is not None:
3137 
      return result.success
3138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemVouchers failed: unknown result");
3139 
 
3140 
  def isValidCatalogItemId(self, catalog_item_id):
3141 
    """
3142 
    Parameters:
3143 
     - catalog_item_id
3144 
    """
3145 
    self.send_isValidCatalogItemId(catalog_item_id)
3146 
    return self.recv_isValidCatalogItemId()
3147 
 
3148 
  def send_isValidCatalogItemId(self, catalog_item_id):
3149 
    self._oprot.writeMessageBegin('isValidCatalogItemId', TMessageType.CALL, self._seqid)
3150 
    args = isValidCatalogItemId_args()
3151 
    args.catalog_item_id = catalog_item_id
3152 
    args.write(self._oprot)
3153 
    self._oprot.writeMessageEnd()
3154 
    self._oprot.trans.flush()
3155 
 
3156 
  def recv_isValidCatalogItemId(self, ):
3157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3158 
    if mtype == TMessageType.EXCEPTION:
3159 
      x = TApplicationException()
3160 
      x.read(self._iprot)
3161 
      self._iprot.readMessageEnd()
3162 
      raise x
3163 
    result = isValidCatalogItemId_result()
3164 
    result.read(self._iprot)
3165 
    self._iprot.readMessageEnd()
3166 
    if result.success is not None:
3167 
      return result.success
3168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isValidCatalogItemId failed: unknown result");
3169 
 
7330 amit.gupta 3170 
  def getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3171 
    """
3172 
    Parameters:
3173 
     - itemId
7330 amit.gupta 3174 
     - stateId
6039 amit.gupta 3175 
     - price
3176 
    """
7330 amit.gupta 3177 
    self.send_getVatPercentageForItem(itemId, stateId, price)
6039 amit.gupta 3178 
    return self.recv_getVatPercentageForItem()
5944 mandeep.dh 3179 
 
7330 amit.gupta 3180 
  def send_getVatPercentageForItem(self, itemId, stateId, price):
6039 amit.gupta 3181 
    self._oprot.writeMessageBegin('getVatPercentageForItem', TMessageType.CALL, self._seqid)
3182 
    args = getVatPercentageForItem_args()
3183 
    args.itemId = itemId
7330 amit.gupta 3184 
    args.stateId = stateId
6039 amit.gupta 3185 
    args.price = price
3186 
    args.write(self._oprot)
3187 
    self._oprot.writeMessageEnd()
3188 
    self._oprot.trans.flush()
3189 
 
3190 
  def recv_getVatPercentageForItem(self, ):
3191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3192 
    if mtype == TMessageType.EXCEPTION:
3193 
      x = TApplicationException()
3194 
      x.read(self._iprot)
3195 
      self._iprot.readMessageEnd()
3196 
      raise x
3197 
    result = getVatPercentageForItem_result()
3198 
    result.read(self._iprot)
3199 
    self._iprot.readMessageEnd()
3200 
    if result.success is not None:
3201 
      return result.success
7340 amit.gupta 3202 
    if result.cex is not None:
3203 
      raise result.cex
6039 amit.gupta 3204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatPercentageForItem failed: unknown result");
3205 
 
3206 
  def getVatAmountForItem(self, itemId, price):
3207 
    """
3208 
    Parameters:
3209 
     - itemId
3210 
     - price
3211 
    """
3212 
    self.send_getVatAmountForItem(itemId, price)
3213 
    return self.recv_getVatAmountForItem()
3214 
 
3215 
  def send_getVatAmountForItem(self, itemId, price):
3216 
    self._oprot.writeMessageBegin('getVatAmountForItem', TMessageType.CALL, self._seqid)
3217 
    args = getVatAmountForItem_args()
3218 
    args.itemId = itemId
3219 
    args.price = price
3220 
    args.write(self._oprot)
3221 
    self._oprot.writeMessageEnd()
3222 
    self._oprot.trans.flush()
3223 
 
3224 
  def recv_getVatAmountForItem(self, ):
3225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3226 
    if mtype == TMessageType.EXCEPTION:
3227 
      x = TApplicationException()
3228 
      x.read(self._iprot)
3229 
      self._iprot.readMessageEnd()
3230 
      raise x
3231 
    result = getVatAmountForItem_result()
3232 
    result.read(self._iprot)
3233 
    self._iprot.readMessageEnd()
3234 
    if result.success is not None:
3235 
      return result.success
3236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVatAmountForItem failed: unknown result");
3237 
 
6531 vikram.rag 3238 
  def getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3239 
    """
3240 
    Parameters:
3241 
     - offset
3242 
     - limit
3243 
    """
3244 
    self.send_getAllIgnoredInventoryUpdateItemsList(offset, limit)
3245 
    return self.recv_getAllIgnoredInventoryUpdateItemsList()
6039 amit.gupta 3246 
 
6531 vikram.rag 3247 
  def send_getAllIgnoredInventoryUpdateItemsList(self, offset, limit):
3248 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryUpdateItemsList', TMessageType.CALL, self._seqid)
3249 
    args = getAllIgnoredInventoryUpdateItemsList_args()
3250 
    args.offset = offset
3251 
    args.limit = limit
3252 
    args.write(self._oprot)
3253 
    self._oprot.writeMessageEnd()
3254 
    self._oprot.trans.flush()
3255 
 
3256 
  def recv_getAllIgnoredInventoryUpdateItemsList(self, ):
3257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3258 
    if mtype == TMessageType.EXCEPTION:
3259 
      x = TApplicationException()
3260 
      x.read(self._iprot)
3261 
      self._iprot.readMessageEnd()
3262 
      raise x
3263 
    result = getAllIgnoredInventoryUpdateItemsList_result()
3264 
    result.read(self._iprot)
3265 
    self._iprot.readMessageEnd()
3266 
    if result.success is not None:
3267 
      return result.success
3268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryUpdateItemsList failed: unknown result");
3269 
 
6821 amar.kumar 3270 
  def getAllAliveItems(self, ):
3271 
    self.send_getAllAliveItems()
3272 
    return self.recv_getAllAliveItems()
3273 
 
3274 
  def send_getAllAliveItems(self, ):
3275 
    self._oprot.writeMessageBegin('getAllAliveItems', TMessageType.CALL, self._seqid)
3276 
    args = getAllAliveItems_args()
3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_getAllAliveItems(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = getAllAliveItems_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
3291 
    if result.success is not None:
3292 
      return result.success
3293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAliveItems failed: unknown result");
3294 
 
6921 anupam.sin 3295 
  def getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3296 
    """
3297 
    This method returns the insurance amount needed to insure the given item for a given quantity.
6531 vikram.rag 3298 
 
6805 anupam.sin 3299 
    Parameters:
3300 
     - itemId
6921 anupam.sin 3301 
     - price
6805 anupam.sin 3302 
     - insurerId
3303 
     - quantity
3304 
    """
6921 anupam.sin 3305 
    self.send_getInsuranceAmount(itemId, price, insurerId, quantity)
6805 anupam.sin 3306 
    return self.recv_getInsuranceAmount()
3307 
 
6921 anupam.sin 3308 
  def send_getInsuranceAmount(self, itemId, price, insurerId, quantity):
6805 anupam.sin 3309 
    self._oprot.writeMessageBegin('getInsuranceAmount', TMessageType.CALL, self._seqid)
3310 
    args = getInsuranceAmount_args()
3311 
    args.itemId = itemId
6921 anupam.sin 3312 
    args.price = price
6805 anupam.sin 3313 
    args.insurerId = insurerId
3314 
    args.quantity = quantity
3315 
    args.write(self._oprot)
3316 
    self._oprot.writeMessageEnd()
3317 
    self._oprot.trans.flush()
3318 
 
3319 
  def recv_getInsuranceAmount(self, ):
3320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3321 
    if mtype == TMessageType.EXCEPTION:
3322 
      x = TApplicationException()
3323 
      x.read(self._iprot)
3324 
      self._iprot.readMessageEnd()
3325 
      raise x
3326 
    result = getInsuranceAmount_result()
3327 
    result.read(self._iprot)
3328 
    self._iprot.readMessageEnd()
3329 
    if result.success is not None:
3330 
      return result.success
3331 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsuranceAmount failed: unknown result");
3332 
 
3333 
  def getInsurer(self, insurerId):
3334 
    """
3335 
    Parameters:
3336 
     - insurerId
3337 
    """
3338 
    self.send_getInsurer(insurerId)
3339 
    return self.recv_getInsurer()
3340 
 
3341 
  def send_getInsurer(self, insurerId):
3342 
    self._oprot.writeMessageBegin('getInsurer', TMessageType.CALL, self._seqid)
3343 
    args = getInsurer_args()
3344 
    args.insurerId = insurerId
3345 
    args.write(self._oprot)
3346 
    self._oprot.writeMessageEnd()
3347 
    self._oprot.trans.flush()
3348 
 
3349 
  def recv_getInsurer(self, ):
3350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3351 
    if mtype == TMessageType.EXCEPTION:
3352 
      x = TApplicationException()
3353 
      x.read(self._iprot)
3354 
      self._iprot.readMessageEnd()
3355 
      raise x
3356 
    result = getInsurer_result()
3357 
    result.read(self._iprot)
3358 
    self._iprot.readMessageEnd()
3359 
    if result.success is not None:
3360 
      return result.success
3361 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInsurer failed: unknown result");
3362 
 
6838 vikram.rag 3363 
  def getAllInsurers(self, ):
3364 
    self.send_getAllInsurers()
3365 
    return self.recv_getAllInsurers()
6805 anupam.sin 3366 
 
6838 vikram.rag 3367 
  def send_getAllInsurers(self, ):
3368 
    self._oprot.writeMessageBegin('getAllInsurers', TMessageType.CALL, self._seqid)
3369 
    args = getAllInsurers_args()
3370 
    args.write(self._oprot)
3371 
    self._oprot.writeMessageEnd()
3372 
    self._oprot.trans.flush()
3373 
 
3374 
  def recv_getAllInsurers(self, ):
3375 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3376 
    if mtype == TMessageType.EXCEPTION:
3377 
      x = TApplicationException()
3378 
      x.read(self._iprot)
3379 
      self._iprot.readMessageEnd()
3380 
      raise x
3381 
    result = getAllInsurers_result()
3382 
    result.read(self._iprot)
3383 
    self._iprot.readMessageEnd()
3384 
    if result.success is not None:
3385 
      return result.success
3386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllInsurers failed: unknown result");
3387 
 
6962 rajveer 3388 
  def updateInsuranceDeclaredAmount(self, insurerId, amount):
3389 
    """
3390 
    Parameters:
3391 
     - insurerId
3392 
     - amount
3393 
    """
3394 
    self.send_updateInsuranceDeclaredAmount(insurerId, amount)
3395 
    self.recv_updateInsuranceDeclaredAmount()
6838 vikram.rag 3396 
 
6962 rajveer 3397 
  def send_updateInsuranceDeclaredAmount(self, insurerId, amount):
3398 
    self._oprot.writeMessageBegin('updateInsuranceDeclaredAmount', TMessageType.CALL, self._seqid)
3399 
    args = updateInsuranceDeclaredAmount_args()
3400 
    args.insurerId = insurerId
3401 
    args.amount = amount
3402 
    args.write(self._oprot)
3403 
    self._oprot.writeMessageEnd()
3404 
    self._oprot.trans.flush()
3405 
 
3406 
  def recv_updateInsuranceDeclaredAmount(self, ):
3407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3408 
    if mtype == TMessageType.EXCEPTION:
3409 
      x = TApplicationException()
3410 
      x.read(self._iprot)
3411 
      self._iprot.readMessageEnd()
3412 
      raise x
3413 
    result = updateInsuranceDeclaredAmount_result()
3414 
    result.read(self._iprot)
3415 
    self._iprot.readMessageEnd()
3416 
    return
3417 
 
7190 amar.kumar 3418 
  def getFreebieForItem(self, itemId):
3419 
    """
3420 
    Parameters:
3421 
     - itemId
3422 
    """
3423 
    self.send_getFreebieForItem(itemId)
3424 
    return self.recv_getFreebieForItem()
6962 rajveer 3425 
 
7190 amar.kumar 3426 
  def send_getFreebieForItem(self, itemId):
3427 
    self._oprot.writeMessageBegin('getFreebieForItem', TMessageType.CALL, self._seqid)
3428 
    args = getFreebieForItem_args()
3429 
    args.itemId = itemId
3430 
    args.write(self._oprot)
3431 
    self._oprot.writeMessageEnd()
3432 
    self._oprot.trans.flush()
3433 
 
3434 
  def recv_getFreebieForItem(self, ):
3435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3436 
    if mtype == TMessageType.EXCEPTION:
3437 
      x = TApplicationException()
3438 
      x.read(self._iprot)
3439 
      self._iprot.readMessageEnd()
3440 
      raise x
3441 
    result = getFreebieForItem_result()
3442 
    result.read(self._iprot)
3443 
    self._iprot.readMessageEnd()
3444 
    if result.success is not None:
3445 
      return result.success
3446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFreebieForItem failed: unknown result");
3447 
 
3448 
  def addOrUpdateFreebieForItem(self, freebieItem):
3449 
    """
3450 
    Parameters:
3451 
     - freebieItem
3452 
    """
3453 
    self.send_addOrUpdateFreebieForItem(freebieItem)
3454 
    self.recv_addOrUpdateFreebieForItem()
3455 
 
3456 
  def send_addOrUpdateFreebieForItem(self, freebieItem):
3457 
    self._oprot.writeMessageBegin('addOrUpdateFreebieForItem', TMessageType.CALL, self._seqid)
3458 
    args = addOrUpdateFreebieForItem_args()
3459 
    args.freebieItem = freebieItem
3460 
    args.write(self._oprot)
3461 
    self._oprot.writeMessageEnd()
3462 
    self._oprot.trans.flush()
3463 
 
3464 
  def recv_addOrUpdateFreebieForItem(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 = addOrUpdateFreebieForItem_result()
3472 
    result.read(self._iprot)
3473 
    self._iprot.readMessageEnd()
3474 
    return
3475 
 
7272 amit.gupta 3476 
  def addOrUpdateBrandInfo(self, brandInfo):
3477 
    """
3478 
    Parameters:
3479 
     - brandInfo
3480 
    """
3481 
    self.send_addOrUpdateBrandInfo(brandInfo)
3482 
    self.recv_addOrUpdateBrandInfo()
3483 
 
3484 
  def send_addOrUpdateBrandInfo(self, brandInfo):
3485 
    self._oprot.writeMessageBegin('addOrUpdateBrandInfo', TMessageType.CALL, self._seqid)
3486 
    args = addOrUpdateBrandInfo_args()
3487 
    args.brandInfo = brandInfo
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_addOrUpdateBrandInfo(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = addOrUpdateBrandInfo_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    return
3503 
 
3504 
  def getBrandInfo(self, ):
3505 
    self.send_getBrandInfo()
3506 
    return self.recv_getBrandInfo()
3507 
 
3508 
  def send_getBrandInfo(self, ):
3509 
    self._oprot.writeMessageBegin('getBrandInfo', TMessageType.CALL, self._seqid)
3510 
    args = getBrandInfo_args()
3511 
    args.write(self._oprot)
3512 
    self._oprot.writeMessageEnd()
3513 
    self._oprot.trans.flush()
3514 
 
3515 
  def recv_getBrandInfo(self, ):
3516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3517 
    if mtype == TMessageType.EXCEPTION:
3518 
      x = TApplicationException()
3519 
      x.read(self._iprot)
3520 
      self._iprot.readMessageEnd()
3521 
      raise x
3522 
    result = getBrandInfo_result()
3523 
    result.read(self._iprot)
3524 
    self._iprot.readMessageEnd()
3525 
    if result.success is not None:
3526 
      return result.success
3527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrandInfo failed: unknown result");
3528 
 
7256 rajveer 3529 
  def getStorePricing(self, itemId):
3530 
    """
3531 
    Parameters:
3532 
     - itemId
3533 
    """
3534 
    self.send_getStorePricing(itemId)
3535 
    return self.recv_getStorePricing()
7190 amar.kumar 3536 
 
7256 rajveer 3537 
  def send_getStorePricing(self, itemId):
3538 
    self._oprot.writeMessageBegin('getStorePricing', TMessageType.CALL, self._seqid)
3539 
    args = getStorePricing_args()
3540 
    args.itemId = itemId
3541 
    args.write(self._oprot)
3542 
    self._oprot.writeMessageEnd()
3543 
    self._oprot.trans.flush()
3544 
 
3545 
  def recv_getStorePricing(self, ):
3546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3547 
    if mtype == TMessageType.EXCEPTION:
3548 
      x = TApplicationException()
3549 
      x.read(self._iprot)
3550 
      self._iprot.readMessageEnd()
3551 
      raise x
3552 
    result = getStorePricing_result()
3553 
    result.read(self._iprot)
3554 
    self._iprot.readMessageEnd()
3555 
    if result.success is not None:
3556 
      return result.success
3557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricing failed: unknown result");
3558 
 
7306 rajveer 3559 
  def getStorePricings(self, itemIds):
3560 
    """
3561 
    Parameters:
3562 
     - itemIds
3563 
    """
3564 
    self.send_getStorePricings(itemIds)
3565 
    return self.recv_getStorePricings()
3566 
 
3567 
  def send_getStorePricings(self, itemIds):
3568 
    self._oprot.writeMessageBegin('getStorePricings', TMessageType.CALL, self._seqid)
3569 
    args = getStorePricings_args()
3570 
    args.itemIds = itemIds
3571 
    args.write(self._oprot)
3572 
    self._oprot.writeMessageEnd()
3573 
    self._oprot.trans.flush()
3574 
 
3575 
  def recv_getStorePricings(self, ):
3576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3577 
    if mtype == TMessageType.EXCEPTION:
3578 
      x = TApplicationException()
3579 
      x.read(self._iprot)
3580 
      self._iprot.readMessageEnd()
3581 
      raise x
3582 
    result = getStorePricings_result()
3583 
    result.read(self._iprot)
3584 
    self._iprot.readMessageEnd()
3585 
    if result.success is not None:
3586 
      return result.success
3587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStorePricings failed: unknown result");
3588 
 
7382 rajveer 3589 
  def updateStorePricing(self, sp, allColors):
7265 rajveer 3590 
    """
3591 
    Parameters:
3592 
     - sp
7382 rajveer 3593 
     - allColors
7265 rajveer 3594 
    """
7382 rajveer 3595 
    self.send_updateStorePricing(sp, allColors)
7265 rajveer 3596 
    self.recv_updateStorePricing()
7256 rajveer 3597 
 
7382 rajveer 3598 
  def send_updateStorePricing(self, sp, allColors):
7265 rajveer 3599 
    self._oprot.writeMessageBegin('updateStorePricing', TMessageType.CALL, self._seqid)
3600 
    args = updateStorePricing_args()
3601 
    args.sp = sp
7382 rajveer 3602 
    args.allColors = allColors
7265 rajveer 3603 
    args.write(self._oprot)
3604 
    self._oprot.writeMessageEnd()
3605 
    self._oprot.trans.flush()
3606 
 
3607 
  def recv_updateStorePricing(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 = updateStorePricing_result()
3615 
    result.read(self._iprot)
3616 
    self._iprot.readMessageEnd()
3617 
    return
3618 
 
7281 kshitij.so 3619 
  def getAllAmazonListedItems(self, ):
3620 
    self.send_getAllAmazonListedItems()
3621 
    return self.recv_getAllAmazonListedItems()
7265 rajveer 3622 
 
7281 kshitij.so 3623 
  def send_getAllAmazonListedItems(self, ):
3624 
    self._oprot.writeMessageBegin('getAllAmazonListedItems', TMessageType.CALL, self._seqid)
3625 
    args = getAllAmazonListedItems_args()
3626 
    args.write(self._oprot)
3627 
    self._oprot.writeMessageEnd()
3628 
    self._oprot.trans.flush()
3629 
 
3630 
  def recv_getAllAmazonListedItems(self, ):
3631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3632 
    if mtype == TMessageType.EXCEPTION:
3633 
      x = TApplicationException()
3634 
      x.read(self._iprot)
3635 
      self._iprot.readMessageEnd()
3636 
      raise x
3637 
    result = getAllAmazonListedItems_result()
3638 
    result.read(self._iprot)
3639 
    self._iprot.readMessageEnd()
3640 
    if result.success is not None:
3641 
      return result.success
3642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonListedItems failed: unknown result");
3643 
 
3644 
  def getAmazonItemDetails(self, itemId):
3645 
    """
3646 
    Parameters:
3647 
     - itemId
3648 
    """
3649 
    self.send_getAmazonItemDetails(itemId)
3650 
    return self.recv_getAmazonItemDetails()
3651 
 
3652 
  def send_getAmazonItemDetails(self, itemId):
3653 
    self._oprot.writeMessageBegin('getAmazonItemDetails', TMessageType.CALL, self._seqid)
3654 
    args = getAmazonItemDetails_args()
3655 
    args.itemId = itemId
3656 
    args.write(self._oprot)
3657 
    self._oprot.writeMessageEnd()
3658 
    self._oprot.trans.flush()
3659 
 
3660 
  def recv_getAmazonItemDetails(self, ):
3661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3662 
    if mtype == TMessageType.EXCEPTION:
3663 
      x = TApplicationException()
3664 
      x.read(self._iprot)
3665 
      self._iprot.readMessageEnd()
3666 
      raise x
3667 
    result = getAmazonItemDetails_result()
3668 
    result.read(self._iprot)
3669 
    self._iprot.readMessageEnd()
3670 
    if result.success is not None:
3671 
      return result.success
3672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonItemDetails failed: unknown result");
3673 
 
7367 kshitij.so 3674 
  def updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3675 
    """
3676 
    Parameters:
3677 
     - itemId
3678 
     - fbaPrice
3679 
     - sellingPrice
3680 
     - isFba
3681 
     - isNonFba
3682 
     - isInventoryOverride
7367 kshitij.so 3683 
     - handlingTime
3684 
     - isCustomTime
7281 kshitij.so 3685 
    """
7367 kshitij.so 3686 
    self.send_updateAmazonItemDetails(itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime)
7281 kshitij.so 3687 
    self.recv_updateAmazonItemDetails()
3688 
 
7367 kshitij.so 3689 
  def send_updateAmazonItemDetails(self, itemId, fbaPrice, sellingPrice, isFba, isNonFba, isInventoryOverride, handlingTime, isCustomTime):
7281 kshitij.so 3690 
    self._oprot.writeMessageBegin('updateAmazonItemDetails', TMessageType.CALL, self._seqid)
3691 
    args = updateAmazonItemDetails_args()
3692 
    args.itemId = itemId
3693 
    args.fbaPrice = fbaPrice
3694 
    args.sellingPrice = sellingPrice
3695 
    args.isFba = isFba
3696 
    args.isNonFba = isNonFba
3697 
    args.isInventoryOverride = isInventoryOverride
7367 kshitij.so 3698 
    args.handlingTime = handlingTime
3699 
    args.isCustomTime = isCustomTime
7281 kshitij.so 3700 
    args.write(self._oprot)
3701 
    self._oprot.writeMessageEnd()
3702 
    self._oprot.trans.flush()
3703 
 
3704 
  def recv_updateAmazonItemDetails(self, ):
3705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3706 
    if mtype == TMessageType.EXCEPTION:
3707 
      x = TApplicationException()
3708 
      x.read(self._iprot)
3709 
      self._iprot.readMessageEnd()
3710 
      raise x
3711 
    result = updateAmazonItemDetails_result()
3712 
    result.read(self._iprot)
3713 
    self._iprot.readMessageEnd()
3714 
    return
3715 
 
3716 
  def addAmazonItem(self, amazonlisted):
3717 
    """
3718 
    Parameters:
3719 
     - amazonlisted
3720 
    """
3721 
    self.send_addAmazonItem(amazonlisted)
3722 
    self.recv_addAmazonItem()
3723 
 
3724 
  def send_addAmazonItem(self, amazonlisted):
3725 
    self._oprot.writeMessageBegin('addAmazonItem', TMessageType.CALL, self._seqid)
3726 
    args = addAmazonItem_args()
3727 
    args.amazonlisted = amazonlisted
3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_addAmazonItem(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = addAmazonItem_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3742 
    return
3743 
 
7291 vikram.rag 3744 
  def getAsinItems(self, ):
3745 
    self.send_getAsinItems()
3746 
    return self.recv_getAsinItems()
7281 kshitij.so 3747 
 
7291 vikram.rag 3748 
  def send_getAsinItems(self, ):
3749 
    self._oprot.writeMessageBegin('getAsinItems', TMessageType.CALL, self._seqid)
3750 
    args = getAsinItems_args()
3751 
    args.write(self._oprot)
3752 
    self._oprot.writeMessageEnd()
3753 
    self._oprot.trans.flush()
3754 
 
3755 
  def recv_getAsinItems(self, ):
3756 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3757 
    if mtype == TMessageType.EXCEPTION:
3758 
      x = TApplicationException()
3759 
      x.read(self._iprot)
3760 
      self._iprot.readMessageEnd()
3761 
      raise x
3762 
    result = getAsinItems_result()
3763 
    result.read(self._iprot)
3764 
    self._iprot.readMessageEnd()
3765 
    if result.success is not None:
3766 
      return result.success
3767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAsinItems failed: unknown result");
3768 
 
3769 
  def getAllFbaListedItems(self, ):
3770 
    self.send_getAllFbaListedItems()
3771 
    return self.recv_getAllFbaListedItems()
3772 
 
3773 
  def send_getAllFbaListedItems(self, ):
3774 
    self._oprot.writeMessageBegin('getAllFbaListedItems', TMessageType.CALL, self._seqid)
3775 
    args = getAllFbaListedItems_args()
3776 
    args.write(self._oprot)
3777 
    self._oprot.writeMessageEnd()
3778 
    self._oprot.trans.flush()
3779 
 
3780 
  def recv_getAllFbaListedItems(self, ):
3781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3782 
    if mtype == TMessageType.EXCEPTION:
3783 
      x = TApplicationException()
3784 
      x.read(self._iprot)
3785 
      self._iprot.readMessageEnd()
3786 
      raise x
3787 
    result = getAllFbaListedItems_result()
3788 
    result.read(self._iprot)
3789 
    self._iprot.readMessageEnd()
3790 
    if result.success is not None:
3791 
      return result.success
3792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllFbaListedItems failed: unknown result");
3793 
 
3794 
  def getAllNonFbaListedItems(self, ):
3795 
    self.send_getAllNonFbaListedItems()
3796 
    return self.recv_getAllNonFbaListedItems()
3797 
 
3798 
  def send_getAllNonFbaListedItems(self, ):
3799 
    self._oprot.writeMessageBegin('getAllNonFbaListedItems', TMessageType.CALL, self._seqid)
3800 
    args = getAllNonFbaListedItems_args()
3801 
    args.write(self._oprot)
3802 
    self._oprot.writeMessageEnd()
3803 
    self._oprot.trans.flush()
3804 
 
3805 
  def recv_getAllNonFbaListedItems(self, ):
3806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3807 
    if mtype == TMessageType.EXCEPTION:
3808 
      x = TApplicationException()
3809 
      x.read(self._iprot)
3810 
      self._iprot.readMessageEnd()
3811 
      raise x
3812 
    result = getAllNonFbaListedItems_result()
3813 
    result.read(self._iprot)
3814 
    self._iprot.readMessageEnd()
3815 
    if result.success is not None:
3816 
      return result.success
3817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllNonFbaListedItems failed: unknown result");
3818 
 
7460 kshitij.so 3819 
  def updateItemInventory(self, itemId, holdInventory, defaultInventory):
3820 
    """
3821 
    Parameters:
3822 
     - itemId
3823 
     - holdInventory
3824 
     - defaultInventory
3825 
    """
3826 
    self.send_updateItemInventory(itemId, holdInventory, defaultInventory)
3827 
    return self.recv_updateItemInventory()
7291 vikram.rag 3828 
 
7460 kshitij.so 3829 
  def send_updateItemInventory(self, itemId, holdInventory, defaultInventory):
3830 
    self._oprot.writeMessageBegin('updateItemInventory', TMessageType.CALL, self._seqid)
3831 
    args = updateItemInventory_args()
3832 
    args.itemId = itemId
3833 
    args.holdInventory = holdInventory
3834 
    args.defaultInventory = defaultInventory
3835 
    args.write(self._oprot)
3836 
    self._oprot.writeMessageEnd()
3837 
    self._oprot.trans.flush()
3838 
 
3839 
  def recv_updateItemInventory(self, ):
3840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3841 
    if mtype == TMessageType.EXCEPTION:
3842 
      x = TApplicationException()
3843 
      x.read(self._iprot)
3844 
      self._iprot.readMessageEnd()
3845 
      raise x
3846 
    result = updateItemInventory_result()
3847 
    result.read(self._iprot)
3848 
    self._iprot.readMessageEnd()
3849 
    if result.success is not None:
3850 
      return result.success
3851 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateItemInventory failed: unknown result");
3852 
 
3853 
 
5944 mandeep.dh 3854 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
3855 
  def __init__(self, handler):
3856 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
3857 
    self._processMap["addItem"] = Processor.process_addItem
3858 
    self._processMap["updateItem"] = Processor.process_updateItem
3859 
    self._processMap["isActive"] = Processor.process_isActive
7438 amit.gupta 3860 
    self._processMap["getItemsStatus"] = Processor.process_getItemsStatus
5944 mandeep.dh 3861 
    self._processMap["getItemStatusDescription"] = Processor.process_getItemStatusDescription
3862 
    self._processMap["startItemOn"] = Processor.process_startItemOn
3863 
    self._processMap["retireItemOn"] = Processor.process_retireItemOn
3864 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
3865 
    self._processMap["getItem"] = Processor.process_getItem
3866 
    self._processMap["getItemsByCatalogId"] = Processor.process_getItemsByCatalogId
3867 
    self._processMap["getValidItemsByCatalogId"] = Processor.process_getValidItemsByCatalogId
3868 
    self._processMap["getAllItems"] = Processor.process_getAllItems
3869 
    self._processMap["getAllItemsByStatus"] = Processor.process_getAllItemsByStatus
3870 
    self._processMap["markItemAsContentComplete"] = Processor.process_markItemAsContentComplete
3871 
    self._processMap["getAllItemsInRange"] = Processor.process_getAllItemsInRange
3872 
    self._processMap["getAllItemsByStatusInRange"] = Processor.process_getAllItemsByStatusInRange
3873 
    self._processMap["getItemCountByStatus"] = Processor.process_getItemCountByStatus
3874 
    self._processMap["getBestSellers"] = Processor.process_getBestSellers
3875 
    self._processMap["getBestSellersCatalogIds"] = Processor.process_getBestSellersCatalogIds
3876 
    self._processMap["getBestSellersCount"] = Processor.process_getBestSellersCount
3877 
    self._processMap["getBestDeals"] = Processor.process_getBestDeals
3878 
    self._processMap["getBestDealsCatalogIds"] = Processor.process_getBestDealsCatalogIds
3879 
    self._processMap["getBestDealsCount"] = Processor.process_getBestDealsCount
3880 
    self._processMap["getComingSoon"] = Processor.process_getComingSoon
3881 
    self._processMap["getComingSoonCatalogIds"] = Processor.process_getComingSoonCatalogIds
3882 
    self._processMap["getComingSoonCount"] = Processor.process_getComingSoonCount
3883 
    self._processMap["getLatestArrivals"] = Processor.process_getLatestArrivals
3884 
    self._processMap["getLatestArrivalsCatalogIds"] = Processor.process_getLatestArrivalsCatalogIds
3885 
    self._processMap["getLatestArrivalsCount"] = Processor.process_getLatestArrivalsCount
3886 
    self._processMap["generateNewEntityID"] = Processor.process_generateNewEntityID
3887 
    self._processMap["addCategory"] = Processor.process_addCategory
3888 
    self._processMap["getCategory"] = Processor.process_getCategory
3889 
    self._processMap["getAllCategories"] = Processor.process_getAllCategories
3890 
    self._processMap["getAllSimilarItems"] = Processor.process_getAllSimilarItems
3891 
    self._processMap["addSimilarItem"] = Processor.process_addSimilarItem
6512 kshitij.so 3892 
    self._processMap["addTag"] = Processor.process_addTag
3893 
    self._processMap["deleteEntityTag"] = Processor.process_deleteEntityTag
3894 
    self._processMap["deleteTag"] = Processor.process_deleteTag
3895 
    self._processMap["getAllTags"] = Processor.process_getAllTags
3896 
    self._processMap["getAllEntitiesByTagName"] = Processor.process_getAllEntitiesByTagName
6845 amit.gupta 3897 
    self._processMap["getAllEntityTags"] = Processor.process_getAllEntityTags
6850 kshitij.so 3898 
    self._processMap["addBanner"] = Processor.process_addBanner
3899 
    self._processMap["getAllBanners"] = Processor.process_getAllBanners
3900 
    self._processMap["deleteBanner"] = Processor.process_deleteBanner
3901 
    self._processMap["getBannerDetails"] = Processor.process_getBannerDetails
3902 
    self._processMap["getActiveBanners"] = Processor.process_getActiveBanners
6849 kshitij.so 3903 
    self._processMap["addBannerMap"] = Processor.process_addBannerMap
3904 
    self._processMap["deleteBannerMap"] = Processor.process_deleteBannerMap
3905 
    self._processMap["getBannerMapDetails"] = Processor.process_getBannerMapDetails
5944 mandeep.dh 3906 
    self._processMap["deleteSimilarItem"] = Processor.process_deleteSimilarItem
3907 
    self._processMap["checkSimilarItem"] = Processor.process_checkSimilarItem
3908 
    self._processMap["validateRiskyStatus"] = Processor.process_validateRiskyStatus
3909 
    self._processMap["changeItemRiskyFlag"] = Processor.process_changeItemRiskyFlag
3910 
    self._processMap["getItemsByRiskyFlag"] = Processor.process_getItemsByRiskyFlag
3911 
    self._processMap["getItemsForMasterSheet"] = Processor.process_getItemsForMasterSheet
3912 
    self._processMap["getSimilarItemsCatalogIds"] = Processor.process_getSimilarItemsCatalogIds
3913 
    self._processMap["addProductNotification"] = Processor.process_addProductNotification
3914 
    self._processMap["sendProductNotifications"] = Processor.process_sendProductNotifications
3915 
    self._processMap["getAllBrandsByCategory"] = Processor.process_getAllBrandsByCategory
3916 
    self._processMap["getAllBrands"] = Processor.process_getAllBrands
3917 
    self._processMap["getAllSources"] = Processor.process_getAllSources
3918 
    self._processMap["getItemPricingBySource"] = Processor.process_getItemPricingBySource
3919 
    self._processMap["addSourceItemPricing"] = Processor.process_addSourceItemPricing
3920 
    self._processMap["getAllSourcePricing"] = Processor.process_getAllSourcePricing
3921 
    self._processMap["getItemForSource"] = Processor.process_getItemForSource
3922 
    self._processMap["searchItemsInRange"] = Processor.process_searchItemsInRange
3923 
    self._processMap["getSearchResultCount"] = Processor.process_getSearchResultCount
3924 
    self._processMap["getProductNotifications"] = Processor.process_getProductNotifications
3925 
    self._processMap["getProductNotificationRequestCount"] = Processor.process_getProductNotificationRequestCount
3926 
    self._processMap["addAuthorizationLog"] = Processor.process_addAuthorizationLog
3927 
    self._processMap["addupdateVoucherForItem"] = Processor.process_addupdateVoucherForItem
3928 
    self._processMap["deleteVoucherForItem"] = Processor.process_deleteVoucherForItem
3929 
    self._processMap["getVoucherAmount"] = Processor.process_getVoucherAmount
3930 
    self._processMap["getAllItemVouchers"] = Processor.process_getAllItemVouchers
3931 
    self._processMap["isValidCatalogItemId"] = Processor.process_isValidCatalogItemId
6039 amit.gupta 3932 
    self._processMap["getVatPercentageForItem"] = Processor.process_getVatPercentageForItem
3933 
    self._processMap["getVatAmountForItem"] = Processor.process_getVatAmountForItem
6531 vikram.rag 3934 
    self._processMap["getAllIgnoredInventoryUpdateItemsList"] = Processor.process_getAllIgnoredInventoryUpdateItemsList
6821 amar.kumar 3935 
    self._processMap["getAllAliveItems"] = Processor.process_getAllAliveItems
6805 anupam.sin 3936 
    self._processMap["getInsuranceAmount"] = Processor.process_getInsuranceAmount
3937 
    self._processMap["getInsurer"] = Processor.process_getInsurer
6838 vikram.rag 3938 
    self._processMap["getAllInsurers"] = Processor.process_getAllInsurers
6962 rajveer 3939 
    self._processMap["updateInsuranceDeclaredAmount"] = Processor.process_updateInsuranceDeclaredAmount
7190 amar.kumar 3940 
    self._processMap["getFreebieForItem"] = Processor.process_getFreebieForItem
3941 
    self._processMap["addOrUpdateFreebieForItem"] = Processor.process_addOrUpdateFreebieForItem
7272 amit.gupta 3942 
    self._processMap["addOrUpdateBrandInfo"] = Processor.process_addOrUpdateBrandInfo
3943 
    self._processMap["getBrandInfo"] = Processor.process_getBrandInfo
7256 rajveer 3944 
    self._processMap["getStorePricing"] = Processor.process_getStorePricing
7306 rajveer 3945 
    self._processMap["getStorePricings"] = Processor.process_getStorePricings
7265 rajveer 3946 
    self._processMap["updateStorePricing"] = Processor.process_updateStorePricing
7281 kshitij.so 3947 
    self._processMap["getAllAmazonListedItems"] = Processor.process_getAllAmazonListedItems
3948 
    self._processMap["getAmazonItemDetails"] = Processor.process_getAmazonItemDetails
3949 
    self._processMap["updateAmazonItemDetails"] = Processor.process_updateAmazonItemDetails
3950 
    self._processMap["addAmazonItem"] = Processor.process_addAmazonItem
7291 vikram.rag 3951 
    self._processMap["getAsinItems"] = Processor.process_getAsinItems
3952 
    self._processMap["getAllFbaListedItems"] = Processor.process_getAllFbaListedItems
3953 
    self._processMap["getAllNonFbaListedItems"] = Processor.process_getAllNonFbaListedItems
7460 kshitij.so 3954 
    self._processMap["updateItemInventory"] = Processor.process_updateItemInventory
5944 mandeep.dh 3955 
 
3956 
  def process(self, iprot, oprot):
3957 
    (name, type, seqid) = iprot.readMessageBegin()
3958 
    if name not in self._processMap:
3959 
      iprot.skip(TType.STRUCT)
3960 
      iprot.readMessageEnd()
3961 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
3962 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
3963 
      x.write(oprot)
3964 
      oprot.writeMessageEnd()
3965 
      oprot.trans.flush()
3966 
      return
3967 
    else:
3968 
      self._processMap[name](self, seqid, iprot, oprot)
3969 
    return True
3970 
 
3971 
  def process_addItem(self, seqid, iprot, oprot):
3972 
    args = addItem_args()
3973 
    args.read(iprot)
3974 
    iprot.readMessageEnd()
3975 
    result = addItem_result()
3976 
    try:
3977 
      result.success = self._handler.addItem(args.item)
3978 
    except CatalogServiceException, cex:
3979 
      result.cex = cex
3980 
    oprot.writeMessageBegin("addItem", TMessageType.REPLY, seqid)
3981 
    result.write(oprot)
3982 
    oprot.writeMessageEnd()
3983 
    oprot.trans.flush()
3984 
 
3985 
  def process_updateItem(self, seqid, iprot, oprot):
3986 
    args = updateItem_args()
3987 
    args.read(iprot)
3988 
    iprot.readMessageEnd()
3989 
    result = updateItem_result()
3990 
    try:
3991 
      result.success = self._handler.updateItem(args.item)
3992 
    except CatalogServiceException, cex:
3993 
      result.cex = cex
3994 
    oprot.writeMessageBegin("updateItem", TMessageType.REPLY, seqid)
3995 
    result.write(oprot)
3996 
    oprot.writeMessageEnd()
3997 
    oprot.trans.flush()
3998 
 
3999 
  def process_isActive(self, seqid, iprot, oprot):
4000 
    args = isActive_args()
4001 
    args.read(iprot)
4002 
    iprot.readMessageEnd()
4003 
    result = isActive_result()
4004 
    try:
4005 
      result.success = self._handler.isActive(args.itemId)
4006 
    except CatalogServiceException, isex:
4007 
      result.isex = isex
4008 
    oprot.writeMessageBegin("isActive", TMessageType.REPLY, seqid)
4009 
    result.write(oprot)
4010 
    oprot.writeMessageEnd()
4011 
    oprot.trans.flush()
4012 
 
7438 amit.gupta 4013 
  def process_getItemsStatus(self, seqid, iprot, oprot):
4014 
    args = getItemsStatus_args()
4015 
    args.read(iprot)
4016 
    iprot.readMessageEnd()
4017 
    result = getItemsStatus_result()
4018 
    try:
4019 
      result.success = self._handler.getItemsStatus(args.itemIds)
4020 
    except CatalogServiceException, isex:
4021 
      result.isex = isex
4022 
    oprot.writeMessageBegin("getItemsStatus", TMessageType.REPLY, seqid)
4023 
    result.write(oprot)
4024 
    oprot.writeMessageEnd()
4025 
    oprot.trans.flush()
4026 
 
5944 mandeep.dh 4027 
  def process_getItemStatusDescription(self, seqid, iprot, oprot):
4028 
    args = getItemStatusDescription_args()
4029 
    args.read(iprot)
4030 
    iprot.readMessageEnd()
4031 
    result = getItemStatusDescription_result()
4032 
    try:
4033 
      result.success = self._handler.getItemStatusDescription(args.itemId)
4034 
    except CatalogServiceException, isex:
4035 
      result.isex = isex
4036 
    oprot.writeMessageBegin("getItemStatusDescription", TMessageType.REPLY, seqid)
4037 
    result.write(oprot)
4038 
    oprot.writeMessageEnd()
4039 
    oprot.trans.flush()
4040 
 
4041 
  def process_startItemOn(self, seqid, iprot, oprot):
4042 
    args = startItemOn_args()
4043 
    args.read(iprot)
4044 
    iprot.readMessageEnd()
4045 
    result = startItemOn_result()
4046 
    try:
4047 
      self._handler.startItemOn(args.item_id, args.timestamp)
4048 
    except CatalogServiceException, cex:
4049 
      result.cex = cex
4050 
    oprot.writeMessageBegin("startItemOn", TMessageType.REPLY, seqid)
4051 
    result.write(oprot)
4052 
    oprot.writeMessageEnd()
4053 
    oprot.trans.flush()
4054 
 
4055 
  def process_retireItemOn(self, seqid, iprot, oprot):
4056 
    args = retireItemOn_args()
4057 
    args.read(iprot)
4058 
    iprot.readMessageEnd()
4059 
    result = retireItemOn_result()
4060 
    try:
4061 
      self._handler.retireItemOn(args.item_id, args.timestamp)
4062 
    except CatalogServiceException, cex:
4063 
      result.cex = cex
4064 
    oprot.writeMessageBegin("retireItemOn", TMessageType.REPLY, seqid)
4065 
    result.write(oprot)
4066 
    oprot.writeMessageEnd()
4067 
    oprot.trans.flush()
4068 
 
4069 
  def process_changeItemStatus(self, seqid, iprot, oprot):
4070 
    args = changeItemStatus_args()
4071 
    args.read(iprot)
4072 
    iprot.readMessageEnd()
4073 
    result = changeItemStatus_result()
4074 
    try:
4075 
      self._handler.changeItemStatus(args.item_id, args.timestamp, args.newstatus)
4076 
    except CatalogServiceException, cex:
4077 
      result.cex = cex
4078 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
4079 
    result.write(oprot)
4080 
    oprot.writeMessageEnd()
4081 
    oprot.trans.flush()
4082 
 
4083 
  def process_getItem(self, seqid, iprot, oprot):
4084 
    args = getItem_args()
4085 
    args.read(iprot)
4086 
    iprot.readMessageEnd()
4087 
    result = getItem_result()
4088 
    try:
4089 
      result.success = self._handler.getItem(args.item_id)
4090 
    except CatalogServiceException, cex:
4091 
      result.cex = cex
4092 
    oprot.writeMessageBegin("getItem", TMessageType.REPLY, seqid)
4093 
    result.write(oprot)
4094 
    oprot.writeMessageEnd()
4095 
    oprot.trans.flush()
4096 
 
4097 
  def process_getItemsByCatalogId(self, seqid, iprot, oprot):
4098 
    args = getItemsByCatalogId_args()
4099 
    args.read(iprot)
4100 
    iprot.readMessageEnd()
4101 
    result = getItemsByCatalogId_result()
4102 
    try:
4103 
      result.success = self._handler.getItemsByCatalogId(args.catalog_item_id)
4104 
    except CatalogServiceException, cex:
4105 
      result.cex = cex
4106 
    oprot.writeMessageBegin("getItemsByCatalogId", TMessageType.REPLY, seqid)
4107 
    result.write(oprot)
4108 
    oprot.writeMessageEnd()
4109 
    oprot.trans.flush()
4110 
 
4111 
  def process_getValidItemsByCatalogId(self, seqid, iprot, oprot):
4112 
    args = getValidItemsByCatalogId_args()
4113 
    args.read(iprot)
4114 
    iprot.readMessageEnd()
4115 
    result = getValidItemsByCatalogId_result()
4116 
    try:
4117 
      result.success = self._handler.getValidItemsByCatalogId(args.catalog_item_id)
4118 
    except CatalogServiceException, cex:
4119 
      result.cex = cex
4120 
    oprot.writeMessageBegin("getValidItemsByCatalogId", TMessageType.REPLY, seqid)
4121 
    result.write(oprot)
4122 
    oprot.writeMessageEnd()
4123 
    oprot.trans.flush()
4124 
 
4125 
  def process_getAllItems(self, seqid, iprot, oprot):
4126 
    args = getAllItems_args()
4127 
    args.read(iprot)
4128 
    iprot.readMessageEnd()
4129 
    result = getAllItems_result()
4130 
    try:
4131 
      result.success = self._handler.getAllItems(args.isActive)
4132 
    except CatalogServiceException, cex:
4133 
      result.cex = cex
4134 
    oprot.writeMessageBegin("getAllItems", TMessageType.REPLY, seqid)
4135 
    result.write(oprot)
4136 
    oprot.writeMessageEnd()
4137 
    oprot.trans.flush()
4138 
 
4139 
  def process_getAllItemsByStatus(self, seqid, iprot, oprot):
4140 
    args = getAllItemsByStatus_args()
4141 
    args.read(iprot)
4142 
    iprot.readMessageEnd()
4143 
    result = getAllItemsByStatus_result()
4144 
    try:
4145 
      result.success = self._handler.getAllItemsByStatus(args.itemStatus)
4146 
    except CatalogServiceException, cex:
4147 
      result.cex = cex
4148 
    oprot.writeMessageBegin("getAllItemsByStatus", TMessageType.REPLY, seqid)
4149 
    result.write(oprot)
4150 
    oprot.writeMessageEnd()
4151 
    oprot.trans.flush()
4152 
 
4153 
  def process_markItemAsContentComplete(self, seqid, iprot, oprot):
4154 
    args = markItemAsContentComplete_args()
4155 
    args.read(iprot)
4156 
    iprot.readMessageEnd()
4157 
    result = markItemAsContentComplete_result()
4158 
    try:
4159 
      result.success = self._handler.markItemAsContentComplete(args.entityId, args.category, args.brand, args.modelName, args.modelNumber)
4160 
    except CatalogServiceException, cex:
4161 
      result.cex = cex
4162 
    oprot.writeMessageBegin("markItemAsContentComplete", TMessageType.REPLY, seqid)
4163 
    result.write(oprot)
4164 
    oprot.writeMessageEnd()
4165 
    oprot.trans.flush()
4166 
 
4167 
  def process_getAllItemsInRange(self, seqid, iprot, oprot):
4168 
    args = getAllItemsInRange_args()
4169 
    args.read(iprot)
4170 
    iprot.readMessageEnd()
4171 
    result = getAllItemsInRange_result()
4172 
    try:
4173 
      result.success = self._handler.getAllItemsInRange(args.offset, args.limit)
4174 
    except CatalogServiceException, cex:
4175 
      result.cex = cex
4176 
    oprot.writeMessageBegin("getAllItemsInRange", TMessageType.REPLY, seqid)
4177 
    result.write(oprot)
4178 
    oprot.writeMessageEnd()
4179 
    oprot.trans.flush()
4180 
 
4181 
  def process_getAllItemsByStatusInRange(self, seqid, iprot, oprot):
4182 
    args = getAllItemsByStatusInRange_args()
4183 
    args.read(iprot)
4184 
    iprot.readMessageEnd()
4185 
    result = getAllItemsByStatusInRange_result()
4186 
    try:
4187 
      result.success = self._handler.getAllItemsByStatusInRange(args.itemStatus, args.offset, args.limit)
4188 
    except CatalogServiceException, cex:
4189 
      result.cex = cex
4190 
    oprot.writeMessageBegin("getAllItemsByStatusInRange", TMessageType.REPLY, seqid)
4191 
    result.write(oprot)
4192 
    oprot.writeMessageEnd()
4193 
    oprot.trans.flush()
4194 
 
4195 
  def process_getItemCountByStatus(self, seqid, iprot, oprot):
4196 
    args = getItemCountByStatus_args()
4197 
    args.read(iprot)
4198 
    iprot.readMessageEnd()
4199 
    result = getItemCountByStatus_result()
4200 
    result.success = self._handler.getItemCountByStatus(args.useStatus, args.itemStatus)
4201 
    oprot.writeMessageBegin("getItemCountByStatus", TMessageType.REPLY, seqid)
4202 
    result.write(oprot)
4203 
    oprot.writeMessageEnd()
4204 
    oprot.trans.flush()
4205 
 
4206 
  def process_getBestSellers(self, seqid, iprot, oprot):
4207 
    args = getBestSellers_args()
4208 
    args.read(iprot)
4209 
    iprot.readMessageEnd()
4210 
    result = getBestSellers_result()
4211 
    try:
4212 
      result.success = self._handler.getBestSellers()
4213 
    except CatalogServiceException, isex:
4214 
      result.isex = isex
4215 
    oprot.writeMessageBegin("getBestSellers", TMessageType.REPLY, seqid)
4216 
    result.write(oprot)
4217 
    oprot.writeMessageEnd()
4218 
    oprot.trans.flush()
4219 
 
4220 
  def process_getBestSellersCatalogIds(self, seqid, iprot, oprot):
4221 
    args = getBestSellersCatalogIds_args()
4222 
    args.read(iprot)
4223 
    iprot.readMessageEnd()
4224 
    result = getBestSellersCatalogIds_result()
4225 
    try:
4226 
      result.success = self._handler.getBestSellersCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4227 
    except CatalogServiceException, cex:
4228 
      result.cex = cex
4229 
    oprot.writeMessageBegin("getBestSellersCatalogIds", TMessageType.REPLY, seqid)
4230 
    result.write(oprot)
4231 
    oprot.writeMessageEnd()
4232 
    oprot.trans.flush()
4233 
 
4234 
  def process_getBestSellersCount(self, seqid, iprot, oprot):
4235 
    args = getBestSellersCount_args()
4236 
    args.read(iprot)
4237 
    iprot.readMessageEnd()
4238 
    result = getBestSellersCount_result()
4239 
    try:
4240 
      result.success = self._handler.getBestSellersCount()
4241 
    except CatalogServiceException, cex:
4242 
      result.cex = cex
4243 
    oprot.writeMessageBegin("getBestSellersCount", TMessageType.REPLY, seqid)
4244 
    result.write(oprot)
4245 
    oprot.writeMessageEnd()
4246 
    oprot.trans.flush()
4247 
 
4248 
  def process_getBestDeals(self, seqid, iprot, oprot):
4249 
    args = getBestDeals_args()
4250 
    args.read(iprot)
4251 
    iprot.readMessageEnd()
4252 
    result = getBestDeals_result()
4253 
    try:
4254 
      result.success = self._handler.getBestDeals()
4255 
    except CatalogServiceException, isex:
4256 
      result.isex = isex
4257 
    oprot.writeMessageBegin("getBestDeals", TMessageType.REPLY, seqid)
4258 
    result.write(oprot)
4259 
    oprot.writeMessageEnd()
4260 
    oprot.trans.flush()
4261 
 
4262 
  def process_getBestDealsCatalogIds(self, seqid, iprot, oprot):
4263 
    args = getBestDealsCatalogIds_args()
4264 
    args.read(iprot)
4265 
    iprot.readMessageEnd()
4266 
    result = getBestDealsCatalogIds_result()
4267 
    try:
4268 
      result.success = self._handler.getBestDealsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4269 
    except CatalogServiceException, cex:
4270 
      result.cex = cex
4271 
    oprot.writeMessageBegin("getBestDealsCatalogIds", TMessageType.REPLY, seqid)
4272 
    result.write(oprot)
4273 
    oprot.writeMessageEnd()
4274 
    oprot.trans.flush()
4275 
 
4276 
  def process_getBestDealsCount(self, seqid, iprot, oprot):
4277 
    args = getBestDealsCount_args()
4278 
    args.read(iprot)
4279 
    iprot.readMessageEnd()
4280 
    result = getBestDealsCount_result()
4281 
    try:
4282 
      result.success = self._handler.getBestDealsCount()
4283 
    except CatalogServiceException, cex:
4284 
      result.cex = cex
4285 
    oprot.writeMessageBegin("getBestDealsCount", TMessageType.REPLY, seqid)
4286 
    result.write(oprot)
4287 
    oprot.writeMessageEnd()
4288 
    oprot.trans.flush()
4289 
 
4290 
  def process_getComingSoon(self, seqid, iprot, oprot):
4291 
    args = getComingSoon_args()
4292 
    args.read(iprot)
4293 
    iprot.readMessageEnd()
4294 
    result = getComingSoon_result()
4295 
    try:
4296 
      result.success = self._handler.getComingSoon()
4297 
    except CatalogServiceException, isex:
4298 
      result.isex = isex
4299 
    oprot.writeMessageBegin("getComingSoon", TMessageType.REPLY, seqid)
4300 
    result.write(oprot)
4301 
    oprot.writeMessageEnd()
4302 
    oprot.trans.flush()
4303 
 
4304 
  def process_getComingSoonCatalogIds(self, seqid, iprot, oprot):
4305 
    args = getComingSoonCatalogIds_args()
4306 
    args.read(iprot)
4307 
    iprot.readMessageEnd()
4308 
    result = getComingSoonCatalogIds_result()
4309 
    try:
4310 
      result.success = self._handler.getComingSoonCatalogIds(args.beginIndex, args.totalItems, args.brand, args.category)
4311 
    except CatalogServiceException, cex:
4312 
      result.cex = cex
4313 
    oprot.writeMessageBegin("getComingSoonCatalogIds", TMessageType.REPLY, seqid)
4314 
    result.write(oprot)
4315 
    oprot.writeMessageEnd()
4316 
    oprot.trans.flush()
4317 
 
4318 
  def process_getComingSoonCount(self, seqid, iprot, oprot):
4319 
    args = getComingSoonCount_args()
4320 
    args.read(iprot)
4321 
    iprot.readMessageEnd()
4322 
    result = getComingSoonCount_result()
4323 
    try:
4324 
      result.success = self._handler.getComingSoonCount()
4325 
    except CatalogServiceException, cex:
4326 
      result.cex = cex
4327 
    oprot.writeMessageBegin("getComingSoonCount", TMessageType.REPLY, seqid)
4328 
    result.write(oprot)
4329 
    oprot.writeMessageEnd()
4330 
    oprot.trans.flush()
4331 
 
4332 
  def process_getLatestArrivals(self, seqid, iprot, oprot):
4333 
    args = getLatestArrivals_args()
4334 
    args.read(iprot)
4335 
    iprot.readMessageEnd()
4336 
    result = getLatestArrivals_result()
4337 
    try:
4338 
      result.success = self._handler.getLatestArrivals()
4339 
    except CatalogServiceException, isex:
4340 
      result.isex = isex
4341 
    oprot.writeMessageBegin("getLatestArrivals", TMessageType.REPLY, seqid)
4342 
    result.write(oprot)
4343 
    oprot.writeMessageEnd()
4344 
    oprot.trans.flush()
4345 
 
4346 
  def process_getLatestArrivalsCatalogIds(self, seqid, iprot, oprot):
4347 
    args = getLatestArrivalsCatalogIds_args()
4348 
    args.read(iprot)
4349 
    iprot.readMessageEnd()
4350 
    result = getLatestArrivalsCatalogIds_result()
4351 
    try:
4352 
      result.success = self._handler.getLatestArrivalsCatalogIds(args.beginIndex, args.totalItems, args.brand, args.categories)
4353 
    except CatalogServiceException, cex:
4354 
      result.cex = cex
4355 
    oprot.writeMessageBegin("getLatestArrivalsCatalogIds", TMessageType.REPLY, seqid)
4356 
    result.write(oprot)
4357 
    oprot.writeMessageEnd()
4358 
    oprot.trans.flush()
4359 
 
4360 
  def process_getLatestArrivalsCount(self, seqid, iprot, oprot):
4361 
    args = getLatestArrivalsCount_args()
4362 
    args.read(iprot)
4363 
    iprot.readMessageEnd()
4364 
    result = getLatestArrivalsCount_result()
4365 
    try:
4366 
      result.success = self._handler.getLatestArrivalsCount()
4367 
    except CatalogServiceException, cex:
4368 
      result.cex = cex
4369 
    oprot.writeMessageBegin("getLatestArrivalsCount", TMessageType.REPLY, seqid)
4370 
    result.write(oprot)
4371 
    oprot.writeMessageEnd()
4372 
    oprot.trans.flush()
4373 
 
4374 
  def process_generateNewEntityID(self, seqid, iprot, oprot):
4375 
    args = generateNewEntityID_args()
4376 
    args.read(iprot)
4377 
    iprot.readMessageEnd()
4378 
    result = generateNewEntityID_result()
4379 
    result.success = self._handler.generateNewEntityID()
4380 
    oprot.writeMessageBegin("generateNewEntityID", TMessageType.REPLY, seqid)
4381 
    result.write(oprot)
4382 
    oprot.writeMessageEnd()
4383 
    oprot.trans.flush()
4384 
 
4385 
  def process_addCategory(self, seqid, iprot, oprot):
4386 
    args = addCategory_args()
4387 
    args.read(iprot)
4388 
    iprot.readMessageEnd()
4389 
    result = addCategory_result()
4390 
    result.success = self._handler.addCategory(args.category)
4391 
    oprot.writeMessageBegin("addCategory", TMessageType.REPLY, seqid)
4392 
    result.write(oprot)
4393 
    oprot.writeMessageEnd()
4394 
    oprot.trans.flush()
4395 
 
4396 
  def process_getCategory(self, seqid, iprot, oprot):
4397 
    args = getCategory_args()
4398 
    args.read(iprot)
4399 
    iprot.readMessageEnd()
4400 
    result = getCategory_result()
4401 
    result.success = self._handler.getCategory(args.id)
4402 
    oprot.writeMessageBegin("getCategory", TMessageType.REPLY, seqid)
4403 
    result.write(oprot)
4404 
    oprot.writeMessageEnd()
4405 
    oprot.trans.flush()
4406 
 
4407 
  def process_getAllCategories(self, seqid, iprot, oprot):
4408 
    args = getAllCategories_args()
4409 
    args.read(iprot)
4410 
    iprot.readMessageEnd()
4411 
    result = getAllCategories_result()
4412 
    result.success = self._handler.getAllCategories()
4413 
    oprot.writeMessageBegin("getAllCategories", TMessageType.REPLY, seqid)
4414 
    result.write(oprot)
4415 
    oprot.writeMessageEnd()
4416 
    oprot.trans.flush()
4417 
 
4418 
  def process_getAllSimilarItems(self, seqid, iprot, oprot):
4419 
    args = getAllSimilarItems_args()
4420 
    args.read(iprot)
4421 
    iprot.readMessageEnd()
4422 
    result = getAllSimilarItems_result()
4423 
    result.success = self._handler.getAllSimilarItems(args.itemId)
4424 
    oprot.writeMessageBegin("getAllSimilarItems", TMessageType.REPLY, seqid)
4425 
    result.write(oprot)
4426 
    oprot.writeMessageEnd()
4427 
    oprot.trans.flush()
4428 
 
4429 
  def process_addSimilarItem(self, seqid, iprot, oprot):
4430 
    args = addSimilarItem_args()
4431 
    args.read(iprot)
4432 
    iprot.readMessageEnd()
4433 
    result = addSimilarItem_result()
4434 
    try:
4435 
      result.success = self._handler.addSimilarItem(args.itemId, args.catalogItemId)
4436 
    except CatalogServiceException, cex:
4437 
      result.cex = cex
4438 
    oprot.writeMessageBegin("addSimilarItem", TMessageType.REPLY, seqid)
4439 
    result.write(oprot)
4440 
    oprot.writeMessageEnd()
4441 
    oprot.trans.flush()
4442 
 
6512 kshitij.so 4443 
  def process_addTag(self, seqid, iprot, oprot):
4444 
    args = addTag_args()
4445 
    args.read(iprot)
4446 
    iprot.readMessageEnd()
4447 
    result = addTag_result()
4448 
    result.success = self._handler.addTag(args.displayName, args.itemId)
4449 
    oprot.writeMessageBegin("addTag", TMessageType.REPLY, seqid)
4450 
    result.write(oprot)
4451 
    oprot.writeMessageEnd()
4452 
    oprot.trans.flush()
4453 
 
4454 
  def process_deleteEntityTag(self, seqid, iprot, oprot):
4455 
    args = deleteEntityTag_args()
4456 
    args.read(iprot)
4457 
    iprot.readMessageEnd()
4458 
    result = deleteEntityTag_result()
4459 
    result.success = self._handler.deleteEntityTag(args.displayName, args.itemId)
4460 
    oprot.writeMessageBegin("deleteEntityTag", TMessageType.REPLY, seqid)
4461 
    result.write(oprot)
4462 
    oprot.writeMessageEnd()
4463 
    oprot.trans.flush()
4464 
 
4465 
  def process_deleteTag(self, seqid, iprot, oprot):
4466 
    args = deleteTag_args()
4467 
    args.read(iprot)
4468 
    iprot.readMessageEnd()
4469 
    result = deleteTag_result()
4470 
    result.success = self._handler.deleteTag(args.displayName)
4471 
    oprot.writeMessageBegin("deleteTag", TMessageType.REPLY, seqid)
4472 
    result.write(oprot)
4473 
    oprot.writeMessageEnd()
4474 
    oprot.trans.flush()
4475 
 
4476 
  def process_getAllTags(self, seqid, iprot, oprot):
4477 
    args = getAllTags_args()
4478 
    args.read(iprot)
4479 
    iprot.readMessageEnd()
4480 
    result = getAllTags_result()
4481 
    result.success = self._handler.getAllTags()
4482 
    oprot.writeMessageBegin("getAllTags", TMessageType.REPLY, seqid)
4483 
    result.write(oprot)
4484 
    oprot.writeMessageEnd()
4485 
    oprot.trans.flush()
4486 
 
4487 
  def process_getAllEntitiesByTagName(self, seqid, iprot, oprot):
4488 
    args = getAllEntitiesByTagName_args()
4489 
    args.read(iprot)
4490 
    iprot.readMessageEnd()
4491 
    result = getAllEntitiesByTagName_result()
4492 
    result.success = self._handler.getAllEntitiesByTagName(args.displayName)
4493 
    oprot.writeMessageBegin("getAllEntitiesByTagName", TMessageType.REPLY, seqid)
4494 
    result.write(oprot)
4495 
    oprot.writeMessageEnd()
4496 
    oprot.trans.flush()
4497 
 
6845 amit.gupta 4498 
  def process_getAllEntityTags(self, seqid, iprot, oprot):
4499 
    args = getAllEntityTags_args()
4500 
    args.read(iprot)
4501 
    iprot.readMessageEnd()
4502 
    result = getAllEntityTags_result()
4503 
    result.success = self._handler.getAllEntityTags()
4504 
    oprot.writeMessageBegin("getAllEntityTags", TMessageType.REPLY, seqid)
4505 
    result.write(oprot)
4506 
    oprot.writeMessageEnd()
4507 
    oprot.trans.flush()
4508 
 
6850 kshitij.so 4509 
  def process_addBanner(self, seqid, iprot, oprot):
4510 
    args = addBanner_args()
4511 
    args.read(iprot)
4512 
    iprot.readMessageEnd()
4513 
    result = addBanner_result()
4514 
    result.success = self._handler.addBanner(args.bannerName, args.imageName, args.link, args.priority, args.isActive, args.hasMap)
4515 
    oprot.writeMessageBegin("addBanner", TMessageType.REPLY, seqid)
4516 
    result.write(oprot)
4517 
    oprot.writeMessageEnd()
4518 
    oprot.trans.flush()
4519 
 
4520 
  def process_getAllBanners(self, seqid, iprot, oprot):
4521 
    args = getAllBanners_args()
4522 
    args.read(iprot)
4523 
    iprot.readMessageEnd()
4524 
    result = getAllBanners_result()
4525 
    result.success = self._handler.getAllBanners()
4526 
    oprot.writeMessageBegin("getAllBanners", TMessageType.REPLY, seqid)
4527 
    result.write(oprot)
4528 
    oprot.writeMessageEnd()
4529 
    oprot.trans.flush()
4530 
 
4531 
  def process_deleteBanner(self, seqid, iprot, oprot):
4532 
    args = deleteBanner_args()
4533 
    args.read(iprot)
4534 
    iprot.readMessageEnd()
4535 
    result = deleteBanner_result()
4536 
    result.success = self._handler.deleteBanner(args.bannerName)
4537 
    oprot.writeMessageBegin("deleteBanner", TMessageType.REPLY, seqid)
4538 
    result.write(oprot)
4539 
    oprot.writeMessageEnd()
4540 
    oprot.trans.flush()
4541 
 
4542 
  def process_getBannerDetails(self, seqid, iprot, oprot):
4543 
    args = getBannerDetails_args()
4544 
    args.read(iprot)
4545 
    iprot.readMessageEnd()
4546 
    result = getBannerDetails_result()
4547 
    result.success = self._handler.getBannerDetails(args.bannerName)
4548 
    oprot.writeMessageBegin("getBannerDetails", TMessageType.REPLY, seqid)
4549 
    result.write(oprot)
4550 
    oprot.writeMessageEnd()
4551 
    oprot.trans.flush()
4552 
 
4553 
  def process_getActiveBanners(self, seqid, iprot, oprot):
4554 
    args = getActiveBanners_args()
4555 
    args.read(iprot)
4556 
    iprot.readMessageEnd()
4557 
    result = getActiveBanners_result()
4558 
    result.success = self._handler.getActiveBanners()
4559 
    oprot.writeMessageBegin("getActiveBanners", TMessageType.REPLY, seqid)
4560 
    result.write(oprot)
4561 
    oprot.writeMessageEnd()
4562 
    oprot.trans.flush()
4563 
 
6849 kshitij.so 4564 
  def process_addBannerMap(self, seqid, iprot, oprot):
4565 
    args = addBannerMap_args()
4566 
    args.read(iprot)
4567 
    iprot.readMessageEnd()
4568 
    result = addBannerMap_result()
4569 
    result.success = self._handler.addBannerMap(args.bannerName, args.mapLink, args.coordinates)
4570 
    oprot.writeMessageBegin("addBannerMap", TMessageType.REPLY, seqid)
4571 
    result.write(oprot)
4572 
    oprot.writeMessageEnd()
4573 
    oprot.trans.flush()
4574 
 
4575 
  def process_deleteBannerMap(self, seqid, iprot, oprot):
4576 
    args = deleteBannerMap_args()
4577 
    args.read(iprot)
4578 
    iprot.readMessageEnd()
4579 
    result = deleteBannerMap_result()
4580 
    result.success = self._handler.deleteBannerMap(args.bannerName)
4581 
    oprot.writeMessageBegin("deleteBannerMap", TMessageType.REPLY, seqid)
4582 
    result.write(oprot)
4583 
    oprot.writeMessageEnd()
4584 
    oprot.trans.flush()
4585 
 
4586 
  def process_getBannerMapDetails(self, seqid, iprot, oprot):
4587 
    args = getBannerMapDetails_args()
4588 
    args.read(iprot)
4589 
    iprot.readMessageEnd()
4590 
    result = getBannerMapDetails_result()
4591 
    result.success = self._handler.getBannerMapDetails(args.bannerName)
4592 
    oprot.writeMessageBegin("getBannerMapDetails", TMessageType.REPLY, seqid)
4593 
    result.write(oprot)
4594 
    oprot.writeMessageEnd()
4595 
    oprot.trans.flush()
4596 
 
5944 mandeep.dh 4597 
  def process_deleteSimilarItem(self, seqid, iprot, oprot):
4598 
    args = deleteSimilarItem_args()
4599 
    args.read(iprot)
4600 
    iprot.readMessageEnd()
4601 
    result = deleteSimilarItem_result()
4602 
    try:
4603 
      result.success = self._handler.deleteSimilarItem(args.itemId, args.catalogItemId)
4604 
    except CatalogServiceException, cex:
4605 
      result.cex = cex
4606 
    oprot.writeMessageBegin("deleteSimilarItem", TMessageType.REPLY, seqid)
4607 
    result.write(oprot)
4608 
    oprot.writeMessageEnd()
4609 
    oprot.trans.flush()
4610 
 
4611 
  def process_checkSimilarItem(self, seqid, iprot, oprot):
4612 
    args = checkSimilarItem_args()
4613 
    args.read(iprot)
4614 
    iprot.readMessageEnd()
4615 
    result = checkSimilarItem_result()
4616 
    result.success = self._handler.checkSimilarItem(args.brand, args.modelNumber, args.modelName, args.color)
4617 
    oprot.writeMessageBegin("checkSimilarItem", TMessageType.REPLY, seqid)
4618 
    result.write(oprot)
4619 
    oprot.writeMessageEnd()
4620 
    oprot.trans.flush()
4621 
 
4622 
  def process_validateRiskyStatus(self, seqid, iprot, oprot):
4623 
    args = validateRiskyStatus_args()
4624 
    args.read(iprot)
4625 
    iprot.readMessageEnd()
4626 
    result = validateRiskyStatus_result()
4627 
    self._handler.validateRiskyStatus(args.itemId)
4628 
    oprot.writeMessageBegin("validateRiskyStatus", TMessageType.REPLY, seqid)
4629 
    result.write(oprot)
4630 
    oprot.writeMessageEnd()
4631 
    oprot.trans.flush()
4632 
 
4633 
  def process_changeItemRiskyFlag(self, seqid, iprot, oprot):
4634 
    args = changeItemRiskyFlag_args()
4635 
    args.read(iprot)
4636 
    iprot.readMessageEnd()
4637 
    result = changeItemRiskyFlag_result()
4638 
    self._handler.changeItemRiskyFlag(args.itemId, args.risky)
4639 
    oprot.writeMessageBegin("changeItemRiskyFlag", TMessageType.REPLY, seqid)
4640 
    result.write(oprot)
4641 
    oprot.writeMessageEnd()
4642 
    oprot.trans.flush()
4643 
 
4644 
  def process_getItemsByRiskyFlag(self, seqid, iprot, oprot):
4645 
    args = getItemsByRiskyFlag_args()
4646 
    args.read(iprot)
4647 
    iprot.readMessageEnd()
4648 
    result = getItemsByRiskyFlag_result()
4649 
    result.success = self._handler.getItemsByRiskyFlag()
4650 
    oprot.writeMessageBegin("getItemsByRiskyFlag", TMessageType.REPLY, seqid)
4651 
    result.write(oprot)
4652 
    oprot.writeMessageEnd()
4653 
    oprot.trans.flush()
4654 
 
4655 
  def process_getItemsForMasterSheet(self, seqid, iprot, oprot):
4656 
    args = getItemsForMasterSheet_args()
4657 
    args.read(iprot)
4658 
    iprot.readMessageEnd()
4659 
    result = getItemsForMasterSheet_result()
4660 
    result.success = self._handler.getItemsForMasterSheet(args.category, args.brand)
4661 
    oprot.writeMessageBegin("getItemsForMasterSheet", TMessageType.REPLY, seqid)
4662 
    result.write(oprot)
4663 
    oprot.writeMessageEnd()
4664 
    oprot.trans.flush()
4665 
 
4666 
  def process_getSimilarItemsCatalogIds(self, seqid, iprot, oprot):
4667 
    args = getSimilarItemsCatalogIds_args()
4668 
    args.read(iprot)
4669 
    iprot.readMessageEnd()
4670 
    result = getSimilarItemsCatalogIds_result()
4671 
    result.success = self._handler.getSimilarItemsCatalogIds(args.beginIndex, args.totalItems, args.itemId)
4672 
    oprot.writeMessageBegin("getSimilarItemsCatalogIds", TMessageType.REPLY, seqid)
4673 
    result.write(oprot)
4674 
    oprot.writeMessageEnd()
4675 
    oprot.trans.flush()
4676 
 
4677 
  def process_addProductNotification(self, seqid, iprot, oprot):
4678 
    args = addProductNotification_args()
4679 
    args.read(iprot)
4680 
    iprot.readMessageEnd()
4681 
    result = addProductNotification_result()
4682 
    result.success = self._handler.addProductNotification(args.itemId, args.email)
4683 
    oprot.writeMessageBegin("addProductNotification", TMessageType.REPLY, seqid)
4684 
    result.write(oprot)
4685 
    oprot.writeMessageEnd()
4686 
    oprot.trans.flush()
4687 
 
4688 
  def process_sendProductNotifications(self, seqid, iprot, oprot):
4689 
    args = sendProductNotifications_args()
4690 
    args.read(iprot)
4691 
    iprot.readMessageEnd()
4692 
    result = sendProductNotifications_result()
4693 
    result.success = self._handler.sendProductNotifications()
4694 
    oprot.writeMessageBegin("sendProductNotifications", TMessageType.REPLY, seqid)
4695 
    result.write(oprot)
4696 
    oprot.writeMessageEnd()
4697 
    oprot.trans.flush()
4698 
 
4699 
  def process_getAllBrandsByCategory(self, seqid, iprot, oprot):
4700 
    args = getAllBrandsByCategory_args()
4701 
    args.read(iprot)
4702 
    iprot.readMessageEnd()
4703 
    result = getAllBrandsByCategory_result()
4704 
    result.success = self._handler.getAllBrandsByCategory(args.categoryId)
4705 
    oprot.writeMessageBegin("getAllBrandsByCategory", TMessageType.REPLY, seqid)
4706 
    result.write(oprot)
4707 
    oprot.writeMessageEnd()
4708 
    oprot.trans.flush()
4709 
 
4710 
  def process_getAllBrands(self, seqid, iprot, oprot):
4711 
    args = getAllBrands_args()
4712 
    args.read(iprot)
4713 
    iprot.readMessageEnd()
4714 
    result = getAllBrands_result()
4715 
    result.success = self._handler.getAllBrands()
4716 
    oprot.writeMessageBegin("getAllBrands", TMessageType.REPLY, seqid)
4717 
    result.write(oprot)
4718 
    oprot.writeMessageEnd()
4719 
    oprot.trans.flush()
4720 
 
4721 
  def process_getAllSources(self, seqid, iprot, oprot):
4722 
    args = getAllSources_args()
4723 
    args.read(iprot)
4724 
    iprot.readMessageEnd()
4725 
    result = getAllSources_result()
4726 
    result.success = self._handler.getAllSources()
4727 
    oprot.writeMessageBegin("getAllSources", TMessageType.REPLY, seqid)
4728 
    result.write(oprot)
4729 
    oprot.writeMessageEnd()
4730 
    oprot.trans.flush()
4731 
 
4732 
  def process_getItemPricingBySource(self, seqid, iprot, oprot):
4733 
    args = getItemPricingBySource_args()
4734 
    args.read(iprot)
4735 
    iprot.readMessageEnd()
4736 
    result = getItemPricingBySource_result()
4737 
    try:
4738 
      result.success = self._handler.getItemPricingBySource(args.itemId, args.sourceId)
4739 
    except CatalogServiceException, cex:
4740 
      result.cex = cex
4741 
    oprot.writeMessageBegin("getItemPricingBySource", TMessageType.REPLY, seqid)
4742 
    result.write(oprot)
4743 
    oprot.writeMessageEnd()
4744 
    oprot.trans.flush()
4745 
 
4746 
  def process_addSourceItemPricing(self, seqid, iprot, oprot):
4747 
    args = addSourceItemPricing_args()
4748 
    args.read(iprot)
4749 
    iprot.readMessageEnd()
4750 
    result = addSourceItemPricing_result()
4751 
    try:
4752 
      self._handler.addSourceItemPricing(args.sourceItemPricing)
4753 
    except CatalogServiceException, cex:
4754 
      result.cex = cex
4755 
    oprot.writeMessageBegin("addSourceItemPricing", TMessageType.REPLY, seqid)
4756 
    result.write(oprot)
4757 
    oprot.writeMessageEnd()
4758 
    oprot.trans.flush()
4759 
 
4760 
  def process_getAllSourcePricing(self, seqid, iprot, oprot):
4761 
    args = getAllSourcePricing_args()
4762 
    args.read(iprot)
4763 
    iprot.readMessageEnd()
4764 
    result = getAllSourcePricing_result()
4765 
    try:
4766 
      result.success = self._handler.getAllSourcePricing(args.itemId)
4767 
    except CatalogServiceException, cex:
4768 
      result.cex = cex
4769 
    oprot.writeMessageBegin("getAllSourcePricing", TMessageType.REPLY, seqid)
4770 
    result.write(oprot)
4771 
    oprot.writeMessageEnd()
4772 
    oprot.trans.flush()
4773 
 
4774 
  def process_getItemForSource(self, seqid, iprot, oprot):
4775 
    args = getItemForSource_args()
4776 
    args.read(iprot)
4777 
    iprot.readMessageEnd()
4778 
    result = getItemForSource_result()
4779 
    try:
4780 
      result.success = self._handler.getItemForSource(args.item_id, args.sourceId)
4781 
    except CatalogServiceException, cex:
4782 
      result.cex = cex
4783 
    oprot.writeMessageBegin("getItemForSource", TMessageType.REPLY, seqid)
4784 
    result.write(oprot)
4785 
    oprot.writeMessageEnd()
4786 
    oprot.trans.flush()
4787 
 
4788 
  def process_searchItemsInRange(self, seqid, iprot, oprot):
4789 
    args = searchItemsInRange_args()
4790 
    args.read(iprot)
4791 
    iprot.readMessageEnd()
4792 
    result = searchItemsInRange_result()
4793 
    result.success = self._handler.searchItemsInRange(args.searchTerms, args.offset, args.limit)
4794 
    oprot.writeMessageBegin("searchItemsInRange", TMessageType.REPLY, seqid)
4795 
    result.write(oprot)
4796 
    oprot.writeMessageEnd()
4797 
    oprot.trans.flush()
4798 
 
4799 
  def process_getSearchResultCount(self, seqid, iprot, oprot):
4800 
    args = getSearchResultCount_args()
4801 
    args.read(iprot)
4802 
    iprot.readMessageEnd()
4803 
    result = getSearchResultCount_result()
4804 
    result.success = self._handler.getSearchResultCount(args.searchTerms)
4805 
    oprot.writeMessageBegin("getSearchResultCount", TMessageType.REPLY, seqid)
4806 
    result.write(oprot)
4807 
    oprot.writeMessageEnd()
4808 
    oprot.trans.flush()
4809 
 
4810 
  def process_getProductNotifications(self, seqid, iprot, oprot):
4811 
    args = getProductNotifications_args()
4812 
    args.read(iprot)
4813 
    iprot.readMessageEnd()
4814 
    result = getProductNotifications_result()
4815 
    result.success = self._handler.getProductNotifications(args.startDateTime)
4816 
    oprot.writeMessageBegin("getProductNotifications", TMessageType.REPLY, seqid)
4817 
    result.write(oprot)
4818 
    oprot.writeMessageEnd()
4819 
    oprot.trans.flush()
4820 
 
4821 
  def process_getProductNotificationRequestCount(self, seqid, iprot, oprot):
4822 
    args = getProductNotificationRequestCount_args()
4823 
    args.read(iprot)
4824 
    iprot.readMessageEnd()
4825 
    result = getProductNotificationRequestCount_result()
4826 
    result.success = self._handler.getProductNotificationRequestCount(args.startDateTime)
4827 
    oprot.writeMessageBegin("getProductNotificationRequestCount", TMessageType.REPLY, seqid)
4828 
    result.write(oprot)
4829 
    oprot.writeMessageEnd()
4830 
    oprot.trans.flush()
4831 
 
4832 
  def process_addAuthorizationLog(self, seqid, iprot, oprot):
4833 
    args = addAuthorizationLog_args()
4834 
    args.read(iprot)
4835 
    iprot.readMessageEnd()
4836 
    result = addAuthorizationLog_result()
4837 
    try:
4838 
      result.success = self._handler.addAuthorizationLog(args.itemId, args.username, args.reason)
4839 
    except CatalogServiceException, cex:
4840 
      result.cex = cex
4841 
    oprot.writeMessageBegin("addAuthorizationLog", TMessageType.REPLY, seqid)
4842 
    result.write(oprot)
4843 
    oprot.writeMessageEnd()
4844 
    oprot.trans.flush()
4845 
 
4846 
  def process_addupdateVoucherForItem(self, seqid, iprot, oprot):
4847 
    args = addupdateVoucherForItem_args()
4848 
    args.read(iprot)
4849 
    iprot.readMessageEnd()
4850 
    result = addupdateVoucherForItem_result()
4851 
    try:
4852 
      result.success = self._handler.addupdateVoucherForItem(args.catalog_item_id, args.voucherType, args.voucherAmount)
4853 
    except CatalogServiceException, cex:
4854 
      result.cex = cex
4855 
    oprot.writeMessageBegin("addupdateVoucherForItem", TMessageType.REPLY, seqid)
4856 
    result.write(oprot)
4857 
    oprot.writeMessageEnd()
4858 
    oprot.trans.flush()
4859 
 
4860 
  def process_deleteVoucherForItem(self, seqid, iprot, oprot):
4861 
    args = deleteVoucherForItem_args()
4862 
    args.read(iprot)
4863 
    iprot.readMessageEnd()
4864 
    result = deleteVoucherForItem_result()
4865 
    try:
4866 
      result.success = self._handler.deleteVoucherForItem(args.catalog_item_id, args.voucherType)
4867 
    except CatalogServiceException, cex:
4868 
      result.cex = cex
4869 
    oprot.writeMessageBegin("deleteVoucherForItem", TMessageType.REPLY, seqid)
4870 
    result.write(oprot)
4871 
    oprot.writeMessageEnd()
4872 
    oprot.trans.flush()
4873 
 
4874 
  def process_getVoucherAmount(self, seqid, iprot, oprot):
4875 
    args = getVoucherAmount_args()
4876 
    args.read(iprot)
4877 
    iprot.readMessageEnd()
4878 
    result = getVoucherAmount_result()
4879 
    result.success = self._handler.getVoucherAmount(args.itemId, args.voucherType)
4880 
    oprot.writeMessageBegin("getVoucherAmount", TMessageType.REPLY, seqid)
4881 
    result.write(oprot)
4882 
    oprot.writeMessageEnd()
4883 
    oprot.trans.flush()
4884 
 
4885 
  def process_getAllItemVouchers(self, seqid, iprot, oprot):
4886 
    args = getAllItemVouchers_args()
4887 
    args.read(iprot)
4888 
    iprot.readMessageEnd()
4889 
    result = getAllItemVouchers_result()
4890 
    result.success = self._handler.getAllItemVouchers(args.itemId)
4891 
    oprot.writeMessageBegin("getAllItemVouchers", TMessageType.REPLY, seqid)
4892 
    result.write(oprot)
4893 
    oprot.writeMessageEnd()
4894 
    oprot.trans.flush()
4895 
 
4896 
  def process_isValidCatalogItemId(self, seqid, iprot, oprot):
4897 
    args = isValidCatalogItemId_args()
4898 
    args.read(iprot)
4899 
    iprot.readMessageEnd()
4900 
    result = isValidCatalogItemId_result()
4901 
    result.success = self._handler.isValidCatalogItemId(args.catalog_item_id)
4902 
    oprot.writeMessageBegin("isValidCatalogItemId", TMessageType.REPLY, seqid)
4903 
    result.write(oprot)
4904 
    oprot.writeMessageEnd()
4905 
    oprot.trans.flush()
4906 
 
6039 amit.gupta 4907 
  def process_getVatPercentageForItem(self, seqid, iprot, oprot):
4908 
    args = getVatPercentageForItem_args()
4909 
    args.read(iprot)
4910 
    iprot.readMessageEnd()
4911 
    result = getVatPercentageForItem_result()
7340 amit.gupta 4912 
    try:
4913 
      result.success = self._handler.getVatPercentageForItem(args.itemId, args.stateId, args.price)
4914 
    except CatalogServiceException, cex:
4915 
      result.cex = cex
6039 amit.gupta 4916 
    oprot.writeMessageBegin("getVatPercentageForItem", TMessageType.REPLY, seqid)
4917 
    result.write(oprot)
4918 
    oprot.writeMessageEnd()
4919 
    oprot.trans.flush()
5944 mandeep.dh 4920 
 
6039 amit.gupta 4921 
  def process_getVatAmountForItem(self, seqid, iprot, oprot):
4922 
    args = getVatAmountForItem_args()
4923 
    args.read(iprot)
4924 
    iprot.readMessageEnd()
4925 
    result = getVatAmountForItem_result()
4926 
    result.success = self._handler.getVatAmountForItem(args.itemId, args.price)
4927 
    oprot.writeMessageBegin("getVatAmountForItem", TMessageType.REPLY, seqid)
4928 
    result.write(oprot)
4929 
    oprot.writeMessageEnd()
4930 
    oprot.trans.flush()
4931 
 
6531 vikram.rag 4932 
  def process_getAllIgnoredInventoryUpdateItemsList(self, seqid, iprot, oprot):
4933 
    args = getAllIgnoredInventoryUpdateItemsList_args()
4934 
    args.read(iprot)
4935 
    iprot.readMessageEnd()
4936 
    result = getAllIgnoredInventoryUpdateItemsList_result()
4937 
    result.success = self._handler.getAllIgnoredInventoryUpdateItemsList(args.offset, args.limit)
4938 
    oprot.writeMessageBegin("getAllIgnoredInventoryUpdateItemsList", TMessageType.REPLY, seqid)
4939 
    result.write(oprot)
4940 
    oprot.writeMessageEnd()
4941 
    oprot.trans.flush()
6039 amit.gupta 4942 
 
6821 amar.kumar 4943 
  def process_getAllAliveItems(self, seqid, iprot, oprot):
4944 
    args = getAllAliveItems_args()
4945 
    args.read(iprot)
4946 
    iprot.readMessageEnd()
4947 
    result = getAllAliveItems_result()
4948 
    result.success = self._handler.getAllAliveItems()
4949 
    oprot.writeMessageBegin("getAllAliveItems", TMessageType.REPLY, seqid)
4950 
    result.write(oprot)
4951 
    oprot.writeMessageEnd()
4952 
    oprot.trans.flush()
4953 
 
6805 anupam.sin 4954 
  def process_getInsuranceAmount(self, seqid, iprot, oprot):
4955 
    args = getInsuranceAmount_args()
4956 
    args.read(iprot)
4957 
    iprot.readMessageEnd()
4958 
    result = getInsuranceAmount_result()
6921 anupam.sin 4959 
    result.success = self._handler.getInsuranceAmount(args.itemId, args.price, args.insurerId, args.quantity)
6805 anupam.sin 4960 
    oprot.writeMessageBegin("getInsuranceAmount", TMessageType.REPLY, seqid)
4961 
    result.write(oprot)
4962 
    oprot.writeMessageEnd()
4963 
    oprot.trans.flush()
6531 vikram.rag 4964 
 
6805 anupam.sin 4965 
  def process_getInsurer(self, seqid, iprot, oprot):
4966 
    args = getInsurer_args()
4967 
    args.read(iprot)
4968 
    iprot.readMessageEnd()
4969 
    result = getInsurer_result()
4970 
    result.success = self._handler.getInsurer(args.insurerId)
4971 
    oprot.writeMessageBegin("getInsurer", TMessageType.REPLY, seqid)
4972 
    result.write(oprot)
4973 
    oprot.writeMessageEnd()
4974 
    oprot.trans.flush()
4975 
 
6838 vikram.rag 4976 
  def process_getAllInsurers(self, seqid, iprot, oprot):
4977 
    args = getAllInsurers_args()
4978 
    args.read(iprot)
4979 
    iprot.readMessageEnd()
4980 
    result = getAllInsurers_result()
4981 
    result.success = self._handler.getAllInsurers()
4982 
    oprot.writeMessageBegin("getAllInsurers", TMessageType.REPLY, seqid)
4983 
    result.write(oprot)
4984 
    oprot.writeMessageEnd()
4985 
    oprot.trans.flush()
6805 anupam.sin 4986 
 
6962 rajveer 4987 
  def process_updateInsuranceDeclaredAmount(self, seqid, iprot, oprot):
4988 
    args = updateInsuranceDeclaredAmount_args()
4989 
    args.read(iprot)
4990 
    iprot.readMessageEnd()
4991 
    result = updateInsuranceDeclaredAmount_result()
4992 
    self._handler.updateInsuranceDeclaredAmount(args.insurerId, args.amount)
4993 
    oprot.writeMessageBegin("updateInsuranceDeclaredAmount", TMessageType.REPLY, seqid)
4994 
    result.write(oprot)
4995 
    oprot.writeMessageEnd()
4996 
    oprot.trans.flush()
6838 vikram.rag 4997 
 
7190 amar.kumar 4998 
  def process_getFreebieForItem(self, seqid, iprot, oprot):
4999 
    args = getFreebieForItem_args()
5000 
    args.read(iprot)
5001 
    iprot.readMessageEnd()
5002 
    result = getFreebieForItem_result()
5003 
    result.success = self._handler.getFreebieForItem(args.itemId)
5004 
    oprot.writeMessageBegin("getFreebieForItem", TMessageType.REPLY, seqid)
5005 
    result.write(oprot)
5006 
    oprot.writeMessageEnd()
5007 
    oprot.trans.flush()
6962 rajveer 5008 
 
7190 amar.kumar 5009 
  def process_addOrUpdateFreebieForItem(self, seqid, iprot, oprot):
5010 
    args = addOrUpdateFreebieForItem_args()
5011 
    args.read(iprot)
5012 
    iprot.readMessageEnd()
5013 
    result = addOrUpdateFreebieForItem_result()
5014 
    self._handler.addOrUpdateFreebieForItem(args.freebieItem)
5015 
    oprot.writeMessageBegin("addOrUpdateFreebieForItem", TMessageType.REPLY, seqid)
5016 
    result.write(oprot)
5017 
    oprot.writeMessageEnd()
5018 
    oprot.trans.flush()
5019 
 
7272 amit.gupta 5020 
  def process_addOrUpdateBrandInfo(self, seqid, iprot, oprot):
5021 
    args = addOrUpdateBrandInfo_args()
5022 
    args.read(iprot)
5023 
    iprot.readMessageEnd()
5024 
    result = addOrUpdateBrandInfo_result()
5025 
    self._handler.addOrUpdateBrandInfo(args.brandInfo)
5026 
    oprot.writeMessageBegin("addOrUpdateBrandInfo", TMessageType.REPLY, seqid)
5027 
    result.write(oprot)
5028 
    oprot.writeMessageEnd()
5029 
    oprot.trans.flush()
5030 
 
5031 
  def process_getBrandInfo(self, seqid, iprot, oprot):
5032 
    args = getBrandInfo_args()
5033 
    args.read(iprot)
5034 
    iprot.readMessageEnd()
5035 
    result = getBrandInfo_result()
5036 
    result.success = self._handler.getBrandInfo()
5037 
    oprot.writeMessageBegin("getBrandInfo", TMessageType.REPLY, seqid)
5038 
    result.write(oprot)
5039 
    oprot.writeMessageEnd()
5040 
    oprot.trans.flush()
5041 
 
7256 rajveer 5042 
  def process_getStorePricing(self, seqid, iprot, oprot):
5043 
    args = getStorePricing_args()
5044 
    args.read(iprot)
5045 
    iprot.readMessageEnd()
5046 
    result = getStorePricing_result()
5047 
    result.success = self._handler.getStorePricing(args.itemId)
5048 
    oprot.writeMessageBegin("getStorePricing", TMessageType.REPLY, seqid)
5049 
    result.write(oprot)
5050 
    oprot.writeMessageEnd()
5051 
    oprot.trans.flush()
7190 amar.kumar 5052 
 
7306 rajveer 5053 
  def process_getStorePricings(self, seqid, iprot, oprot):
5054 
    args = getStorePricings_args()
5055 
    args.read(iprot)
5056 
    iprot.readMessageEnd()
5057 
    result = getStorePricings_result()
5058 
    result.success = self._handler.getStorePricings(args.itemIds)
5059 
    oprot.writeMessageBegin("getStorePricings", TMessageType.REPLY, seqid)
5060 
    result.write(oprot)
5061 
    oprot.writeMessageEnd()
5062 
    oprot.trans.flush()
5063 
 
7265 rajveer 5064 
  def process_updateStorePricing(self, seqid, iprot, oprot):
5065 
    args = updateStorePricing_args()
5066 
    args.read(iprot)
5067 
    iprot.readMessageEnd()
5068 
    result = updateStorePricing_result()
7382 rajveer 5069 
    self._handler.updateStorePricing(args.sp, args.allColors)
7265 rajveer 5070 
    oprot.writeMessageBegin("updateStorePricing", TMessageType.REPLY, seqid)
5071 
    result.write(oprot)
5072 
    oprot.writeMessageEnd()
5073 
    oprot.trans.flush()
7256 rajveer 5074 
 
7281 kshitij.so 5075 
  def process_getAllAmazonListedItems(self, seqid, iprot, oprot):
5076 
    args = getAllAmazonListedItems_args()
5077 
    args.read(iprot)
5078 
    iprot.readMessageEnd()
5079 
    result = getAllAmazonListedItems_result()
5080 
    result.success = self._handler.getAllAmazonListedItems()
5081 
    oprot.writeMessageBegin("getAllAmazonListedItems", TMessageType.REPLY, seqid)
5082 
    result.write(oprot)
5083 
    oprot.writeMessageEnd()
5084 
    oprot.trans.flush()
7265 rajveer 5085 
 
7281 kshitij.so 5086 
  def process_getAmazonItemDetails(self, seqid, iprot, oprot):
5087 
    args = getAmazonItemDetails_args()
5088 
    args.read(iprot)
5089 
    iprot.readMessageEnd()
5090 
    result = getAmazonItemDetails_result()
5091 
    result.success = self._handler.getAmazonItemDetails(args.itemId)
5092 
    oprot.writeMessageBegin("getAmazonItemDetails", TMessageType.REPLY, seqid)
5093 
    result.write(oprot)
5094 
    oprot.writeMessageEnd()
5095 
    oprot.trans.flush()
5096 
 
5097 
  def process_updateAmazonItemDetails(self, seqid, iprot, oprot):
5098 
    args = updateAmazonItemDetails_args()
5099 
    args.read(iprot)
5100 
    iprot.readMessageEnd()
5101 
    result = updateAmazonItemDetails_result()
7367 kshitij.so 5102 
    self._handler.updateAmazonItemDetails(args.itemId, args.fbaPrice, args.sellingPrice, args.isFba, args.isNonFba, args.isInventoryOverride, args.handlingTime, args.isCustomTime)
7281 kshitij.so 5103 
    oprot.writeMessageBegin("updateAmazonItemDetails", TMessageType.REPLY, seqid)
5104 
    result.write(oprot)
5105 
    oprot.writeMessageEnd()
5106 
    oprot.trans.flush()
5107 
 
5108 
  def process_addAmazonItem(self, seqid, iprot, oprot):
5109 
    args = addAmazonItem_args()
5110 
    args.read(iprot)
5111 
    iprot.readMessageEnd()
5112 
    result = addAmazonItem_result()
5113 
    self._handler.addAmazonItem(args.amazonlisted)
5114 
    oprot.writeMessageBegin("addAmazonItem", TMessageType.REPLY, seqid)
5115 
    result.write(oprot)
5116 
    oprot.writeMessageEnd()
5117 
    oprot.trans.flush()
5118 
 
7291 vikram.rag 5119 
  def process_getAsinItems(self, seqid, iprot, oprot):
5120 
    args = getAsinItems_args()
5121 
    args.read(iprot)
5122 
    iprot.readMessageEnd()
5123 
    result = getAsinItems_result()
5124 
    result.success = self._handler.getAsinItems()
5125 
    oprot.writeMessageBegin("getAsinItems", TMessageType.REPLY, seqid)
5126 
    result.write(oprot)
5127 
    oprot.writeMessageEnd()
5128 
    oprot.trans.flush()
7281 kshitij.so 5129 
 
7291 vikram.rag 5130 
  def process_getAllFbaListedItems(self, seqid, iprot, oprot):
5131 
    args = getAllFbaListedItems_args()
5132 
    args.read(iprot)
5133 
    iprot.readMessageEnd()
5134 
    result = getAllFbaListedItems_result()
5135 
    result.success = self._handler.getAllFbaListedItems()
5136 
    oprot.writeMessageBegin("getAllFbaListedItems", TMessageType.REPLY, seqid)
5137 
    result.write(oprot)
5138 
    oprot.writeMessageEnd()
5139 
    oprot.trans.flush()
5140 
 
5141 
  def process_getAllNonFbaListedItems(self, seqid, iprot, oprot):
5142 
    args = getAllNonFbaListedItems_args()
5143 
    args.read(iprot)
5144 
    iprot.readMessageEnd()
5145 
    result = getAllNonFbaListedItems_result()
5146 
    result.success = self._handler.getAllNonFbaListedItems()
5147 
    oprot.writeMessageBegin("getAllNonFbaListedItems", TMessageType.REPLY, seqid)
5148 
    result.write(oprot)
5149 
    oprot.writeMessageEnd()
5150 
    oprot.trans.flush()
5151 
 
7460 kshitij.so 5152 
  def process_updateItemInventory(self, seqid, iprot, oprot):
5153 
    args = updateItemInventory_args()
5154 
    args.read(iprot)
5155 
    iprot.readMessageEnd()
5156 
    result = updateItemInventory_result()
5157 
    result.success = self._handler.updateItemInventory(args.itemId, args.holdInventory, args.defaultInventory)
5158 
    oprot.writeMessageBegin("updateItemInventory", TMessageType.REPLY, seqid)
5159 
    result.write(oprot)
5160 
    oprot.writeMessageEnd()
5161 
    oprot.trans.flush()
7291 vikram.rag 5162 
 
7460 kshitij.so 5163 
 
5944 mandeep.dh 5164 
# HELPER FUNCTIONS AND STRUCTURES
5165 
 
5166 
class addItem_args:
5167 
  """
5168 
  Attributes:
5169 
   - item
5170 
  """
5171 
 
5172 
  thrift_spec = (
5173 
    None, # 0
5174 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5175 
  )
5176 
 
5177 
  def __init__(self, item=None,):
5178 
    self.item = item
5179 
 
5180 
  def read(self, iprot):
5181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5183 
      return
5184 
    iprot.readStructBegin()
5185 
    while True:
5186 
      (fname, ftype, fid) = iprot.readFieldBegin()
5187 
      if ftype == TType.STOP:
5188 
        break
5189 
      if fid == 1:
5190 
        if ftype == TType.STRUCT:
5191 
          self.item = Item()
5192 
          self.item.read(iprot)
5193 
        else:
5194 
          iprot.skip(ftype)
5195 
      else:
5196 
        iprot.skip(ftype)
5197 
      iprot.readFieldEnd()
5198 
    iprot.readStructEnd()
5199 
 
5200 
  def write(self, oprot):
5201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5203 
      return
5204 
    oprot.writeStructBegin('addItem_args')
5205 
    if self.item is not None:
5206 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5207 
      self.item.write(oprot)
5208 
      oprot.writeFieldEnd()
5209 
    oprot.writeFieldStop()
5210 
    oprot.writeStructEnd()
5211 
 
5212 
  def validate(self):
5213 
    return
5214 
 
5215 
 
5216 
  def __repr__(self):
5217 
    L = ['%s=%r' % (key, value)
5218 
      for key, value in self.__dict__.iteritems()]
5219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5220 
 
5221 
  def __eq__(self, other):
5222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5223 
 
5224 
  def __ne__(self, other):
5225 
    return not (self == other)
5226 
 
5227 
class addItem_result:
5228 
  """
5229 
  Attributes:
5230 
   - success
5231 
   - cex
5232 
  """
5233 
 
5234 
  thrift_spec = (
5235 
    (0, TType.I64, 'success', None, None, ), # 0
5236 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5237 
  )
5238 
 
5239 
  def __init__(self, success=None, cex=None,):
5240 
    self.success = success
5241 
    self.cex = cex
5242 
 
5243 
  def read(self, iprot):
5244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5246 
      return
5247 
    iprot.readStructBegin()
5248 
    while True:
5249 
      (fname, ftype, fid) = iprot.readFieldBegin()
5250 
      if ftype == TType.STOP:
5251 
        break
5252 
      if fid == 0:
5253 
        if ftype == TType.I64:
5254 
          self.success = iprot.readI64();
5255 
        else:
5256 
          iprot.skip(ftype)
5257 
      elif fid == 1:
5258 
        if ftype == TType.STRUCT:
5259 
          self.cex = CatalogServiceException()
5260 
          self.cex.read(iprot)
5261 
        else:
5262 
          iprot.skip(ftype)
5263 
      else:
5264 
        iprot.skip(ftype)
5265 
      iprot.readFieldEnd()
5266 
    iprot.readStructEnd()
5267 
 
5268 
  def write(self, oprot):
5269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5271 
      return
5272 
    oprot.writeStructBegin('addItem_result')
5273 
    if self.success is not None:
5274 
      oprot.writeFieldBegin('success', TType.I64, 0)
5275 
      oprot.writeI64(self.success)
5276 
      oprot.writeFieldEnd()
5277 
    if self.cex is not None:
5278 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5279 
      self.cex.write(oprot)
5280 
      oprot.writeFieldEnd()
5281 
    oprot.writeFieldStop()
5282 
    oprot.writeStructEnd()
5283 
 
5284 
  def validate(self):
5285 
    return
5286 
 
5287 
 
5288 
  def __repr__(self):
5289 
    L = ['%s=%r' % (key, value)
5290 
      for key, value in self.__dict__.iteritems()]
5291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5292 
 
5293 
  def __eq__(self, other):
5294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5295 
 
5296 
  def __ne__(self, other):
5297 
    return not (self == other)
5298 
 
5299 
class updateItem_args:
5300 
  """
5301 
  Attributes:
5302 
   - item
5303 
  """
5304 
 
5305 
  thrift_spec = (
5306 
    None, # 0
5307 
    (1, TType.STRUCT, 'item', (Item, Item.thrift_spec), None, ), # 1
5308 
  )
5309 
 
5310 
  def __init__(self, item=None,):
5311 
    self.item = item
5312 
 
5313 
  def read(self, iprot):
5314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5316 
      return
5317 
    iprot.readStructBegin()
5318 
    while True:
5319 
      (fname, ftype, fid) = iprot.readFieldBegin()
5320 
      if ftype == TType.STOP:
5321 
        break
5322 
      if fid == 1:
5323 
        if ftype == TType.STRUCT:
5324 
          self.item = Item()
5325 
          self.item.read(iprot)
5326 
        else:
5327 
          iprot.skip(ftype)
5328 
      else:
5329 
        iprot.skip(ftype)
5330 
      iprot.readFieldEnd()
5331 
    iprot.readStructEnd()
5332 
 
5333 
  def write(self, oprot):
5334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5336 
      return
5337 
    oprot.writeStructBegin('updateItem_args')
5338 
    if self.item is not None:
5339 
      oprot.writeFieldBegin('item', TType.STRUCT, 1)
5340 
      self.item.write(oprot)
5341 
      oprot.writeFieldEnd()
5342 
    oprot.writeFieldStop()
5343 
    oprot.writeStructEnd()
5344 
 
5345 
  def validate(self):
5346 
    return
5347 
 
5348 
 
5349 
  def __repr__(self):
5350 
    L = ['%s=%r' % (key, value)
5351 
      for key, value in self.__dict__.iteritems()]
5352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5353 
 
5354 
  def __eq__(self, other):
5355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5356 
 
5357 
  def __ne__(self, other):
5358 
    return not (self == other)
5359 
 
5360 
class updateItem_result:
5361 
  """
5362 
  Attributes:
5363 
   - success
5364 
   - cex
5365 
  """
5366 
 
5367 
  thrift_spec = (
5368 
    (0, TType.I64, 'success', None, None, ), # 0
5369 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5370 
  )
5371 
 
5372 
  def __init__(self, success=None, cex=None,):
5373 
    self.success = success
5374 
    self.cex = cex
5375 
 
5376 
  def read(self, iprot):
5377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5379 
      return
5380 
    iprot.readStructBegin()
5381 
    while True:
5382 
      (fname, ftype, fid) = iprot.readFieldBegin()
5383 
      if ftype == TType.STOP:
5384 
        break
5385 
      if fid == 0:
5386 
        if ftype == TType.I64:
5387 
          self.success = iprot.readI64();
5388 
        else:
5389 
          iprot.skip(ftype)
5390 
      elif fid == 1:
5391 
        if ftype == TType.STRUCT:
5392 
          self.cex = CatalogServiceException()
5393 
          self.cex.read(iprot)
5394 
        else:
5395 
          iprot.skip(ftype)
5396 
      else:
5397 
        iprot.skip(ftype)
5398 
      iprot.readFieldEnd()
5399 
    iprot.readStructEnd()
5400 
 
5401 
  def write(self, oprot):
5402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5404 
      return
5405 
    oprot.writeStructBegin('updateItem_result')
5406 
    if self.success is not None:
5407 
      oprot.writeFieldBegin('success', TType.I64, 0)
5408 
      oprot.writeI64(self.success)
5409 
      oprot.writeFieldEnd()
5410 
    if self.cex is not None:
5411 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5412 
      self.cex.write(oprot)
5413 
      oprot.writeFieldEnd()
5414 
    oprot.writeFieldStop()
5415 
    oprot.writeStructEnd()
5416 
 
5417 
  def validate(self):
5418 
    return
5419 
 
5420 
 
5421 
  def __repr__(self):
5422 
    L = ['%s=%r' % (key, value)
5423 
      for key, value in self.__dict__.iteritems()]
5424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5425 
 
5426 
  def __eq__(self, other):
5427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5428 
 
5429 
  def __ne__(self, other):
5430 
    return not (self == other)
5431 
 
5432 
class isActive_args:
5433 
  """
5434 
  Attributes:
5435 
   - itemId
5436 
  """
5437 
 
5438 
  thrift_spec = (
5439 
    None, # 0
5440 
    (1, TType.I64, 'itemId', None, None, ), # 1
5441 
  )
5442 
 
5443 
  def __init__(self, itemId=None,):
5444 
    self.itemId = itemId
5445 
 
5446 
  def read(self, iprot):
5447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5449 
      return
5450 
    iprot.readStructBegin()
5451 
    while True:
5452 
      (fname, ftype, fid) = iprot.readFieldBegin()
5453 
      if ftype == TType.STOP:
5454 
        break
5455 
      if fid == 1:
5456 
        if ftype == TType.I64:
5457 
          self.itemId = iprot.readI64();
5458 
        else:
5459 
          iprot.skip(ftype)
5460 
      else:
5461 
        iprot.skip(ftype)
5462 
      iprot.readFieldEnd()
5463 
    iprot.readStructEnd()
5464 
 
5465 
  def write(self, oprot):
5466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5468 
      return
5469 
    oprot.writeStructBegin('isActive_args')
5470 
    if self.itemId is not None:
5471 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5472 
      oprot.writeI64(self.itemId)
5473 
      oprot.writeFieldEnd()
5474 
    oprot.writeFieldStop()
5475 
    oprot.writeStructEnd()
5476 
 
5477 
  def validate(self):
5478 
    return
5479 
 
5480 
 
5481 
  def __repr__(self):
5482 
    L = ['%s=%r' % (key, value)
5483 
      for key, value in self.__dict__.iteritems()]
5484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5485 
 
5486 
  def __eq__(self, other):
5487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5488 
 
5489 
  def __ne__(self, other):
5490 
    return not (self == other)
5491 
 
5492 
class isActive_result:
5493 
  """
5494 
  Attributes:
5495 
   - success
5496 
   - isex
5497 
  """
5498 
 
5499 
  thrift_spec = (
5500 
    (0, TType.STRUCT, 'success', (ItemShippingInfo, ItemShippingInfo.thrift_spec), None, ), # 0
5501 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5502 
  )
5503 
 
5504 
  def __init__(self, success=None, isex=None,):
5505 
    self.success = success
5506 
    self.isex = isex
5507 
 
5508 
  def read(self, iprot):
5509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5511 
      return
5512 
    iprot.readStructBegin()
5513 
    while True:
5514 
      (fname, ftype, fid) = iprot.readFieldBegin()
5515 
      if ftype == TType.STOP:
5516 
        break
5517 
      if fid == 0:
5518 
        if ftype == TType.STRUCT:
5519 
          self.success = ItemShippingInfo()
5520 
          self.success.read(iprot)
5521 
        else:
5522 
          iprot.skip(ftype)
5523 
      elif fid == 1:
5524 
        if ftype == TType.STRUCT:
5525 
          self.isex = CatalogServiceException()
5526 
          self.isex.read(iprot)
5527 
        else:
5528 
          iprot.skip(ftype)
5529 
      else:
5530 
        iprot.skip(ftype)
5531 
      iprot.readFieldEnd()
5532 
    iprot.readStructEnd()
5533 
 
5534 
  def write(self, oprot):
5535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5537 
      return
5538 
    oprot.writeStructBegin('isActive_result')
5539 
    if self.success is not None:
5540 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5541 
      self.success.write(oprot)
5542 
      oprot.writeFieldEnd()
5543 
    if self.isex is not None:
5544 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5545 
      self.isex.write(oprot)
5546 
      oprot.writeFieldEnd()
5547 
    oprot.writeFieldStop()
5548 
    oprot.writeStructEnd()
5549 
 
5550 
  def validate(self):
5551 
    return
5552 
 
5553 
 
5554 
  def __repr__(self):
5555 
    L = ['%s=%r' % (key, value)
5556 
      for key, value in self.__dict__.iteritems()]
5557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5558 
 
5559 
  def __eq__(self, other):
5560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5561 
 
5562 
  def __ne__(self, other):
5563 
    return not (self == other)
5564 
 
7438 amit.gupta 5565 
class getItemsStatus_args:
5566 
  """
5567 
  Attributes:
5568 
   - itemIds
5569 
  """
5570 
 
5571 
  thrift_spec = (
5572 
    None, # 0
5573 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
5574 
  )
5575 
 
5576 
  def __init__(self, itemIds=None,):
5577 
    self.itemIds = itemIds
5578 
 
5579 
  def read(self, iprot):
5580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5582 
      return
5583 
    iprot.readStructBegin()
5584 
    while True:
5585 
      (fname, ftype, fid) = iprot.readFieldBegin()
5586 
      if ftype == TType.STOP:
5587 
        break
5588 
      if fid == 1:
5589 
        if ftype == TType.LIST:
5590 
          self.itemIds = []
5591 
          (_etype19, _size16) = iprot.readListBegin()
5592 
          for _i20 in xrange(_size16):
5593 
            _elem21 = iprot.readI64();
5594 
            self.itemIds.append(_elem21)
5595 
          iprot.readListEnd()
5596 
        else:
5597 
          iprot.skip(ftype)
5598 
      else:
5599 
        iprot.skip(ftype)
5600 
      iprot.readFieldEnd()
5601 
    iprot.readStructEnd()
5602 
 
5603 
  def write(self, oprot):
5604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5606 
      return
5607 
    oprot.writeStructBegin('getItemsStatus_args')
5608 
    if self.itemIds is not None:
5609 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
5610 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
5611 
      for iter22 in self.itemIds:
5612 
        oprot.writeI64(iter22)
5613 
      oprot.writeListEnd()
5614 
      oprot.writeFieldEnd()
5615 
    oprot.writeFieldStop()
5616 
    oprot.writeStructEnd()
5617 
 
5618 
  def validate(self):
5619 
    return
5620 
 
5621 
 
5622 
  def __repr__(self):
5623 
    L = ['%s=%r' % (key, value)
5624 
      for key, value in self.__dict__.iteritems()]
5625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5626 
 
5627 
  def __eq__(self, other):
5628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5629 
 
5630 
  def __ne__(self, other):
5631 
    return not (self == other)
5632 
 
5633 
class getItemsStatus_result:
5634 
  """
5635 
  Attributes:
5636 
   - success
5637 
   - isex
5638 
  """
5639 
 
5640 
  thrift_spec = (
5641 
    (0, TType.MAP, 'success', (TType.I64,None,TType.BOOL,None), None, ), # 0
5642 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5643 
  )
5644 
 
5645 
  def __init__(self, success=None, isex=None,):
5646 
    self.success = success
5647 
    self.isex = isex
5648 
 
5649 
  def read(self, iprot):
5650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5652 
      return
5653 
    iprot.readStructBegin()
5654 
    while True:
5655 
      (fname, ftype, fid) = iprot.readFieldBegin()
5656 
      if ftype == TType.STOP:
5657 
        break
5658 
      if fid == 0:
5659 
        if ftype == TType.MAP:
5660 
          self.success = {}
5661 
          (_ktype24, _vtype25, _size23 ) = iprot.readMapBegin()
5662 
          for _i27 in xrange(_size23):
5663 
            _key28 = iprot.readI64();
5664 
            _val29 = iprot.readBool();
5665 
            self.success[_key28] = _val29
5666 
          iprot.readMapEnd()
5667 
        else:
5668 
          iprot.skip(ftype)
5669 
      elif fid == 1:
5670 
        if ftype == TType.STRUCT:
5671 
          self.isex = CatalogServiceException()
5672 
          self.isex.read(iprot)
5673 
        else:
5674 
          iprot.skip(ftype)
5675 
      else:
5676 
        iprot.skip(ftype)
5677 
      iprot.readFieldEnd()
5678 
    iprot.readStructEnd()
5679 
 
5680 
  def write(self, oprot):
5681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5683 
      return
5684 
    oprot.writeStructBegin('getItemsStatus_result')
5685 
    if self.success is not None:
5686 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5687 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
5688 
      for kiter30,viter31 in self.success.items():
5689 
        oprot.writeI64(kiter30)
5690 
        oprot.writeBool(viter31)
5691 
      oprot.writeMapEnd()
5692 
      oprot.writeFieldEnd()
5693 
    if self.isex is not None:
5694 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5695 
      self.isex.write(oprot)
5696 
      oprot.writeFieldEnd()
5697 
    oprot.writeFieldStop()
5698 
    oprot.writeStructEnd()
5699 
 
5700 
  def validate(self):
5701 
    return
5702 
 
5703 
 
5704 
  def __repr__(self):
5705 
    L = ['%s=%r' % (key, value)
5706 
      for key, value in self.__dict__.iteritems()]
5707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5708 
 
5709 
  def __eq__(self, other):
5710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5711 
 
5712 
  def __ne__(self, other):
5713 
    return not (self == other)
5714 
 
5944 mandeep.dh 5715 
class getItemStatusDescription_args:
5716 
  """
5717 
  Attributes:
5718 
   - itemId
5719 
  """
5720 
 
5721 
  thrift_spec = (
5722 
    None, # 0
5723 
    (1, TType.I64, 'itemId', None, None, ), # 1
5724 
  )
5725 
 
5726 
  def __init__(self, itemId=None,):
5727 
    self.itemId = itemId
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.itemId = iprot.readI64();
5741 
        else:
5742 
          iprot.skip(ftype)
5743 
      else:
5744 
        iprot.skip(ftype)
5745 
      iprot.readFieldEnd()
5746 
    iprot.readStructEnd()
5747 
 
5748 
  def write(self, oprot):
5749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5751 
      return
5752 
    oprot.writeStructBegin('getItemStatusDescription_args')
5753 
    if self.itemId is not None:
5754 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5755 
      oprot.writeI64(self.itemId)
5756 
      oprot.writeFieldEnd()
5757 
    oprot.writeFieldStop()
5758 
    oprot.writeStructEnd()
5759 
 
5760 
  def validate(self):
5761 
    return
5762 
 
5763 
 
5764 
  def __repr__(self):
5765 
    L = ['%s=%r' % (key, value)
5766 
      for key, value in self.__dict__.iteritems()]
5767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5768 
 
5769 
  def __eq__(self, other):
5770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5771 
 
5772 
  def __ne__(self, other):
5773 
    return not (self == other)
5774 
 
5775 
class getItemStatusDescription_result:
5776 
  """
5777 
  Attributes:
5778 
   - success
5779 
   - isex
5780 
  """
5781 
 
5782 
  thrift_spec = (
5783 
    (0, TType.STRING, 'success', None, None, ), # 0
5784 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5785 
  )
5786 
 
5787 
  def __init__(self, success=None, isex=None,):
5788 
    self.success = success
5789 
    self.isex = isex
5790 
 
5791 
  def read(self, iprot):
5792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5794 
      return
5795 
    iprot.readStructBegin()
5796 
    while True:
5797 
      (fname, ftype, fid) = iprot.readFieldBegin()
5798 
      if ftype == TType.STOP:
5799 
        break
5800 
      if fid == 0:
5801 
        if ftype == TType.STRING:
5802 
          self.success = iprot.readString();
5803 
        else:
5804 
          iprot.skip(ftype)
5805 
      elif fid == 1:
5806 
        if ftype == TType.STRUCT:
5807 
          self.isex = CatalogServiceException()
5808 
          self.isex.read(iprot)
5809 
        else:
5810 
          iprot.skip(ftype)
5811 
      else:
5812 
        iprot.skip(ftype)
5813 
      iprot.readFieldEnd()
5814 
    iprot.readStructEnd()
5815 
 
5816 
  def write(self, oprot):
5817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5819 
      return
5820 
    oprot.writeStructBegin('getItemStatusDescription_result')
5821 
    if self.success is not None:
5822 
      oprot.writeFieldBegin('success', TType.STRING, 0)
5823 
      oprot.writeString(self.success)
5824 
      oprot.writeFieldEnd()
5825 
    if self.isex is not None:
5826 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
5827 
      self.isex.write(oprot)
5828 
      oprot.writeFieldEnd()
5829 
    oprot.writeFieldStop()
5830 
    oprot.writeStructEnd()
5831 
 
5832 
  def validate(self):
5833 
    return
5834 
 
5835 
 
5836 
  def __repr__(self):
5837 
    L = ['%s=%r' % (key, value)
5838 
      for key, value in self.__dict__.iteritems()]
5839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5840 
 
5841 
  def __eq__(self, other):
5842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5843 
 
5844 
  def __ne__(self, other):
5845 
    return not (self == other)
5846 
 
5847 
class startItemOn_args:
5848 
  """
5849 
  Attributes:
5850 
   - item_id
5851 
   - timestamp
5852 
  """
5853 
 
5854 
  thrift_spec = (
5855 
    None, # 0
5856 
    (1, TType.I64, 'item_id', None, None, ), # 1
5857 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5858 
  )
5859 
 
5860 
  def __init__(self, item_id=None, timestamp=None,):
5861 
    self.item_id = item_id
5862 
    self.timestamp = timestamp
5863 
 
5864 
  def read(self, iprot):
5865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5867 
      return
5868 
    iprot.readStructBegin()
5869 
    while True:
5870 
      (fname, ftype, fid) = iprot.readFieldBegin()
5871 
      if ftype == TType.STOP:
5872 
        break
5873 
      if fid == 1:
5874 
        if ftype == TType.I64:
5875 
          self.item_id = iprot.readI64();
5876 
        else:
5877 
          iprot.skip(ftype)
5878 
      elif fid == 2:
5879 
        if ftype == TType.I64:
5880 
          self.timestamp = iprot.readI64();
5881 
        else:
5882 
          iprot.skip(ftype)
5883 
      else:
5884 
        iprot.skip(ftype)
5885 
      iprot.readFieldEnd()
5886 
    iprot.readStructEnd()
5887 
 
5888 
  def write(self, oprot):
5889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5891 
      return
5892 
    oprot.writeStructBegin('startItemOn_args')
5893 
    if self.item_id is not None:
5894 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
5895 
      oprot.writeI64(self.item_id)
5896 
      oprot.writeFieldEnd()
5897 
    if self.timestamp is not None:
5898 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5899 
      oprot.writeI64(self.timestamp)
5900 
      oprot.writeFieldEnd()
5901 
    oprot.writeFieldStop()
5902 
    oprot.writeStructEnd()
5903 
 
5904 
  def validate(self):
5905 
    return
5906 
 
5907 
 
5908 
  def __repr__(self):
5909 
    L = ['%s=%r' % (key, value)
5910 
      for key, value in self.__dict__.iteritems()]
5911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5912 
 
5913 
  def __eq__(self, other):
5914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5915 
 
5916 
  def __ne__(self, other):
5917 
    return not (self == other)
5918 
 
5919 
class startItemOn_result:
5920 
  """
5921 
  Attributes:
5922 
   - cex
5923 
  """
5924 
 
5925 
  thrift_spec = (
5926 
    None, # 0
5927 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
5928 
  )
5929 
 
5930 
  def __init__(self, cex=None,):
5931 
    self.cex = cex
5932 
 
5933 
  def read(self, iprot):
5934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5936 
      return
5937 
    iprot.readStructBegin()
5938 
    while True:
5939 
      (fname, ftype, fid) = iprot.readFieldBegin()
5940 
      if ftype == TType.STOP:
5941 
        break
5942 
      if fid == 1:
5943 
        if ftype == TType.STRUCT:
5944 
          self.cex = CatalogServiceException()
5945 
          self.cex.read(iprot)
5946 
        else:
5947 
          iprot.skip(ftype)
5948 
      else:
5949 
        iprot.skip(ftype)
5950 
      iprot.readFieldEnd()
5951 
    iprot.readStructEnd()
5952 
 
5953 
  def write(self, oprot):
5954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5956 
      return
5957 
    oprot.writeStructBegin('startItemOn_result')
5958 
    if self.cex is not None:
5959 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5960 
      self.cex.write(oprot)
5961 
      oprot.writeFieldEnd()
5962 
    oprot.writeFieldStop()
5963 
    oprot.writeStructEnd()
5964 
 
5965 
  def validate(self):
5966 
    return
5967 
 
5968 
 
5969 
  def __repr__(self):
5970 
    L = ['%s=%r' % (key, value)
5971 
      for key, value in self.__dict__.iteritems()]
5972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5973 
 
5974 
  def __eq__(self, other):
5975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5976 
 
5977 
  def __ne__(self, other):
5978 
    return not (self == other)
5979 
 
5980 
class retireItemOn_args:
5981 
  """
5982 
  Attributes:
5983 
   - item_id
5984 
   - timestamp
5985 
  """
5986 
 
5987 
  thrift_spec = (
5988 
    None, # 0
5989 
    (1, TType.I64, 'item_id', None, None, ), # 1
5990 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5991 
  )
5992 
 
5993 
  def __init__(self, item_id=None, timestamp=None,):
5994 
    self.item_id = item_id
5995 
    self.timestamp = timestamp
5996 
 
5997 
  def read(self, iprot):
5998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6000 
      return
6001 
    iprot.readStructBegin()
6002 
    while True:
6003 
      (fname, ftype, fid) = iprot.readFieldBegin()
6004 
      if ftype == TType.STOP:
6005 
        break
6006 
      if fid == 1:
6007 
        if ftype == TType.I64:
6008 
          self.item_id = iprot.readI64();
6009 
        else:
6010 
          iprot.skip(ftype)
6011 
      elif fid == 2:
6012 
        if ftype == TType.I64:
6013 
          self.timestamp = iprot.readI64();
6014 
        else:
6015 
          iprot.skip(ftype)
6016 
      else:
6017 
        iprot.skip(ftype)
6018 
      iprot.readFieldEnd()
6019 
    iprot.readStructEnd()
6020 
 
6021 
  def write(self, oprot):
6022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6024 
      return
6025 
    oprot.writeStructBegin('retireItemOn_args')
6026 
    if self.item_id is not None:
6027 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6028 
      oprot.writeI64(self.item_id)
6029 
      oprot.writeFieldEnd()
6030 
    if self.timestamp is not None:
6031 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6032 
      oprot.writeI64(self.timestamp)
6033 
      oprot.writeFieldEnd()
6034 
    oprot.writeFieldStop()
6035 
    oprot.writeStructEnd()
6036 
 
6037 
  def validate(self):
6038 
    return
6039 
 
6040 
 
6041 
  def __repr__(self):
6042 
    L = ['%s=%r' % (key, value)
6043 
      for key, value in self.__dict__.iteritems()]
6044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6045 
 
6046 
  def __eq__(self, other):
6047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6048 
 
6049 
  def __ne__(self, other):
6050 
    return not (self == other)
6051 
 
6052 
class retireItemOn_result:
6053 
  """
6054 
  Attributes:
6055 
   - cex
6056 
  """
6057 
 
6058 
  thrift_spec = (
6059 
    None, # 0
6060 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6061 
  )
6062 
 
6063 
  def __init__(self, cex=None,):
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 == 1:
6076 
        if ftype == TType.STRUCT:
6077 
          self.cex = CatalogServiceException()
6078 
          self.cex.read(iprot)
6079 
        else:
6080 
          iprot.skip(ftype)
6081 
      else:
6082 
        iprot.skip(ftype)
6083 
      iprot.readFieldEnd()
6084 
    iprot.readStructEnd()
6085 
 
6086 
  def write(self, oprot):
6087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6089 
      return
6090 
    oprot.writeStructBegin('retireItemOn_result')
6091 
    if self.cex is not None:
6092 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6093 
      self.cex.write(oprot)
6094 
      oprot.writeFieldEnd()
6095 
    oprot.writeFieldStop()
6096 
    oprot.writeStructEnd()
6097 
 
6098 
  def validate(self):
6099 
    return
6100 
 
6101 
 
6102 
  def __repr__(self):
6103 
    L = ['%s=%r' % (key, value)
6104 
      for key, value in self.__dict__.iteritems()]
6105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6106 
 
6107 
  def __eq__(self, other):
6108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6109 
 
6110 
  def __ne__(self, other):
6111 
    return not (self == other)
6112 
 
6113 
class changeItemStatus_args:
6114 
  """
6115 
  Attributes:
6116 
   - item_id
6117 
   - timestamp
6118 
   - newstatus
6119 
  """
6120 
 
6121 
  thrift_spec = (
6122 
    None, # 0
6123 
    (1, TType.I64, 'item_id', None, None, ), # 1
6124 
    (2, TType.I64, 'timestamp', None, None, ), # 2
6125 
    (3, TType.I32, 'newstatus', None, None, ), # 3
6126 
  )
6127 
 
6128 
  def __init__(self, item_id=None, timestamp=None, newstatus=None,):
6129 
    self.item_id = item_id
6130 
    self.timestamp = timestamp
6131 
    self.newstatus = newstatus
6132 
 
6133 
  def read(self, iprot):
6134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6136 
      return
6137 
    iprot.readStructBegin()
6138 
    while True:
6139 
      (fname, ftype, fid) = iprot.readFieldBegin()
6140 
      if ftype == TType.STOP:
6141 
        break
6142 
      if fid == 1:
6143 
        if ftype == TType.I64:
6144 
          self.item_id = iprot.readI64();
6145 
        else:
6146 
          iprot.skip(ftype)
6147 
      elif fid == 2:
6148 
        if ftype == TType.I64:
6149 
          self.timestamp = iprot.readI64();
6150 
        else:
6151 
          iprot.skip(ftype)
6152 
      elif fid == 3:
6153 
        if ftype == TType.I32:
6154 
          self.newstatus = iprot.readI32();
6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      else:
6158 
        iprot.skip(ftype)
6159 
      iprot.readFieldEnd()
6160 
    iprot.readStructEnd()
6161 
 
6162 
  def write(self, oprot):
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6165 
      return
6166 
    oprot.writeStructBegin('changeItemStatus_args')
6167 
    if self.item_id is not None:
6168 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6169 
      oprot.writeI64(self.item_id)
6170 
      oprot.writeFieldEnd()
6171 
    if self.timestamp is not None:
6172 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
6173 
      oprot.writeI64(self.timestamp)
6174 
      oprot.writeFieldEnd()
6175 
    if self.newstatus is not None:
6176 
      oprot.writeFieldBegin('newstatus', TType.I32, 3)
6177 
      oprot.writeI32(self.newstatus)
6178 
      oprot.writeFieldEnd()
6179 
    oprot.writeFieldStop()
6180 
    oprot.writeStructEnd()
6181 
 
6182 
  def validate(self):
6183 
    return
6184 
 
6185 
 
6186 
  def __repr__(self):
6187 
    L = ['%s=%r' % (key, value)
6188 
      for key, value in self.__dict__.iteritems()]
6189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6190 
 
6191 
  def __eq__(self, other):
6192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6193 
 
6194 
  def __ne__(self, other):
6195 
    return not (self == other)
6196 
 
6197 
class changeItemStatus_result:
6198 
  """
6199 
  Attributes:
6200 
   - cex
6201 
  """
6202 
 
6203 
  thrift_spec = (
6204 
    None, # 0
6205 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6206 
  )
6207 
 
6208 
  def __init__(self, cex=None,):
6209 
    self.cex = cex
6210 
 
6211 
  def read(self, iprot):
6212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6214 
      return
6215 
    iprot.readStructBegin()
6216 
    while True:
6217 
      (fname, ftype, fid) = iprot.readFieldBegin()
6218 
      if ftype == TType.STOP:
6219 
        break
6220 
      if fid == 1:
6221 
        if ftype == TType.STRUCT:
6222 
          self.cex = CatalogServiceException()
6223 
          self.cex.read(iprot)
6224 
        else:
6225 
          iprot.skip(ftype)
6226 
      else:
6227 
        iprot.skip(ftype)
6228 
      iprot.readFieldEnd()
6229 
    iprot.readStructEnd()
6230 
 
6231 
  def write(self, oprot):
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6234 
      return
6235 
    oprot.writeStructBegin('changeItemStatus_result')
6236 
    if self.cex is not None:
6237 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6238 
      self.cex.write(oprot)
6239 
      oprot.writeFieldEnd()
6240 
    oprot.writeFieldStop()
6241 
    oprot.writeStructEnd()
6242 
 
6243 
  def validate(self):
6244 
    return
6245 
 
6246 
 
6247 
  def __repr__(self):
6248 
    L = ['%s=%r' % (key, value)
6249 
      for key, value in self.__dict__.iteritems()]
6250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6251 
 
6252 
  def __eq__(self, other):
6253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6254 
 
6255 
  def __ne__(self, other):
6256 
    return not (self == other)
6257 
 
6258 
class getItem_args:
6259 
  """
6260 
  Attributes:
6261 
   - item_id
6262 
  """
6263 
 
6264 
  thrift_spec = (
6265 
    None, # 0
6266 
    (1, TType.I64, 'item_id', None, None, ), # 1
6267 
  )
6268 
 
6269 
  def __init__(self, item_id=None,):
6270 
    self.item_id = item_id
6271 
 
6272 
  def read(self, iprot):
6273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6275 
      return
6276 
    iprot.readStructBegin()
6277 
    while True:
6278 
      (fname, ftype, fid) = iprot.readFieldBegin()
6279 
      if ftype == TType.STOP:
6280 
        break
6281 
      if fid == 1:
6282 
        if ftype == TType.I64:
6283 
          self.item_id = iprot.readI64();
6284 
        else:
6285 
          iprot.skip(ftype)
6286 
      else:
6287 
        iprot.skip(ftype)
6288 
      iprot.readFieldEnd()
6289 
    iprot.readStructEnd()
6290 
 
6291 
  def write(self, oprot):
6292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6294 
      return
6295 
    oprot.writeStructBegin('getItem_args')
6296 
    if self.item_id is not None:
6297 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
6298 
      oprot.writeI64(self.item_id)
6299 
      oprot.writeFieldEnd()
6300 
    oprot.writeFieldStop()
6301 
    oprot.writeStructEnd()
6302 
 
6303 
  def validate(self):
6304 
    return
6305 
 
6306 
 
6307 
  def __repr__(self):
6308 
    L = ['%s=%r' % (key, value)
6309 
      for key, value in self.__dict__.iteritems()]
6310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6311 
 
6312 
  def __eq__(self, other):
6313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6314 
 
6315 
  def __ne__(self, other):
6316 
    return not (self == other)
6317 
 
6318 
class getItem_result:
6319 
  """
6320 
  Attributes:
6321 
   - success
6322 
   - cex
6323 
  """
6324 
 
6325 
  thrift_spec = (
6326 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
6327 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6328 
  )
6329 
 
6330 
  def __init__(self, success=None, cex=None,):
6331 
    self.success = success
6332 
    self.cex = cex
6333 
 
6334 
  def read(self, iprot):
6335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6337 
      return
6338 
    iprot.readStructBegin()
6339 
    while True:
6340 
      (fname, ftype, fid) = iprot.readFieldBegin()
6341 
      if ftype == TType.STOP:
6342 
        break
6343 
      if fid == 0:
6344 
        if ftype == TType.STRUCT:
6345 
          self.success = Item()
6346 
          self.success.read(iprot)
6347 
        else:
6348 
          iprot.skip(ftype)
6349 
      elif fid == 1:
6350 
        if ftype == TType.STRUCT:
6351 
          self.cex = CatalogServiceException()
6352 
          self.cex.read(iprot)
6353 
        else:
6354 
          iprot.skip(ftype)
6355 
      else:
6356 
        iprot.skip(ftype)
6357 
      iprot.readFieldEnd()
6358 
    iprot.readStructEnd()
6359 
 
6360 
  def write(self, oprot):
6361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6363 
      return
6364 
    oprot.writeStructBegin('getItem_result')
6365 
    if self.success is not None:
6366 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6367 
      self.success.write(oprot)
6368 
      oprot.writeFieldEnd()
6369 
    if self.cex is not None:
6370 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6371 
      self.cex.write(oprot)
6372 
      oprot.writeFieldEnd()
6373 
    oprot.writeFieldStop()
6374 
    oprot.writeStructEnd()
6375 
 
6376 
  def validate(self):
6377 
    return
6378 
 
6379 
 
6380 
  def __repr__(self):
6381 
    L = ['%s=%r' % (key, value)
6382 
      for key, value in self.__dict__.iteritems()]
6383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6384 
 
6385 
  def __eq__(self, other):
6386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6387 
 
6388 
  def __ne__(self, other):
6389 
    return not (self == other)
6390 
 
6391 
class getItemsByCatalogId_args:
6392 
  """
6393 
  Attributes:
6394 
   - catalog_item_id
6395 
  """
6396 
 
6397 
  thrift_spec = (
6398 
    None, # 0
6399 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6400 
  )
6401 
 
6402 
  def __init__(self, catalog_item_id=None,):
6403 
    self.catalog_item_id = catalog_item_id
6404 
 
6405 
  def read(self, iprot):
6406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6408 
      return
6409 
    iprot.readStructBegin()
6410 
    while True:
6411 
      (fname, ftype, fid) = iprot.readFieldBegin()
6412 
      if ftype == TType.STOP:
6413 
        break
6414 
      if fid == 1:
6415 
        if ftype == TType.I64:
6416 
          self.catalog_item_id = iprot.readI64();
6417 
        else:
6418 
          iprot.skip(ftype)
6419 
      else:
6420 
        iprot.skip(ftype)
6421 
      iprot.readFieldEnd()
6422 
    iprot.readStructEnd()
6423 
 
6424 
  def write(self, oprot):
6425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6427 
      return
6428 
    oprot.writeStructBegin('getItemsByCatalogId_args')
6429 
    if self.catalog_item_id is not None:
6430 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6431 
      oprot.writeI64(self.catalog_item_id)
6432 
      oprot.writeFieldEnd()
6433 
    oprot.writeFieldStop()
6434 
    oprot.writeStructEnd()
6435 
 
6436 
  def validate(self):
6437 
    return
6438 
 
6439 
 
6440 
  def __repr__(self):
6441 
    L = ['%s=%r' % (key, value)
6442 
      for key, value in self.__dict__.iteritems()]
6443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6444 
 
6445 
  def __eq__(self, other):
6446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6447 
 
6448 
  def __ne__(self, other):
6449 
    return not (self == other)
6450 
 
6451 
class getItemsByCatalogId_result:
6452 
  """
6453 
  Attributes:
6454 
   - success
6455 
   - cex
6456 
  """
6457 
 
6458 
  thrift_spec = (
6459 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6460 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6461 
  )
6462 
 
6463 
  def __init__(self, success=None, cex=None,):
6464 
    self.success = success
6465 
    self.cex = cex
6466 
 
6467 
  def read(self, iprot):
6468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6470 
      return
6471 
    iprot.readStructBegin()
6472 
    while True:
6473 
      (fname, ftype, fid) = iprot.readFieldBegin()
6474 
      if ftype == TType.STOP:
6475 
        break
6476 
      if fid == 0:
6477 
        if ftype == TType.LIST:
6478 
          self.success = []
7438 amit.gupta 6479 
          (_etype35, _size32) = iprot.readListBegin()
6480 
          for _i36 in xrange(_size32):
6481 
            _elem37 = Item()
6482 
            _elem37.read(iprot)
6483 
            self.success.append(_elem37)
5944 mandeep.dh 6484 
          iprot.readListEnd()
6485 
        else:
6486 
          iprot.skip(ftype)
6487 
      elif fid == 1:
6488 
        if ftype == TType.STRUCT:
6489 
          self.cex = CatalogServiceException()
6490 
          self.cex.read(iprot)
6491 
        else:
6492 
          iprot.skip(ftype)
6493 
      else:
6494 
        iprot.skip(ftype)
6495 
      iprot.readFieldEnd()
6496 
    iprot.readStructEnd()
6497 
 
6498 
  def write(self, oprot):
6499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6501 
      return
6502 
    oprot.writeStructBegin('getItemsByCatalogId_result')
6503 
    if self.success is not None:
6504 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6505 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6506 
      for iter38 in self.success:
6507 
        iter38.write(oprot)
5944 mandeep.dh 6508 
      oprot.writeListEnd()
6509 
      oprot.writeFieldEnd()
6510 
    if self.cex is not None:
6511 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6512 
      self.cex.write(oprot)
6513 
      oprot.writeFieldEnd()
6514 
    oprot.writeFieldStop()
6515 
    oprot.writeStructEnd()
6516 
 
6517 
  def validate(self):
6518 
    return
6519 
 
6520 
 
6521 
  def __repr__(self):
6522 
    L = ['%s=%r' % (key, value)
6523 
      for key, value in self.__dict__.iteritems()]
6524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6525 
 
6526 
  def __eq__(self, other):
6527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6528 
 
6529 
  def __ne__(self, other):
6530 
    return not (self == other)
6531 
 
6532 
class getValidItemsByCatalogId_args:
6533 
  """
6534 
  Attributes:
6535 
   - catalog_item_id
6536 
  """
6537 
 
6538 
  thrift_spec = (
6539 
    None, # 0
6540 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
6541 
  )
6542 
 
6543 
  def __init__(self, catalog_item_id=None,):
6544 
    self.catalog_item_id = catalog_item_id
6545 
 
6546 
  def read(self, iprot):
6547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6549 
      return
6550 
    iprot.readStructBegin()
6551 
    while True:
6552 
      (fname, ftype, fid) = iprot.readFieldBegin()
6553 
      if ftype == TType.STOP:
6554 
        break
6555 
      if fid == 1:
6556 
        if ftype == TType.I64:
6557 
          self.catalog_item_id = iprot.readI64();
6558 
        else:
6559 
          iprot.skip(ftype)
6560 
      else:
6561 
        iprot.skip(ftype)
6562 
      iprot.readFieldEnd()
6563 
    iprot.readStructEnd()
6564 
 
6565 
  def write(self, oprot):
6566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6568 
      return
6569 
    oprot.writeStructBegin('getValidItemsByCatalogId_args')
6570 
    if self.catalog_item_id is not None:
6571 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
6572 
      oprot.writeI64(self.catalog_item_id)
6573 
      oprot.writeFieldEnd()
6574 
    oprot.writeFieldStop()
6575 
    oprot.writeStructEnd()
6576 
 
6577 
  def validate(self):
6578 
    return
6579 
 
6580 
 
6581 
  def __repr__(self):
6582 
    L = ['%s=%r' % (key, value)
6583 
      for key, value in self.__dict__.iteritems()]
6584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6585 
 
6586 
  def __eq__(self, other):
6587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6588 
 
6589 
  def __ne__(self, other):
6590 
    return not (self == other)
6591 
 
6592 
class getValidItemsByCatalogId_result:
6593 
  """
6594 
  Attributes:
6595 
   - success
6596 
   - cex
6597 
  """
6598 
 
6599 
  thrift_spec = (
6600 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6601 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6602 
  )
6603 
 
6604 
  def __init__(self, success=None, cex=None,):
6605 
    self.success = success
6606 
    self.cex = cex
6607 
 
6608 
  def read(self, iprot):
6609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6611 
      return
6612 
    iprot.readStructBegin()
6613 
    while True:
6614 
      (fname, ftype, fid) = iprot.readFieldBegin()
6615 
      if ftype == TType.STOP:
6616 
        break
6617 
      if fid == 0:
6618 
        if ftype == TType.LIST:
6619 
          self.success = []
7438 amit.gupta 6620 
          (_etype42, _size39) = iprot.readListBegin()
6621 
          for _i43 in xrange(_size39):
6622 
            _elem44 = Item()
6623 
            _elem44.read(iprot)
6624 
            self.success.append(_elem44)
5944 mandeep.dh 6625 
          iprot.readListEnd()
6626 
        else:
6627 
          iprot.skip(ftype)
6628 
      elif fid == 1:
6629 
        if ftype == TType.STRUCT:
6630 
          self.cex = CatalogServiceException()
6631 
          self.cex.read(iprot)
6632 
        else:
6633 
          iprot.skip(ftype)
6634 
      else:
6635 
        iprot.skip(ftype)
6636 
      iprot.readFieldEnd()
6637 
    iprot.readStructEnd()
6638 
 
6639 
  def write(self, oprot):
6640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6642 
      return
6643 
    oprot.writeStructBegin('getValidItemsByCatalogId_result')
6644 
    if self.success is not None:
6645 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6646 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6647 
      for iter45 in self.success:
6648 
        iter45.write(oprot)
5944 mandeep.dh 6649 
      oprot.writeListEnd()
6650 
      oprot.writeFieldEnd()
6651 
    if self.cex is not None:
6652 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6653 
      self.cex.write(oprot)
6654 
      oprot.writeFieldEnd()
6655 
    oprot.writeFieldStop()
6656 
    oprot.writeStructEnd()
6657 
 
6658 
  def validate(self):
6659 
    return
6660 
 
6661 
 
6662 
  def __repr__(self):
6663 
    L = ['%s=%r' % (key, value)
6664 
      for key, value in self.__dict__.iteritems()]
6665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6666 
 
6667 
  def __eq__(self, other):
6668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6669 
 
6670 
  def __ne__(self, other):
6671 
    return not (self == other)
6672 
 
6673 
class getAllItems_args:
6674 
  """
6675 
  Attributes:
6676 
   - isActive
6677 
  """
6678 
 
6679 
  thrift_spec = (
6680 
    None, # 0
6681 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
6682 
  )
6683 
 
6684 
  def __init__(self, isActive=None,):
6685 
    self.isActive = isActive
6686 
 
6687 
  def read(self, iprot):
6688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6690 
      return
6691 
    iprot.readStructBegin()
6692 
    while True:
6693 
      (fname, ftype, fid) = iprot.readFieldBegin()
6694 
      if ftype == TType.STOP:
6695 
        break
6696 
      if fid == 1:
6697 
        if ftype == TType.BOOL:
6698 
          self.isActive = iprot.readBool();
6699 
        else:
6700 
          iprot.skip(ftype)
6701 
      else:
6702 
        iprot.skip(ftype)
6703 
      iprot.readFieldEnd()
6704 
    iprot.readStructEnd()
6705 
 
6706 
  def write(self, oprot):
6707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6709 
      return
6710 
    oprot.writeStructBegin('getAllItems_args')
6711 
    if self.isActive is not None:
6712 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
6713 
      oprot.writeBool(self.isActive)
6714 
      oprot.writeFieldEnd()
6715 
    oprot.writeFieldStop()
6716 
    oprot.writeStructEnd()
6717 
 
6718 
  def validate(self):
6719 
    return
6720 
 
6721 
 
6722 
  def __repr__(self):
6723 
    L = ['%s=%r' % (key, value)
6724 
      for key, value in self.__dict__.iteritems()]
6725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6726 
 
6727 
  def __eq__(self, other):
6728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6729 
 
6730 
  def __ne__(self, other):
6731 
    return not (self == other)
6732 
 
6733 
class getAllItems_result:
6734 
  """
6735 
  Attributes:
6736 
   - success
6737 
   - cex
6738 
  """
6739 
 
6740 
  thrift_spec = (
6741 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6742 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6743 
  )
6744 
 
6745 
  def __init__(self, success=None, cex=None,):
6746 
    self.success = success
6747 
    self.cex = cex
6748 
 
6749 
  def read(self, iprot):
6750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6752 
      return
6753 
    iprot.readStructBegin()
6754 
    while True:
6755 
      (fname, ftype, fid) = iprot.readFieldBegin()
6756 
      if ftype == TType.STOP:
6757 
        break
6758 
      if fid == 0:
6759 
        if ftype == TType.LIST:
6760 
          self.success = []
7438 amit.gupta 6761 
          (_etype49, _size46) = iprot.readListBegin()
6762 
          for _i50 in xrange(_size46):
6763 
            _elem51 = Item()
6764 
            _elem51.read(iprot)
6765 
            self.success.append(_elem51)
5944 mandeep.dh 6766 
          iprot.readListEnd()
6767 
        else:
6768 
          iprot.skip(ftype)
6769 
      elif fid == 1:
6770 
        if ftype == TType.STRUCT:
6771 
          self.cex = CatalogServiceException()
6772 
          self.cex.read(iprot)
6773 
        else:
6774 
          iprot.skip(ftype)
6775 
      else:
6776 
        iprot.skip(ftype)
6777 
      iprot.readFieldEnd()
6778 
    iprot.readStructEnd()
6779 
 
6780 
  def write(self, oprot):
6781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6783 
      return
6784 
    oprot.writeStructBegin('getAllItems_result')
6785 
    if self.success is not None:
6786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6788 
      for iter52 in self.success:
6789 
        iter52.write(oprot)
5944 mandeep.dh 6790 
      oprot.writeListEnd()
6791 
      oprot.writeFieldEnd()
6792 
    if self.cex is not None:
6793 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6794 
      self.cex.write(oprot)
6795 
      oprot.writeFieldEnd()
6796 
    oprot.writeFieldStop()
6797 
    oprot.writeStructEnd()
6798 
 
6799 
  def validate(self):
6800 
    return
6801 
 
6802 
 
6803 
  def __repr__(self):
6804 
    L = ['%s=%r' % (key, value)
6805 
      for key, value in self.__dict__.iteritems()]
6806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6807 
 
6808 
  def __eq__(self, other):
6809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6810 
 
6811 
  def __ne__(self, other):
6812 
    return not (self == other)
6813 
 
6814 
class getAllItemsByStatus_args:
6815 
  """
6816 
  Attributes:
6817 
   - itemStatus
6818 
  """
6819 
 
6820 
  thrift_spec = (
6821 
    None, # 0
6822 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
6823 
  )
6824 
 
6825 
  def __init__(self, itemStatus=None,):
6826 
    self.itemStatus = itemStatus
6827 
 
6828 
  def read(self, iprot):
6829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6831 
      return
6832 
    iprot.readStructBegin()
6833 
    while True:
6834 
      (fname, ftype, fid) = iprot.readFieldBegin()
6835 
      if ftype == TType.STOP:
6836 
        break
6837 
      if fid == 1:
6838 
        if ftype == TType.I32:
6839 
          self.itemStatus = iprot.readI32();
6840 
        else:
6841 
          iprot.skip(ftype)
6842 
      else:
6843 
        iprot.skip(ftype)
6844 
      iprot.readFieldEnd()
6845 
    iprot.readStructEnd()
6846 
 
6847 
  def write(self, oprot):
6848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6850 
      return
6851 
    oprot.writeStructBegin('getAllItemsByStatus_args')
6852 
    if self.itemStatus is not None:
6853 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
6854 
      oprot.writeI32(self.itemStatus)
6855 
      oprot.writeFieldEnd()
6856 
    oprot.writeFieldStop()
6857 
    oprot.writeStructEnd()
6858 
 
6859 
  def validate(self):
6860 
    return
6861 
 
6862 
 
6863 
  def __repr__(self):
6864 
    L = ['%s=%r' % (key, value)
6865 
      for key, value in self.__dict__.iteritems()]
6866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6867 
 
6868 
  def __eq__(self, other):
6869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6870 
 
6871 
  def __ne__(self, other):
6872 
    return not (self == other)
6873 
 
6874 
class getAllItemsByStatus_result:
6875 
  """
6876 
  Attributes:
6877 
   - success
6878 
   - cex
6879 
  """
6880 
 
6881 
  thrift_spec = (
6882 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
6883 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6884 
  )
6885 
 
6886 
  def __init__(self, success=None, cex=None,):
6887 
    self.success = success
6888 
    self.cex = cex
6889 
 
6890 
  def read(self, iprot):
6891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6893 
      return
6894 
    iprot.readStructBegin()
6895 
    while True:
6896 
      (fname, ftype, fid) = iprot.readFieldBegin()
6897 
      if ftype == TType.STOP:
6898 
        break
6899 
      if fid == 0:
6900 
        if ftype == TType.LIST:
6901 
          self.success = []
7438 amit.gupta 6902 
          (_etype56, _size53) = iprot.readListBegin()
6903 
          for _i57 in xrange(_size53):
6904 
            _elem58 = Item()
6905 
            _elem58.read(iprot)
6906 
            self.success.append(_elem58)
5944 mandeep.dh 6907 
          iprot.readListEnd()
6908 
        else:
6909 
          iprot.skip(ftype)
6910 
      elif fid == 1:
6911 
        if ftype == TType.STRUCT:
6912 
          self.cex = CatalogServiceException()
6913 
          self.cex.read(iprot)
6914 
        else:
6915 
          iprot.skip(ftype)
6916 
      else:
6917 
        iprot.skip(ftype)
6918 
      iprot.readFieldEnd()
6919 
    iprot.readStructEnd()
6920 
 
6921 
  def write(self, oprot):
6922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6924 
      return
6925 
    oprot.writeStructBegin('getAllItemsByStatus_result')
6926 
    if self.success is not None:
6927 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6928 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 6929 
      for iter59 in self.success:
6930 
        iter59.write(oprot)
5944 mandeep.dh 6931 
      oprot.writeListEnd()
6932 
      oprot.writeFieldEnd()
6933 
    if self.cex is not None:
6934 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6935 
      self.cex.write(oprot)
6936 
      oprot.writeFieldEnd()
6937 
    oprot.writeFieldStop()
6938 
    oprot.writeStructEnd()
6939 
 
6940 
  def validate(self):
6941 
    return
6942 
 
6943 
 
6944 
  def __repr__(self):
6945 
    L = ['%s=%r' % (key, value)
6946 
      for key, value in self.__dict__.iteritems()]
6947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6948 
 
6949 
  def __eq__(self, other):
6950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6951 
 
6952 
  def __ne__(self, other):
6953 
    return not (self == other)
6954 
 
6955 
class markItemAsContentComplete_args:
6956 
  """
6957 
  Attributes:
6958 
   - entityId
6959 
   - category
6960 
   - brand
6961 
   - modelName
6962 
   - modelNumber
6963 
  """
6964 
 
6965 
  thrift_spec = (
6966 
    None, # 0
6967 
    (1, TType.I64, 'entityId', None, None, ), # 1
6968 
    (2, TType.I64, 'category', None, None, ), # 2
6969 
    (3, TType.STRING, 'brand', None, None, ), # 3
6970 
    (4, TType.STRING, 'modelName', None, None, ), # 4
6971 
    (5, TType.STRING, 'modelNumber', None, None, ), # 5
6972 
  )
6973 
 
6974 
  def __init__(self, entityId=None, category=None, brand=None, modelName=None, modelNumber=None,):
6975 
    self.entityId = entityId
6976 
    self.category = category
6977 
    self.brand = brand
6978 
    self.modelName = modelName
6979 
    self.modelNumber = modelNumber
6980 
 
6981 
  def read(self, iprot):
6982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6984 
      return
6985 
    iprot.readStructBegin()
6986 
    while True:
6987 
      (fname, ftype, fid) = iprot.readFieldBegin()
6988 
      if ftype == TType.STOP:
6989 
        break
6990 
      if fid == 1:
6991 
        if ftype == TType.I64:
6992 
          self.entityId = iprot.readI64();
6993 
        else:
6994 
          iprot.skip(ftype)
6995 
      elif fid == 2:
6996 
        if ftype == TType.I64:
6997 
          self.category = iprot.readI64();
6998 
        else:
6999 
          iprot.skip(ftype)
7000 
      elif fid == 3:
7001 
        if ftype == TType.STRING:
7002 
          self.brand = iprot.readString();
7003 
        else:
7004 
          iprot.skip(ftype)
7005 
      elif fid == 4:
7006 
        if ftype == TType.STRING:
7007 
          self.modelName = iprot.readString();
7008 
        else:
7009 
          iprot.skip(ftype)
7010 
      elif fid == 5:
7011 
        if ftype == TType.STRING:
7012 
          self.modelNumber = iprot.readString();
7013 
        else:
7014 
          iprot.skip(ftype)
7015 
      else:
7016 
        iprot.skip(ftype)
7017 
      iprot.readFieldEnd()
7018 
    iprot.readStructEnd()
7019 
 
7020 
  def write(self, oprot):
7021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7023 
      return
7024 
    oprot.writeStructBegin('markItemAsContentComplete_args')
7025 
    if self.entityId is not None:
7026 
      oprot.writeFieldBegin('entityId', TType.I64, 1)
7027 
      oprot.writeI64(self.entityId)
7028 
      oprot.writeFieldEnd()
7029 
    if self.category is not None:
7030 
      oprot.writeFieldBegin('category', TType.I64, 2)
7031 
      oprot.writeI64(self.category)
7032 
      oprot.writeFieldEnd()
7033 
    if self.brand is not None:
7034 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7035 
      oprot.writeString(self.brand)
7036 
      oprot.writeFieldEnd()
7037 
    if self.modelName is not None:
7038 
      oprot.writeFieldBegin('modelName', TType.STRING, 4)
7039 
      oprot.writeString(self.modelName)
7040 
      oprot.writeFieldEnd()
7041 
    if self.modelNumber is not None:
7042 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 5)
7043 
      oprot.writeString(self.modelNumber)
7044 
      oprot.writeFieldEnd()
7045 
    oprot.writeFieldStop()
7046 
    oprot.writeStructEnd()
7047 
 
7048 
  def validate(self):
7049 
    return
7050 
 
7051 
 
7052 
  def __repr__(self):
7053 
    L = ['%s=%r' % (key, value)
7054 
      for key, value in self.__dict__.iteritems()]
7055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7056 
 
7057 
  def __eq__(self, other):
7058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7059 
 
7060 
  def __ne__(self, other):
7061 
    return not (self == other)
7062 
 
7063 
class markItemAsContentComplete_result:
7064 
  """
7065 
  Attributes:
7066 
   - success
7067 
   - cex
7068 
  """
7069 
 
7070 
  thrift_spec = (
7071 
    (0, TType.BOOL, 'success', None, None, ), # 0
7072 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7073 
  )
7074 
 
7075 
  def __init__(self, success=None, cex=None,):
7076 
    self.success = success
7077 
    self.cex = cex
7078 
 
7079 
  def read(self, iprot):
7080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7082 
      return
7083 
    iprot.readStructBegin()
7084 
    while True:
7085 
      (fname, ftype, fid) = iprot.readFieldBegin()
7086 
      if ftype == TType.STOP:
7087 
        break
7088 
      if fid == 0:
7089 
        if ftype == TType.BOOL:
7090 
          self.success = iprot.readBool();
7091 
        else:
7092 
          iprot.skip(ftype)
7093 
      elif fid == 1:
7094 
        if ftype == TType.STRUCT:
7095 
          self.cex = CatalogServiceException()
7096 
          self.cex.read(iprot)
7097 
        else:
7098 
          iprot.skip(ftype)
7099 
      else:
7100 
        iprot.skip(ftype)
7101 
      iprot.readFieldEnd()
7102 
    iprot.readStructEnd()
7103 
 
7104 
  def write(self, oprot):
7105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7107 
      return
7108 
    oprot.writeStructBegin('markItemAsContentComplete_result')
7109 
    if self.success is not None:
7110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7111 
      oprot.writeBool(self.success)
7112 
      oprot.writeFieldEnd()
7113 
    if self.cex is not None:
7114 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7115 
      self.cex.write(oprot)
7116 
      oprot.writeFieldEnd()
7117 
    oprot.writeFieldStop()
7118 
    oprot.writeStructEnd()
7119 
 
7120 
  def validate(self):
7121 
    return
7122 
 
7123 
 
7124 
  def __repr__(self):
7125 
    L = ['%s=%r' % (key, value)
7126 
      for key, value in self.__dict__.iteritems()]
7127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7128 
 
7129 
  def __eq__(self, other):
7130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7131 
 
7132 
  def __ne__(self, other):
7133 
    return not (self == other)
7134 
 
7135 
class getAllItemsInRange_args:
7136 
  """
7137 
  Attributes:
7138 
   - offset
7139 
   - limit
7140 
  """
7141 
 
7142 
  thrift_spec = (
7143 
    None, # 0
7144 
    (1, TType.I64, 'offset', None, None, ), # 1
7145 
    (2, TType.I64, 'limit', None, None, ), # 2
7146 
  )
7147 
 
7148 
  def __init__(self, offset=None, limit=None,):
7149 
    self.offset = offset
7150 
    self.limit = limit
7151 
 
7152 
  def read(self, iprot):
7153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7155 
      return
7156 
    iprot.readStructBegin()
7157 
    while True:
7158 
      (fname, ftype, fid) = iprot.readFieldBegin()
7159 
      if ftype == TType.STOP:
7160 
        break
7161 
      if fid == 1:
7162 
        if ftype == TType.I64:
7163 
          self.offset = iprot.readI64();
7164 
        else:
7165 
          iprot.skip(ftype)
7166 
      elif fid == 2:
7167 
        if ftype == TType.I64:
7168 
          self.limit = iprot.readI64();
7169 
        else:
7170 
          iprot.skip(ftype)
7171 
      else:
7172 
        iprot.skip(ftype)
7173 
      iprot.readFieldEnd()
7174 
    iprot.readStructEnd()
7175 
 
7176 
  def write(self, oprot):
7177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7179 
      return
7180 
    oprot.writeStructBegin('getAllItemsInRange_args')
7181 
    if self.offset is not None:
7182 
      oprot.writeFieldBegin('offset', TType.I64, 1)
7183 
      oprot.writeI64(self.offset)
7184 
      oprot.writeFieldEnd()
7185 
    if self.limit is not None:
7186 
      oprot.writeFieldBegin('limit', TType.I64, 2)
7187 
      oprot.writeI64(self.limit)
7188 
      oprot.writeFieldEnd()
7189 
    oprot.writeFieldStop()
7190 
    oprot.writeStructEnd()
7191 
 
7192 
  def validate(self):
7193 
    return
7194 
 
7195 
 
7196 
  def __repr__(self):
7197 
    L = ['%s=%r' % (key, value)
7198 
      for key, value in self.__dict__.iteritems()]
7199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7200 
 
7201 
  def __eq__(self, other):
7202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7203 
 
7204 
  def __ne__(self, other):
7205 
    return not (self == other)
7206 
 
7207 
class getAllItemsInRange_result:
7208 
  """
7209 
  Attributes:
7210 
   - success
7211 
   - cex
7212 
  """
7213 
 
7214 
  thrift_spec = (
7215 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7216 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7217 
  )
7218 
 
7219 
  def __init__(self, success=None, cex=None,):
7220 
    self.success = success
7221 
    self.cex = cex
7222 
 
7223 
  def read(self, iprot):
7224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7226 
      return
7227 
    iprot.readStructBegin()
7228 
    while True:
7229 
      (fname, ftype, fid) = iprot.readFieldBegin()
7230 
      if ftype == TType.STOP:
7231 
        break
7232 
      if fid == 0:
7233 
        if ftype == TType.LIST:
7234 
          self.success = []
7438 amit.gupta 7235 
          (_etype63, _size60) = iprot.readListBegin()
7236 
          for _i64 in xrange(_size60):
7237 
            _elem65 = Item()
7238 
            _elem65.read(iprot)
7239 
            self.success.append(_elem65)
5944 mandeep.dh 7240 
          iprot.readListEnd()
7241 
        else:
7242 
          iprot.skip(ftype)
7243 
      elif fid == 1:
7244 
        if ftype == TType.STRUCT:
7245 
          self.cex = CatalogServiceException()
7246 
          self.cex.read(iprot)
7247 
        else:
7248 
          iprot.skip(ftype)
7249 
      else:
7250 
        iprot.skip(ftype)
7251 
      iprot.readFieldEnd()
7252 
    iprot.readStructEnd()
7253 
 
7254 
  def write(self, oprot):
7255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7257 
      return
7258 
    oprot.writeStructBegin('getAllItemsInRange_result')
7259 
    if self.success is not None:
7260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7261 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7262 
      for iter66 in self.success:
7263 
        iter66.write(oprot)
5944 mandeep.dh 7264 
      oprot.writeListEnd()
7265 
      oprot.writeFieldEnd()
7266 
    if self.cex is not None:
7267 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7268 
      self.cex.write(oprot)
7269 
      oprot.writeFieldEnd()
7270 
    oprot.writeFieldStop()
7271 
    oprot.writeStructEnd()
7272 
 
7273 
  def validate(self):
7274 
    return
7275 
 
7276 
 
7277 
  def __repr__(self):
7278 
    L = ['%s=%r' % (key, value)
7279 
      for key, value in self.__dict__.iteritems()]
7280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7281 
 
7282 
  def __eq__(self, other):
7283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7284 
 
7285 
  def __ne__(self, other):
7286 
    return not (self == other)
7287 
 
7288 
class getAllItemsByStatusInRange_args:
7289 
  """
7290 
  Attributes:
7291 
   - itemStatus
7292 
   - offset
7293 
   - limit
7294 
  """
7295 
 
7296 
  thrift_spec = (
7297 
    None, # 0
7298 
    (1, TType.I32, 'itemStatus', None, None, ), # 1
7299 
    (2, TType.I64, 'offset', None, None, ), # 2
7300 
    (3, TType.I64, 'limit', None, None, ), # 3
7301 
  )
7302 
 
7303 
  def __init__(self, itemStatus=None, offset=None, limit=None,):
7304 
    self.itemStatus = itemStatus
7305 
    self.offset = offset
7306 
    self.limit = limit
7307 
 
7308 
  def read(self, iprot):
7309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7311 
      return
7312 
    iprot.readStructBegin()
7313 
    while True:
7314 
      (fname, ftype, fid) = iprot.readFieldBegin()
7315 
      if ftype == TType.STOP:
7316 
        break
7317 
      if fid == 1:
7318 
        if ftype == TType.I32:
7319 
          self.itemStatus = iprot.readI32();
7320 
        else:
7321 
          iprot.skip(ftype)
7322 
      elif fid == 2:
7323 
        if ftype == TType.I64:
7324 
          self.offset = iprot.readI64();
7325 
        else:
7326 
          iprot.skip(ftype)
7327 
      elif fid == 3:
7328 
        if ftype == TType.I64:
7329 
          self.limit = iprot.readI64();
7330 
        else:
7331 
          iprot.skip(ftype)
7332 
      else:
7333 
        iprot.skip(ftype)
7334 
      iprot.readFieldEnd()
7335 
    iprot.readStructEnd()
7336 
 
7337 
  def write(self, oprot):
7338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7340 
      return
7341 
    oprot.writeStructBegin('getAllItemsByStatusInRange_args')
7342 
    if self.itemStatus is not None:
7343 
      oprot.writeFieldBegin('itemStatus', TType.I32, 1)
7344 
      oprot.writeI32(self.itemStatus)
7345 
      oprot.writeFieldEnd()
7346 
    if self.offset is not None:
7347 
      oprot.writeFieldBegin('offset', TType.I64, 2)
7348 
      oprot.writeI64(self.offset)
7349 
      oprot.writeFieldEnd()
7350 
    if self.limit is not None:
7351 
      oprot.writeFieldBegin('limit', TType.I64, 3)
7352 
      oprot.writeI64(self.limit)
7353 
      oprot.writeFieldEnd()
7354 
    oprot.writeFieldStop()
7355 
    oprot.writeStructEnd()
7356 
 
7357 
  def validate(self):
7358 
    return
7359 
 
7360 
 
7361 
  def __repr__(self):
7362 
    L = ['%s=%r' % (key, value)
7363 
      for key, value in self.__dict__.iteritems()]
7364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7365 
 
7366 
  def __eq__(self, other):
7367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7368 
 
7369 
  def __ne__(self, other):
7370 
    return not (self == other)
7371 
 
7372 
class getAllItemsByStatusInRange_result:
7373 
  """
7374 
  Attributes:
7375 
   - success
7376 
   - cex
7377 
  """
7378 
 
7379 
  thrift_spec = (
7380 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7381 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7382 
  )
7383 
 
7384 
  def __init__(self, success=None, cex=None,):
7385 
    self.success = success
7386 
    self.cex = cex
7387 
 
7388 
  def read(self, iprot):
7389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7391 
      return
7392 
    iprot.readStructBegin()
7393 
    while True:
7394 
      (fname, ftype, fid) = iprot.readFieldBegin()
7395 
      if ftype == TType.STOP:
7396 
        break
7397 
      if fid == 0:
7398 
        if ftype == TType.LIST:
7399 
          self.success = []
7438 amit.gupta 7400 
          (_etype70, _size67) = iprot.readListBegin()
7401 
          for _i71 in xrange(_size67):
7402 
            _elem72 = Item()
7403 
            _elem72.read(iprot)
7404 
            self.success.append(_elem72)
5944 mandeep.dh 7405 
          iprot.readListEnd()
7406 
        else:
7407 
          iprot.skip(ftype)
7408 
      elif fid == 1:
7409 
        if ftype == TType.STRUCT:
7410 
          self.cex = CatalogServiceException()
7411 
          self.cex.read(iprot)
7412 
        else:
7413 
          iprot.skip(ftype)
7414 
      else:
7415 
        iprot.skip(ftype)
7416 
      iprot.readFieldEnd()
7417 
    iprot.readStructEnd()
7418 
 
7419 
  def write(self, oprot):
7420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7422 
      return
7423 
    oprot.writeStructBegin('getAllItemsByStatusInRange_result')
7424 
    if self.success is not None:
7425 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7426 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7427 
      for iter73 in self.success:
7428 
        iter73.write(oprot)
5944 mandeep.dh 7429 
      oprot.writeListEnd()
7430 
      oprot.writeFieldEnd()
7431 
    if self.cex is not None:
7432 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7433 
      self.cex.write(oprot)
7434 
      oprot.writeFieldEnd()
7435 
    oprot.writeFieldStop()
7436 
    oprot.writeStructEnd()
7437 
 
7438 
  def validate(self):
7439 
    return
7440 
 
7441 
 
7442 
  def __repr__(self):
7443 
    L = ['%s=%r' % (key, value)
7444 
      for key, value in self.__dict__.iteritems()]
7445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7446 
 
7447 
  def __eq__(self, other):
7448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7449 
 
7450 
  def __ne__(self, other):
7451 
    return not (self == other)
7452 
 
7453 
class getItemCountByStatus_args:
7454 
  """
7455 
  Attributes:
7456 
   - useStatus
7457 
   - itemStatus
7458 
  """
7459 
 
7460 
  thrift_spec = (
7461 
    None, # 0
7462 
    (1, TType.BOOL, 'useStatus', None, None, ), # 1
7463 
    (2, TType.I32, 'itemStatus', None, None, ), # 2
7464 
  )
7465 
 
7466 
  def __init__(self, useStatus=None, itemStatus=None,):
7467 
    self.useStatus = useStatus
7468 
    self.itemStatus = itemStatus
7469 
 
7470 
  def read(self, iprot):
7471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7473 
      return
7474 
    iprot.readStructBegin()
7475 
    while True:
7476 
      (fname, ftype, fid) = iprot.readFieldBegin()
7477 
      if ftype == TType.STOP:
7478 
        break
7479 
      if fid == 1:
7480 
        if ftype == TType.BOOL:
7481 
          self.useStatus = iprot.readBool();
7482 
        else:
7483 
          iprot.skip(ftype)
7484 
      elif fid == 2:
7485 
        if ftype == TType.I32:
7486 
          self.itemStatus = iprot.readI32();
7487 
        else:
7488 
          iprot.skip(ftype)
7489 
      else:
7490 
        iprot.skip(ftype)
7491 
      iprot.readFieldEnd()
7492 
    iprot.readStructEnd()
7493 
 
7494 
  def write(self, oprot):
7495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7497 
      return
7498 
    oprot.writeStructBegin('getItemCountByStatus_args')
7499 
    if self.useStatus is not None:
7500 
      oprot.writeFieldBegin('useStatus', TType.BOOL, 1)
7501 
      oprot.writeBool(self.useStatus)
7502 
      oprot.writeFieldEnd()
7503 
    if self.itemStatus is not None:
7504 
      oprot.writeFieldBegin('itemStatus', TType.I32, 2)
7505 
      oprot.writeI32(self.itemStatus)
7506 
      oprot.writeFieldEnd()
7507 
    oprot.writeFieldStop()
7508 
    oprot.writeStructEnd()
7509 
 
7510 
  def validate(self):
7511 
    return
7512 
 
7513 
 
7514 
  def __repr__(self):
7515 
    L = ['%s=%r' % (key, value)
7516 
      for key, value in self.__dict__.iteritems()]
7517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7518 
 
7519 
  def __eq__(self, other):
7520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7521 
 
7522 
  def __ne__(self, other):
7523 
    return not (self == other)
7524 
 
7525 
class getItemCountByStatus_result:
7526 
  """
7527 
  Attributes:
7528 
   - success
7529 
  """
7530 
 
7531 
  thrift_spec = (
7532 
    (0, TType.I32, 'success', None, None, ), # 0
7533 
  )
7534 
 
7535 
  def __init__(self, success=None,):
7536 
    self.success = success
7537 
 
7538 
  def read(self, iprot):
7539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7541 
      return
7542 
    iprot.readStructBegin()
7543 
    while True:
7544 
      (fname, ftype, fid) = iprot.readFieldBegin()
7545 
      if ftype == TType.STOP:
7546 
        break
7547 
      if fid == 0:
7548 
        if ftype == TType.I32:
7549 
          self.success = iprot.readI32();
7550 
        else:
7551 
          iprot.skip(ftype)
7552 
      else:
7553 
        iprot.skip(ftype)
7554 
      iprot.readFieldEnd()
7555 
    iprot.readStructEnd()
7556 
 
7557 
  def write(self, oprot):
7558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7560 
      return
7561 
    oprot.writeStructBegin('getItemCountByStatus_result')
7562 
    if self.success is not None:
7563 
      oprot.writeFieldBegin('success', TType.I32, 0)
7564 
      oprot.writeI32(self.success)
7565 
      oprot.writeFieldEnd()
7566 
    oprot.writeFieldStop()
7567 
    oprot.writeStructEnd()
7568 
 
7569 
  def validate(self):
7570 
    return
7571 
 
7572 
 
7573 
  def __repr__(self):
7574 
    L = ['%s=%r' % (key, value)
7575 
      for key, value in self.__dict__.iteritems()]
7576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7577 
 
7578 
  def __eq__(self, other):
7579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7580 
 
7581 
  def __ne__(self, other):
7582 
    return not (self == other)
7583 
 
7584 
class getBestSellers_args:
7585 
 
7586 
  thrift_spec = (
7587 
  )
7588 
 
7589 
  def read(self, iprot):
7590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7592 
      return
7593 
    iprot.readStructBegin()
7594 
    while True:
7595 
      (fname, ftype, fid) = iprot.readFieldBegin()
7596 
      if ftype == TType.STOP:
7597 
        break
7598 
      else:
7599 
        iprot.skip(ftype)
7600 
      iprot.readFieldEnd()
7601 
    iprot.readStructEnd()
7602 
 
7603 
  def write(self, oprot):
7604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7606 
      return
7607 
    oprot.writeStructBegin('getBestSellers_args')
7608 
    oprot.writeFieldStop()
7609 
    oprot.writeStructEnd()
7610 
 
7611 
  def validate(self):
7612 
    return
7613 
 
7614 
 
7615 
  def __repr__(self):
7616 
    L = ['%s=%r' % (key, value)
7617 
      for key, value in self.__dict__.iteritems()]
7618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7619 
 
7620 
  def __eq__(self, other):
7621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7622 
 
7623 
  def __ne__(self, other):
7624 
    return not (self == other)
7625 
 
7626 
class getBestSellers_result:
7627 
  """
7628 
  Attributes:
7629 
   - success
7630 
   - isex
7631 
  """
7632 
 
7633 
  thrift_spec = (
7634 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
7635 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7636 
  )
7637 
 
7638 
  def __init__(self, success=None, isex=None,):
7639 
    self.success = success
7640 
    self.isex = isex
7641 
 
7642 
  def read(self, iprot):
7643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7645 
      return
7646 
    iprot.readStructBegin()
7647 
    while True:
7648 
      (fname, ftype, fid) = iprot.readFieldBegin()
7649 
      if ftype == TType.STOP:
7650 
        break
7651 
      if fid == 0:
7652 
        if ftype == TType.LIST:
7653 
          self.success = []
7438 amit.gupta 7654 
          (_etype77, _size74) = iprot.readListBegin()
7655 
          for _i78 in xrange(_size74):
7656 
            _elem79 = Item()
7657 
            _elem79.read(iprot)
7658 
            self.success.append(_elem79)
5944 mandeep.dh 7659 
          iprot.readListEnd()
7660 
        else:
7661 
          iprot.skip(ftype)
7662 
      elif fid == 1:
7663 
        if ftype == TType.STRUCT:
7664 
          self.isex = CatalogServiceException()
7665 
          self.isex.read(iprot)
7666 
        else:
7667 
          iprot.skip(ftype)
7668 
      else:
7669 
        iprot.skip(ftype)
7670 
      iprot.readFieldEnd()
7671 
    iprot.readStructEnd()
7672 
 
7673 
  def write(self, oprot):
7674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7676 
      return
7677 
    oprot.writeStructBegin('getBestSellers_result')
7678 
    if self.success is not None:
7679 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7680 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 7681 
      for iter80 in self.success:
7682 
        iter80.write(oprot)
5944 mandeep.dh 7683 
      oprot.writeListEnd()
7684 
      oprot.writeFieldEnd()
7685 
    if self.isex is not None:
7686 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
7687 
      self.isex.write(oprot)
7688 
      oprot.writeFieldEnd()
7689 
    oprot.writeFieldStop()
7690 
    oprot.writeStructEnd()
7691 
 
7692 
  def validate(self):
7693 
    return
7694 
 
7695 
 
7696 
  def __repr__(self):
7697 
    L = ['%s=%r' % (key, value)
7698 
      for key, value in self.__dict__.iteritems()]
7699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7700 
 
7701 
  def __eq__(self, other):
7702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7703 
 
7704 
  def __ne__(self, other):
7705 
    return not (self == other)
7706 
 
7707 
class getBestSellersCatalogIds_args:
7708 
  """
7709 
  Attributes:
7710 
   - beginIndex
7711 
   - totalItems
7712 
   - brand
7713 
   - category
7714 
  """
7715 
 
7716 
  thrift_spec = (
7717 
    None, # 0
7718 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
7719 
    (2, TType.I64, 'totalItems', None, None, ), # 2
7720 
    (3, TType.STRING, 'brand', None, None, ), # 3
7721 
    (4, TType.I64, 'category', None, None, ), # 4
7722 
  )
7723 
 
7724 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
7725 
    self.beginIndex = beginIndex
7726 
    self.totalItems = totalItems
7727 
    self.brand = brand
7728 
    self.category = category
7729 
 
7730 
  def read(self, iprot):
7731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7733 
      return
7734 
    iprot.readStructBegin()
7735 
    while True:
7736 
      (fname, ftype, fid) = iprot.readFieldBegin()
7737 
      if ftype == TType.STOP:
7738 
        break
7739 
      if fid == 1:
7740 
        if ftype == TType.I64:
7741 
          self.beginIndex = iprot.readI64();
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      elif fid == 2:
7745 
        if ftype == TType.I64:
7746 
          self.totalItems = iprot.readI64();
7747 
        else:
7748 
          iprot.skip(ftype)
7749 
      elif fid == 3:
7750 
        if ftype == TType.STRING:
7751 
          self.brand = iprot.readString();
7752 
        else:
7753 
          iprot.skip(ftype)
7754 
      elif fid == 4:
7755 
        if ftype == TType.I64:
7756 
          self.category = iprot.readI64();
7757 
        else:
7758 
          iprot.skip(ftype)
7759 
      else:
7760 
        iprot.skip(ftype)
7761 
      iprot.readFieldEnd()
7762 
    iprot.readStructEnd()
7763 
 
7764 
  def write(self, oprot):
7765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7767 
      return
7768 
    oprot.writeStructBegin('getBestSellersCatalogIds_args')
7769 
    if self.beginIndex is not None:
7770 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
7771 
      oprot.writeI64(self.beginIndex)
7772 
      oprot.writeFieldEnd()
7773 
    if self.totalItems is not None:
7774 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
7775 
      oprot.writeI64(self.totalItems)
7776 
      oprot.writeFieldEnd()
7777 
    if self.brand is not None:
7778 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
7779 
      oprot.writeString(self.brand)
7780 
      oprot.writeFieldEnd()
7781 
    if self.category is not None:
7782 
      oprot.writeFieldBegin('category', TType.I64, 4)
7783 
      oprot.writeI64(self.category)
7784 
      oprot.writeFieldEnd()
7785 
    oprot.writeFieldStop()
7786 
    oprot.writeStructEnd()
7787 
 
7788 
  def validate(self):
7789 
    return
7790 
 
7791 
 
7792 
  def __repr__(self):
7793 
    L = ['%s=%r' % (key, value)
7794 
      for key, value in self.__dict__.iteritems()]
7795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7796 
 
7797 
  def __eq__(self, other):
7798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7799 
 
7800 
  def __ne__(self, other):
7801 
    return not (self == other)
7802 
 
7803 
class getBestSellersCatalogIds_result:
7804 
  """
7805 
  Attributes:
7806 
   - success
7807 
   - cex
7808 
  """
7809 
 
7810 
  thrift_spec = (
7811 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
7812 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7813 
  )
7814 
 
7815 
  def __init__(self, success=None, cex=None,):
7816 
    self.success = success
7817 
    self.cex = cex
7818 
 
7819 
  def read(self, iprot):
7820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7822 
      return
7823 
    iprot.readStructBegin()
7824 
    while True:
7825 
      (fname, ftype, fid) = iprot.readFieldBegin()
7826 
      if ftype == TType.STOP:
7827 
        break
7828 
      if fid == 0:
7829 
        if ftype == TType.LIST:
7830 
          self.success = []
7438 amit.gupta 7831 
          (_etype84, _size81) = iprot.readListBegin()
7832 
          for _i85 in xrange(_size81):
7833 
            _elem86 = iprot.readI64();
7834 
            self.success.append(_elem86)
5944 mandeep.dh 7835 
          iprot.readListEnd()
7836 
        else:
7837 
          iprot.skip(ftype)
7838 
      elif fid == 1:
7839 
        if ftype == TType.STRUCT:
7840 
          self.cex = CatalogServiceException()
7841 
          self.cex.read(iprot)
7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      else:
7845 
        iprot.skip(ftype)
7846 
      iprot.readFieldEnd()
7847 
    iprot.readStructEnd()
7848 
 
7849 
  def write(self, oprot):
7850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7852 
      return
7853 
    oprot.writeStructBegin('getBestSellersCatalogIds_result')
7854 
    if self.success is not None:
7855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7856 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 7857 
      for iter87 in self.success:
7858 
        oprot.writeI64(iter87)
5944 mandeep.dh 7859 
      oprot.writeListEnd()
7860 
      oprot.writeFieldEnd()
7861 
    if self.cex is not None:
7862 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7863 
      self.cex.write(oprot)
7864 
      oprot.writeFieldEnd()
7865 
    oprot.writeFieldStop()
7866 
    oprot.writeStructEnd()
7867 
 
7868 
  def validate(self):
7869 
    return
7870 
 
7871 
 
7872 
  def __repr__(self):
7873 
    L = ['%s=%r' % (key, value)
7874 
      for key, value in self.__dict__.iteritems()]
7875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7876 
 
7877 
  def __eq__(self, other):
7878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7879 
 
7880 
  def __ne__(self, other):
7881 
    return not (self == other)
7882 
 
7883 
class getBestSellersCount_args:
7884 
 
7885 
  thrift_spec = (
7886 
  )
7887 
 
7888 
  def read(self, iprot):
7889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7891 
      return
7892 
    iprot.readStructBegin()
7893 
    while True:
7894 
      (fname, ftype, fid) = iprot.readFieldBegin()
7895 
      if ftype == TType.STOP:
7896 
        break
7897 
      else:
7898 
        iprot.skip(ftype)
7899 
      iprot.readFieldEnd()
7900 
    iprot.readStructEnd()
7901 
 
7902 
  def write(self, oprot):
7903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7905 
      return
7906 
    oprot.writeStructBegin('getBestSellersCount_args')
7907 
    oprot.writeFieldStop()
7908 
    oprot.writeStructEnd()
7909 
 
7910 
  def validate(self):
7911 
    return
7912 
 
7913 
 
7914 
  def __repr__(self):
7915 
    L = ['%s=%r' % (key, value)
7916 
      for key, value in self.__dict__.iteritems()]
7917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7918 
 
7919 
  def __eq__(self, other):
7920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7921 
 
7922 
  def __ne__(self, other):
7923 
    return not (self == other)
7924 
 
7925 
class getBestSellersCount_result:
7926 
  """
7927 
  Attributes:
7928 
   - success
7929 
   - cex
7930 
  """
7931 
 
7932 
  thrift_spec = (
7933 
    (0, TType.I64, 'success', None, None, ), # 0
7934 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
7935 
  )
7936 
 
7937 
  def __init__(self, success=None, cex=None,):
7938 
    self.success = success
7939 
    self.cex = cex
7940 
 
7941 
  def read(self, iprot):
7942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7944 
      return
7945 
    iprot.readStructBegin()
7946 
    while True:
7947 
      (fname, ftype, fid) = iprot.readFieldBegin()
7948 
      if ftype == TType.STOP:
7949 
        break
7950 
      if fid == 0:
7951 
        if ftype == TType.I64:
7952 
          self.success = iprot.readI64();
7953 
        else:
7954 
          iprot.skip(ftype)
7955 
      elif fid == 1:
7956 
        if ftype == TType.STRUCT:
7957 
          self.cex = CatalogServiceException()
7958 
          self.cex.read(iprot)
7959 
        else:
7960 
          iprot.skip(ftype)
7961 
      else:
7962 
        iprot.skip(ftype)
7963 
      iprot.readFieldEnd()
7964 
    iprot.readStructEnd()
7965 
 
7966 
  def write(self, oprot):
7967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7969 
      return
7970 
    oprot.writeStructBegin('getBestSellersCount_result')
7971 
    if self.success is not None:
7972 
      oprot.writeFieldBegin('success', TType.I64, 0)
7973 
      oprot.writeI64(self.success)
7974 
      oprot.writeFieldEnd()
7975 
    if self.cex is not None:
7976 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7977 
      self.cex.write(oprot)
7978 
      oprot.writeFieldEnd()
7979 
    oprot.writeFieldStop()
7980 
    oprot.writeStructEnd()
7981 
 
7982 
  def validate(self):
7983 
    return
7984 
 
7985 
 
7986 
  def __repr__(self):
7987 
    L = ['%s=%r' % (key, value)
7988 
      for key, value in self.__dict__.iteritems()]
7989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7990 
 
7991 
  def __eq__(self, other):
7992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7993 
 
7994 
  def __ne__(self, other):
7995 
    return not (self == other)
7996 
 
7997 
class getBestDeals_args:
7998 
 
7999 
  thrift_spec = (
8000 
  )
8001 
 
8002 
  def read(self, iprot):
8003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8005 
      return
8006 
    iprot.readStructBegin()
8007 
    while True:
8008 
      (fname, ftype, fid) = iprot.readFieldBegin()
8009 
      if ftype == TType.STOP:
8010 
        break
8011 
      else:
8012 
        iprot.skip(ftype)
8013 
      iprot.readFieldEnd()
8014 
    iprot.readStructEnd()
8015 
 
8016 
  def write(self, oprot):
8017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8019 
      return
8020 
    oprot.writeStructBegin('getBestDeals_args')
8021 
    oprot.writeFieldStop()
8022 
    oprot.writeStructEnd()
8023 
 
8024 
  def validate(self):
8025 
    return
8026 
 
8027 
 
8028 
  def __repr__(self):
8029 
    L = ['%s=%r' % (key, value)
8030 
      for key, value in self.__dict__.iteritems()]
8031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8032 
 
8033 
  def __eq__(self, other):
8034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8035 
 
8036 
  def __ne__(self, other):
8037 
    return not (self == other)
8038 
 
8039 
class getBestDeals_result:
8040 
  """
8041 
  Attributes:
8042 
   - success
8043 
   - isex
8044 
  """
8045 
 
8046 
  thrift_spec = (
8047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8048 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8049 
  )
8050 
 
8051 
  def __init__(self, success=None, isex=None,):
8052 
    self.success = success
8053 
    self.isex = isex
8054 
 
8055 
  def read(self, iprot):
8056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8058 
      return
8059 
    iprot.readStructBegin()
8060 
    while True:
8061 
      (fname, ftype, fid) = iprot.readFieldBegin()
8062 
      if ftype == TType.STOP:
8063 
        break
8064 
      if fid == 0:
8065 
        if ftype == TType.LIST:
8066 
          self.success = []
7438 amit.gupta 8067 
          (_etype91, _size88) = iprot.readListBegin()
8068 
          for _i92 in xrange(_size88):
8069 
            _elem93 = Item()
8070 
            _elem93.read(iprot)
8071 
            self.success.append(_elem93)
5944 mandeep.dh 8072 
          iprot.readListEnd()
8073 
        else:
8074 
          iprot.skip(ftype)
8075 
      elif fid == 1:
8076 
        if ftype == TType.STRUCT:
8077 
          self.isex = CatalogServiceException()
8078 
          self.isex.read(iprot)
8079 
        else:
8080 
          iprot.skip(ftype)
8081 
      else:
8082 
        iprot.skip(ftype)
8083 
      iprot.readFieldEnd()
8084 
    iprot.readStructEnd()
8085 
 
8086 
  def write(self, oprot):
8087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8089 
      return
8090 
    oprot.writeStructBegin('getBestDeals_result')
8091 
    if self.success is not None:
8092 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8093 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8094 
      for iter94 in self.success:
8095 
        iter94.write(oprot)
5944 mandeep.dh 8096 
      oprot.writeListEnd()
8097 
      oprot.writeFieldEnd()
8098 
    if self.isex is not None:
8099 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8100 
      self.isex.write(oprot)
8101 
      oprot.writeFieldEnd()
8102 
    oprot.writeFieldStop()
8103 
    oprot.writeStructEnd()
8104 
 
8105 
  def validate(self):
8106 
    return
8107 
 
8108 
 
8109 
  def __repr__(self):
8110 
    L = ['%s=%r' % (key, value)
8111 
      for key, value in self.__dict__.iteritems()]
8112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8113 
 
8114 
  def __eq__(self, other):
8115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8116 
 
8117 
  def __ne__(self, other):
8118 
    return not (self == other)
8119 
 
8120 
class getBestDealsCatalogIds_args:
8121 
  """
8122 
  Attributes:
8123 
   - beginIndex
8124 
   - totalItems
8125 
   - brand
8126 
   - category
8127 
  """
8128 
 
8129 
  thrift_spec = (
8130 
    None, # 0
8131 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8132 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8133 
    (3, TType.STRING, 'brand', None, None, ), # 3
8134 
    (4, TType.I64, 'category', None, None, ), # 4
8135 
  )
8136 
 
8137 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8138 
    self.beginIndex = beginIndex
8139 
    self.totalItems = totalItems
8140 
    self.brand = brand
8141 
    self.category = category
8142 
 
8143 
  def read(self, iprot):
8144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8146 
      return
8147 
    iprot.readStructBegin()
8148 
    while True:
8149 
      (fname, ftype, fid) = iprot.readFieldBegin()
8150 
      if ftype == TType.STOP:
8151 
        break
8152 
      if fid == 1:
8153 
        if ftype == TType.I64:
8154 
          self.beginIndex = iprot.readI64();
8155 
        else:
8156 
          iprot.skip(ftype)
8157 
      elif fid == 2:
8158 
        if ftype == TType.I64:
8159 
          self.totalItems = iprot.readI64();
8160 
        else:
8161 
          iprot.skip(ftype)
8162 
      elif fid == 3:
8163 
        if ftype == TType.STRING:
8164 
          self.brand = iprot.readString();
8165 
        else:
8166 
          iprot.skip(ftype)
8167 
      elif fid == 4:
8168 
        if ftype == TType.I64:
8169 
          self.category = iprot.readI64();
8170 
        else:
8171 
          iprot.skip(ftype)
8172 
      else:
8173 
        iprot.skip(ftype)
8174 
      iprot.readFieldEnd()
8175 
    iprot.readStructEnd()
8176 
 
8177 
  def write(self, oprot):
8178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8180 
      return
8181 
    oprot.writeStructBegin('getBestDealsCatalogIds_args')
8182 
    if self.beginIndex is not None:
8183 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8184 
      oprot.writeI64(self.beginIndex)
8185 
      oprot.writeFieldEnd()
8186 
    if self.totalItems is not None:
8187 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8188 
      oprot.writeI64(self.totalItems)
8189 
      oprot.writeFieldEnd()
8190 
    if self.brand is not None:
8191 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8192 
      oprot.writeString(self.brand)
8193 
      oprot.writeFieldEnd()
8194 
    if self.category is not None:
8195 
      oprot.writeFieldBegin('category', TType.I64, 4)
8196 
      oprot.writeI64(self.category)
8197 
      oprot.writeFieldEnd()
8198 
    oprot.writeFieldStop()
8199 
    oprot.writeStructEnd()
8200 
 
8201 
  def validate(self):
8202 
    return
8203 
 
8204 
 
8205 
  def __repr__(self):
8206 
    L = ['%s=%r' % (key, value)
8207 
      for key, value in self.__dict__.iteritems()]
8208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8209 
 
8210 
  def __eq__(self, other):
8211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8212 
 
8213 
  def __ne__(self, other):
8214 
    return not (self == other)
8215 
 
8216 
class getBestDealsCatalogIds_result:
8217 
  """
8218 
  Attributes:
8219 
   - success
8220 
   - cex
8221 
  """
8222 
 
8223 
  thrift_spec = (
8224 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8225 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8226 
  )
8227 
 
8228 
  def __init__(self, success=None, cex=None,):
8229 
    self.success = success
8230 
    self.cex = cex
8231 
 
8232 
  def read(self, iprot):
8233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8235 
      return
8236 
    iprot.readStructBegin()
8237 
    while True:
8238 
      (fname, ftype, fid) = iprot.readFieldBegin()
8239 
      if ftype == TType.STOP:
8240 
        break
8241 
      if fid == 0:
8242 
        if ftype == TType.LIST:
8243 
          self.success = []
7438 amit.gupta 8244 
          (_etype98, _size95) = iprot.readListBegin()
8245 
          for _i99 in xrange(_size95):
8246 
            _elem100 = iprot.readI64();
8247 
            self.success.append(_elem100)
5944 mandeep.dh 8248 
          iprot.readListEnd()
8249 
        else:
8250 
          iprot.skip(ftype)
8251 
      elif fid == 1:
8252 
        if ftype == TType.STRUCT:
8253 
          self.cex = CatalogServiceException()
8254 
          self.cex.read(iprot)
8255 
        else:
8256 
          iprot.skip(ftype)
8257 
      else:
8258 
        iprot.skip(ftype)
8259 
      iprot.readFieldEnd()
8260 
    iprot.readStructEnd()
8261 
 
8262 
  def write(self, oprot):
8263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8265 
      return
8266 
    oprot.writeStructBegin('getBestDealsCatalogIds_result')
8267 
    if self.success is not None:
8268 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8269 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8270 
      for iter101 in self.success:
8271 
        oprot.writeI64(iter101)
5944 mandeep.dh 8272 
      oprot.writeListEnd()
8273 
      oprot.writeFieldEnd()
8274 
    if self.cex is not None:
8275 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8276 
      self.cex.write(oprot)
8277 
      oprot.writeFieldEnd()
8278 
    oprot.writeFieldStop()
8279 
    oprot.writeStructEnd()
8280 
 
8281 
  def validate(self):
8282 
    return
8283 
 
8284 
 
8285 
  def __repr__(self):
8286 
    L = ['%s=%r' % (key, value)
8287 
      for key, value in self.__dict__.iteritems()]
8288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8289 
 
8290 
  def __eq__(self, other):
8291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8292 
 
8293 
  def __ne__(self, other):
8294 
    return not (self == other)
8295 
 
8296 
class getBestDealsCount_args:
8297 
 
8298 
  thrift_spec = (
8299 
  )
8300 
 
8301 
  def read(self, iprot):
8302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8304 
      return
8305 
    iprot.readStructBegin()
8306 
    while True:
8307 
      (fname, ftype, fid) = iprot.readFieldBegin()
8308 
      if ftype == TType.STOP:
8309 
        break
8310 
      else:
8311 
        iprot.skip(ftype)
8312 
      iprot.readFieldEnd()
8313 
    iprot.readStructEnd()
8314 
 
8315 
  def write(self, oprot):
8316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8318 
      return
8319 
    oprot.writeStructBegin('getBestDealsCount_args')
8320 
    oprot.writeFieldStop()
8321 
    oprot.writeStructEnd()
8322 
 
8323 
  def validate(self):
8324 
    return
8325 
 
8326 
 
8327 
  def __repr__(self):
8328 
    L = ['%s=%r' % (key, value)
8329 
      for key, value in self.__dict__.iteritems()]
8330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8331 
 
8332 
  def __eq__(self, other):
8333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8334 
 
8335 
  def __ne__(self, other):
8336 
    return not (self == other)
8337 
 
8338 
class getBestDealsCount_result:
8339 
  """
8340 
  Attributes:
8341 
   - success
8342 
   - cex
8343 
  """
8344 
 
8345 
  thrift_spec = (
8346 
    (0, TType.I64, 'success', None, None, ), # 0
8347 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8348 
  )
8349 
 
8350 
  def __init__(self, success=None, cex=None,):
8351 
    self.success = success
8352 
    self.cex = cex
8353 
 
8354 
  def read(self, iprot):
8355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8357 
      return
8358 
    iprot.readStructBegin()
8359 
    while True:
8360 
      (fname, ftype, fid) = iprot.readFieldBegin()
8361 
      if ftype == TType.STOP:
8362 
        break
8363 
      if fid == 0:
8364 
        if ftype == TType.I64:
8365 
          self.success = iprot.readI64();
8366 
        else:
8367 
          iprot.skip(ftype)
8368 
      elif fid == 1:
8369 
        if ftype == TType.STRUCT:
8370 
          self.cex = CatalogServiceException()
8371 
          self.cex.read(iprot)
8372 
        else:
8373 
          iprot.skip(ftype)
8374 
      else:
8375 
        iprot.skip(ftype)
8376 
      iprot.readFieldEnd()
8377 
    iprot.readStructEnd()
8378 
 
8379 
  def write(self, oprot):
8380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8382 
      return
8383 
    oprot.writeStructBegin('getBestDealsCount_result')
8384 
    if self.success is not None:
8385 
      oprot.writeFieldBegin('success', TType.I64, 0)
8386 
      oprot.writeI64(self.success)
8387 
      oprot.writeFieldEnd()
8388 
    if self.cex is not None:
8389 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8390 
      self.cex.write(oprot)
8391 
      oprot.writeFieldEnd()
8392 
    oprot.writeFieldStop()
8393 
    oprot.writeStructEnd()
8394 
 
8395 
  def validate(self):
8396 
    return
8397 
 
8398 
 
8399 
  def __repr__(self):
8400 
    L = ['%s=%r' % (key, value)
8401 
      for key, value in self.__dict__.iteritems()]
8402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8403 
 
8404 
  def __eq__(self, other):
8405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8406 
 
8407 
  def __ne__(self, other):
8408 
    return not (self == other)
8409 
 
8410 
class getComingSoon_args:
8411 
 
8412 
  thrift_spec = (
8413 
  )
8414 
 
8415 
  def read(self, iprot):
8416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8418 
      return
8419 
    iprot.readStructBegin()
8420 
    while True:
8421 
      (fname, ftype, fid) = iprot.readFieldBegin()
8422 
      if ftype == TType.STOP:
8423 
        break
8424 
      else:
8425 
        iprot.skip(ftype)
8426 
      iprot.readFieldEnd()
8427 
    iprot.readStructEnd()
8428 
 
8429 
  def write(self, oprot):
8430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8432 
      return
8433 
    oprot.writeStructBegin('getComingSoon_args')
8434 
    oprot.writeFieldStop()
8435 
    oprot.writeStructEnd()
8436 
 
8437 
  def validate(self):
8438 
    return
8439 
 
8440 
 
8441 
  def __repr__(self):
8442 
    L = ['%s=%r' % (key, value)
8443 
      for key, value in self.__dict__.iteritems()]
8444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8445 
 
8446 
  def __eq__(self, other):
8447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8448 
 
8449 
  def __ne__(self, other):
8450 
    return not (self == other)
8451 
 
8452 
class getComingSoon_result:
8453 
  """
8454 
  Attributes:
8455 
   - success
8456 
   - isex
8457 
  """
8458 
 
8459 
  thrift_spec = (
8460 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8461 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8462 
  )
8463 
 
8464 
  def __init__(self, success=None, isex=None,):
8465 
    self.success = success
8466 
    self.isex = isex
8467 
 
8468 
  def read(self, iprot):
8469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8471 
      return
8472 
    iprot.readStructBegin()
8473 
    while True:
8474 
      (fname, ftype, fid) = iprot.readFieldBegin()
8475 
      if ftype == TType.STOP:
8476 
        break
8477 
      if fid == 0:
8478 
        if ftype == TType.LIST:
8479 
          self.success = []
7438 amit.gupta 8480 
          (_etype105, _size102) = iprot.readListBegin()
8481 
          for _i106 in xrange(_size102):
8482 
            _elem107 = Item()
8483 
            _elem107.read(iprot)
8484 
            self.success.append(_elem107)
5944 mandeep.dh 8485 
          iprot.readListEnd()
8486 
        else:
8487 
          iprot.skip(ftype)
8488 
      elif fid == 1:
8489 
        if ftype == TType.STRUCT:
8490 
          self.isex = CatalogServiceException()
8491 
          self.isex.read(iprot)
8492 
        else:
8493 
          iprot.skip(ftype)
8494 
      else:
8495 
        iprot.skip(ftype)
8496 
      iprot.readFieldEnd()
8497 
    iprot.readStructEnd()
8498 
 
8499 
  def write(self, oprot):
8500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8502 
      return
8503 
    oprot.writeStructBegin('getComingSoon_result')
8504 
    if self.success is not None:
8505 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8506 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8507 
      for iter108 in self.success:
8508 
        iter108.write(oprot)
5944 mandeep.dh 8509 
      oprot.writeListEnd()
8510 
      oprot.writeFieldEnd()
8511 
    if self.isex is not None:
8512 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8513 
      self.isex.write(oprot)
8514 
      oprot.writeFieldEnd()
8515 
    oprot.writeFieldStop()
8516 
    oprot.writeStructEnd()
8517 
 
8518 
  def validate(self):
8519 
    return
8520 
 
8521 
 
8522 
  def __repr__(self):
8523 
    L = ['%s=%r' % (key, value)
8524 
      for key, value in self.__dict__.iteritems()]
8525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8526 
 
8527 
  def __eq__(self, other):
8528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8529 
 
8530 
  def __ne__(self, other):
8531 
    return not (self == other)
8532 
 
8533 
class getComingSoonCatalogIds_args:
8534 
  """
8535 
  Attributes:
8536 
   - beginIndex
8537 
   - totalItems
8538 
   - brand
8539 
   - category
8540 
  """
8541 
 
8542 
  thrift_spec = (
8543 
    None, # 0
8544 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8545 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8546 
    (3, TType.STRING, 'brand', None, None, ), # 3
8547 
    (4, TType.I64, 'category', None, None, ), # 4
8548 
  )
8549 
 
8550 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, category=None,):
8551 
    self.beginIndex = beginIndex
8552 
    self.totalItems = totalItems
8553 
    self.brand = brand
8554 
    self.category = category
8555 
 
8556 
  def read(self, iprot):
8557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8559 
      return
8560 
    iprot.readStructBegin()
8561 
    while True:
8562 
      (fname, ftype, fid) = iprot.readFieldBegin()
8563 
      if ftype == TType.STOP:
8564 
        break
8565 
      if fid == 1:
8566 
        if ftype == TType.I64:
8567 
          self.beginIndex = iprot.readI64();
8568 
        else:
8569 
          iprot.skip(ftype)
8570 
      elif fid == 2:
8571 
        if ftype == TType.I64:
8572 
          self.totalItems = iprot.readI64();
8573 
        else:
8574 
          iprot.skip(ftype)
8575 
      elif fid == 3:
8576 
        if ftype == TType.STRING:
8577 
          self.brand = iprot.readString();
8578 
        else:
8579 
          iprot.skip(ftype)
8580 
      elif fid == 4:
8581 
        if ftype == TType.I64:
8582 
          self.category = iprot.readI64();
8583 
        else:
8584 
          iprot.skip(ftype)
8585 
      else:
8586 
        iprot.skip(ftype)
8587 
      iprot.readFieldEnd()
8588 
    iprot.readStructEnd()
8589 
 
8590 
  def write(self, oprot):
8591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8593 
      return
8594 
    oprot.writeStructBegin('getComingSoonCatalogIds_args')
8595 
    if self.beginIndex is not None:
8596 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
8597 
      oprot.writeI64(self.beginIndex)
8598 
      oprot.writeFieldEnd()
8599 
    if self.totalItems is not None:
8600 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
8601 
      oprot.writeI64(self.totalItems)
8602 
      oprot.writeFieldEnd()
8603 
    if self.brand is not None:
8604 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
8605 
      oprot.writeString(self.brand)
8606 
      oprot.writeFieldEnd()
8607 
    if self.category is not None:
8608 
      oprot.writeFieldBegin('category', TType.I64, 4)
8609 
      oprot.writeI64(self.category)
8610 
      oprot.writeFieldEnd()
8611 
    oprot.writeFieldStop()
8612 
    oprot.writeStructEnd()
8613 
 
8614 
  def validate(self):
8615 
    return
8616 
 
8617 
 
8618 
  def __repr__(self):
8619 
    L = ['%s=%r' % (key, value)
8620 
      for key, value in self.__dict__.iteritems()]
8621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8622 
 
8623 
  def __eq__(self, other):
8624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8625 
 
8626 
  def __ne__(self, other):
8627 
    return not (self == other)
8628 
 
8629 
class getComingSoonCatalogIds_result:
8630 
  """
8631 
  Attributes:
8632 
   - success
8633 
   - cex
8634 
  """
8635 
 
8636 
  thrift_spec = (
8637 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8638 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8639 
  )
8640 
 
8641 
  def __init__(self, success=None, cex=None,):
8642 
    self.success = success
8643 
    self.cex = cex
8644 
 
8645 
  def read(self, iprot):
8646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8648 
      return
8649 
    iprot.readStructBegin()
8650 
    while True:
8651 
      (fname, ftype, fid) = iprot.readFieldBegin()
8652 
      if ftype == TType.STOP:
8653 
        break
8654 
      if fid == 0:
8655 
        if ftype == TType.LIST:
8656 
          self.success = []
7438 amit.gupta 8657 
          (_etype112, _size109) = iprot.readListBegin()
8658 
          for _i113 in xrange(_size109):
8659 
            _elem114 = iprot.readI64();
8660 
            self.success.append(_elem114)
5944 mandeep.dh 8661 
          iprot.readListEnd()
8662 
        else:
8663 
          iprot.skip(ftype)
8664 
      elif fid == 1:
8665 
        if ftype == TType.STRUCT:
8666 
          self.cex = CatalogServiceException()
8667 
          self.cex.read(iprot)
8668 
        else:
8669 
          iprot.skip(ftype)
8670 
      else:
8671 
        iprot.skip(ftype)
8672 
      iprot.readFieldEnd()
8673 
    iprot.readStructEnd()
8674 
 
8675 
  def write(self, oprot):
8676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8678 
      return
8679 
    oprot.writeStructBegin('getComingSoonCatalogIds_result')
8680 
    if self.success is not None:
8681 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8682 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 8683 
      for iter115 in self.success:
8684 
        oprot.writeI64(iter115)
5944 mandeep.dh 8685 
      oprot.writeListEnd()
8686 
      oprot.writeFieldEnd()
8687 
    if self.cex is not None:
8688 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8689 
      self.cex.write(oprot)
8690 
      oprot.writeFieldEnd()
8691 
    oprot.writeFieldStop()
8692 
    oprot.writeStructEnd()
8693 
 
8694 
  def validate(self):
8695 
    return
8696 
 
8697 
 
8698 
  def __repr__(self):
8699 
    L = ['%s=%r' % (key, value)
8700 
      for key, value in self.__dict__.iteritems()]
8701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8702 
 
8703 
  def __eq__(self, other):
8704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8705 
 
8706 
  def __ne__(self, other):
8707 
    return not (self == other)
8708 
 
8709 
class getComingSoonCount_args:
8710 
 
8711 
  thrift_spec = (
8712 
  )
8713 
 
8714 
  def read(self, iprot):
8715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8717 
      return
8718 
    iprot.readStructBegin()
8719 
    while True:
8720 
      (fname, ftype, fid) = iprot.readFieldBegin()
8721 
      if ftype == TType.STOP:
8722 
        break
8723 
      else:
8724 
        iprot.skip(ftype)
8725 
      iprot.readFieldEnd()
8726 
    iprot.readStructEnd()
8727 
 
8728 
  def write(self, oprot):
8729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8731 
      return
8732 
    oprot.writeStructBegin('getComingSoonCount_args')
8733 
    oprot.writeFieldStop()
8734 
    oprot.writeStructEnd()
8735 
 
8736 
  def validate(self):
8737 
    return
8738 
 
8739 
 
8740 
  def __repr__(self):
8741 
    L = ['%s=%r' % (key, value)
8742 
      for key, value in self.__dict__.iteritems()]
8743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8744 
 
8745 
  def __eq__(self, other):
8746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8747 
 
8748 
  def __ne__(self, other):
8749 
    return not (self == other)
8750 
 
8751 
class getComingSoonCount_result:
8752 
  """
8753 
  Attributes:
8754 
   - success
8755 
   - cex
8756 
  """
8757 
 
8758 
  thrift_spec = (
8759 
    (0, TType.I64, 'success', None, None, ), # 0
8760 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8761 
  )
8762 
 
8763 
  def __init__(self, success=None, cex=None,):
8764 
    self.success = success
8765 
    self.cex = cex
8766 
 
8767 
  def read(self, iprot):
8768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8770 
      return
8771 
    iprot.readStructBegin()
8772 
    while True:
8773 
      (fname, ftype, fid) = iprot.readFieldBegin()
8774 
      if ftype == TType.STOP:
8775 
        break
8776 
      if fid == 0:
8777 
        if ftype == TType.I64:
8778 
          self.success = iprot.readI64();
8779 
        else:
8780 
          iprot.skip(ftype)
8781 
      elif fid == 1:
8782 
        if ftype == TType.STRUCT:
8783 
          self.cex = CatalogServiceException()
8784 
          self.cex.read(iprot)
8785 
        else:
8786 
          iprot.skip(ftype)
8787 
      else:
8788 
        iprot.skip(ftype)
8789 
      iprot.readFieldEnd()
8790 
    iprot.readStructEnd()
8791 
 
8792 
  def write(self, oprot):
8793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8795 
      return
8796 
    oprot.writeStructBegin('getComingSoonCount_result')
8797 
    if self.success is not None:
8798 
      oprot.writeFieldBegin('success', TType.I64, 0)
8799 
      oprot.writeI64(self.success)
8800 
      oprot.writeFieldEnd()
8801 
    if self.cex is not None:
8802 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
8803 
      self.cex.write(oprot)
8804 
      oprot.writeFieldEnd()
8805 
    oprot.writeFieldStop()
8806 
    oprot.writeStructEnd()
8807 
 
8808 
  def validate(self):
8809 
    return
8810 
 
8811 
 
8812 
  def __repr__(self):
8813 
    L = ['%s=%r' % (key, value)
8814 
      for key, value in self.__dict__.iteritems()]
8815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8816 
 
8817 
  def __eq__(self, other):
8818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8819 
 
8820 
  def __ne__(self, other):
8821 
    return not (self == other)
8822 
 
8823 
class getLatestArrivals_args:
8824 
 
8825 
  thrift_spec = (
8826 
  )
8827 
 
8828 
  def read(self, iprot):
8829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8831 
      return
8832 
    iprot.readStructBegin()
8833 
    while True:
8834 
      (fname, ftype, fid) = iprot.readFieldBegin()
8835 
      if ftype == TType.STOP:
8836 
        break
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('getLatestArrivals_args')
8847 
    oprot.writeFieldStop()
8848 
    oprot.writeStructEnd()
8849 
 
8850 
  def validate(self):
8851 
    return
8852 
 
8853 
 
8854 
  def __repr__(self):
8855 
    L = ['%s=%r' % (key, value)
8856 
      for key, value in self.__dict__.iteritems()]
8857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8858 
 
8859 
  def __eq__(self, other):
8860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8861 
 
8862 
  def __ne__(self, other):
8863 
    return not (self == other)
8864 
 
8865 
class getLatestArrivals_result:
8866 
  """
8867 
  Attributes:
8868 
   - success
8869 
   - isex
8870 
  """
8871 
 
8872 
  thrift_spec = (
8873 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
8874 
    (1, TType.STRUCT, 'isex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
8875 
  )
8876 
 
8877 
  def __init__(self, success=None, isex=None,):
8878 
    self.success = success
8879 
    self.isex = isex
8880 
 
8881 
  def read(self, iprot):
8882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8884 
      return
8885 
    iprot.readStructBegin()
8886 
    while True:
8887 
      (fname, ftype, fid) = iprot.readFieldBegin()
8888 
      if ftype == TType.STOP:
8889 
        break
8890 
      if fid == 0:
8891 
        if ftype == TType.LIST:
8892 
          self.success = []
7438 amit.gupta 8893 
          (_etype119, _size116) = iprot.readListBegin()
8894 
          for _i120 in xrange(_size116):
8895 
            _elem121 = Item()
8896 
            _elem121.read(iprot)
8897 
            self.success.append(_elem121)
5944 mandeep.dh 8898 
          iprot.readListEnd()
8899 
        else:
8900 
          iprot.skip(ftype)
8901 
      elif fid == 1:
8902 
        if ftype == TType.STRUCT:
8903 
          self.isex = CatalogServiceException()
8904 
          self.isex.read(iprot)
8905 
        else:
8906 
          iprot.skip(ftype)
8907 
      else:
8908 
        iprot.skip(ftype)
8909 
      iprot.readFieldEnd()
8910 
    iprot.readStructEnd()
8911 
 
8912 
  def write(self, oprot):
8913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8915 
      return
8916 
    oprot.writeStructBegin('getLatestArrivals_result')
8917 
    if self.success is not None:
8918 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8919 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 8920 
      for iter122 in self.success:
8921 
        iter122.write(oprot)
5944 mandeep.dh 8922 
      oprot.writeListEnd()
8923 
      oprot.writeFieldEnd()
8924 
    if self.isex is not None:
8925 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
8926 
      self.isex.write(oprot)
8927 
      oprot.writeFieldEnd()
8928 
    oprot.writeFieldStop()
8929 
    oprot.writeStructEnd()
8930 
 
8931 
  def validate(self):
8932 
    return
8933 
 
8934 
 
8935 
  def __repr__(self):
8936 
    L = ['%s=%r' % (key, value)
8937 
      for key, value in self.__dict__.iteritems()]
8938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8939 
 
8940 
  def __eq__(self, other):
8941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8942 
 
8943 
  def __ne__(self, other):
8944 
    return not (self == other)
8945 
 
8946 
class getLatestArrivalsCatalogIds_args:
8947 
  """
8948 
  Attributes:
8949 
   - beginIndex
8950 
   - totalItems
8951 
   - brand
8952 
   - categories
8953 
  """
8954 
 
8955 
  thrift_spec = (
8956 
    None, # 0
8957 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
8958 
    (2, TType.I64, 'totalItems', None, None, ), # 2
8959 
    (3, TType.STRING, 'brand', None, None, ), # 3
8960 
    (4, TType.LIST, 'categories', (TType.I64,None), None, ), # 4
8961 
  )
8962 
 
8963 
  def __init__(self, beginIndex=None, totalItems=None, brand=None, categories=None,):
8964 
    self.beginIndex = beginIndex
8965 
    self.totalItems = totalItems
8966 
    self.brand = brand
8967 
    self.categories = categories
8968 
 
8969 
  def read(self, iprot):
8970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8972 
      return
8973 
    iprot.readStructBegin()
8974 
    while True:
8975 
      (fname, ftype, fid) = iprot.readFieldBegin()
8976 
      if ftype == TType.STOP:
8977 
        break
8978 
      if fid == 1:
8979 
        if ftype == TType.I64:
8980 
          self.beginIndex = iprot.readI64();
8981 
        else:
8982 
          iprot.skip(ftype)
8983 
      elif fid == 2:
8984 
        if ftype == TType.I64:
8985 
          self.totalItems = iprot.readI64();
8986 
        else:
8987 
          iprot.skip(ftype)
8988 
      elif fid == 3:
8989 
        if ftype == TType.STRING:
8990 
          self.brand = iprot.readString();
8991 
        else:
8992 
          iprot.skip(ftype)
8993 
      elif fid == 4:
8994 
        if ftype == TType.LIST:
8995 
          self.categories = []
7438 amit.gupta 8996 
          (_etype126, _size123) = iprot.readListBegin()
8997 
          for _i127 in xrange(_size123):
8998 
            _elem128 = iprot.readI64();
8999 
            self.categories.append(_elem128)
5944 mandeep.dh 9000 
          iprot.readListEnd()
9001 
        else:
9002 
          iprot.skip(ftype)
9003 
      else:
9004 
        iprot.skip(ftype)
9005 
      iprot.readFieldEnd()
9006 
    iprot.readStructEnd()
9007 
 
9008 
  def write(self, oprot):
9009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9011 
      return
9012 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_args')
9013 
    if self.beginIndex is not None:
9014 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
9015 
      oprot.writeI64(self.beginIndex)
9016 
      oprot.writeFieldEnd()
9017 
    if self.totalItems is not None:
9018 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
9019 
      oprot.writeI64(self.totalItems)
9020 
      oprot.writeFieldEnd()
9021 
    if self.brand is not None:
9022 
      oprot.writeFieldBegin('brand', TType.STRING, 3)
9023 
      oprot.writeString(self.brand)
9024 
      oprot.writeFieldEnd()
9025 
    if self.categories is not None:
9026 
      oprot.writeFieldBegin('categories', TType.LIST, 4)
9027 
      oprot.writeListBegin(TType.I64, len(self.categories))
7438 amit.gupta 9028 
      for iter129 in self.categories:
9029 
        oprot.writeI64(iter129)
5944 mandeep.dh 9030 
      oprot.writeListEnd()
9031 
      oprot.writeFieldEnd()
9032 
    oprot.writeFieldStop()
9033 
    oprot.writeStructEnd()
9034 
 
9035 
  def validate(self):
9036 
    return
9037 
 
9038 
 
9039 
  def __repr__(self):
9040 
    L = ['%s=%r' % (key, value)
9041 
      for key, value in self.__dict__.iteritems()]
9042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9043 
 
9044 
  def __eq__(self, other):
9045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9046 
 
9047 
  def __ne__(self, other):
9048 
    return not (self == other)
9049 
 
9050 
class getLatestArrivalsCatalogIds_result:
9051 
  """
9052 
  Attributes:
9053 
   - success
9054 
   - cex
9055 
  """
9056 
 
9057 
  thrift_spec = (
9058 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9059 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9060 
  )
9061 
 
9062 
  def __init__(self, success=None, cex=None,):
9063 
    self.success = success
9064 
    self.cex = cex
9065 
 
9066 
  def read(self, iprot):
9067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9069 
      return
9070 
    iprot.readStructBegin()
9071 
    while True:
9072 
      (fname, ftype, fid) = iprot.readFieldBegin()
9073 
      if ftype == TType.STOP:
9074 
        break
9075 
      if fid == 0:
9076 
        if ftype == TType.LIST:
9077 
          self.success = []
7438 amit.gupta 9078 
          (_etype133, _size130) = iprot.readListBegin()
9079 
          for _i134 in xrange(_size130):
9080 
            _elem135 = iprot.readI64();
9081 
            self.success.append(_elem135)
5944 mandeep.dh 9082 
          iprot.readListEnd()
9083 
        else:
9084 
          iprot.skip(ftype)
9085 
      elif fid == 1:
9086 
        if ftype == TType.STRUCT:
9087 
          self.cex = CatalogServiceException()
9088 
          self.cex.read(iprot)
9089 
        else:
9090 
          iprot.skip(ftype)
9091 
      else:
9092 
        iprot.skip(ftype)
9093 
      iprot.readFieldEnd()
9094 
    iprot.readStructEnd()
9095 
 
9096 
  def write(self, oprot):
9097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9099 
      return
9100 
    oprot.writeStructBegin('getLatestArrivalsCatalogIds_result')
9101 
    if self.success is not None:
9102 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9103 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 9104 
      for iter136 in self.success:
9105 
        oprot.writeI64(iter136)
5944 mandeep.dh 9106 
      oprot.writeListEnd()
9107 
      oprot.writeFieldEnd()
9108 
    if self.cex is not None:
9109 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9110 
      self.cex.write(oprot)
9111 
      oprot.writeFieldEnd()
9112 
    oprot.writeFieldStop()
9113 
    oprot.writeStructEnd()
9114 
 
9115 
  def validate(self):
9116 
    return
9117 
 
9118 
 
9119 
  def __repr__(self):
9120 
    L = ['%s=%r' % (key, value)
9121 
      for key, value in self.__dict__.iteritems()]
9122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9123 
 
9124 
  def __eq__(self, other):
9125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9126 
 
9127 
  def __ne__(self, other):
9128 
    return not (self == other)
9129 
 
9130 
class getLatestArrivalsCount_args:
9131 
 
9132 
  thrift_spec = (
9133 
  )
9134 
 
9135 
  def read(self, iprot):
9136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9138 
      return
9139 
    iprot.readStructBegin()
9140 
    while True:
9141 
      (fname, ftype, fid) = iprot.readFieldBegin()
9142 
      if ftype == TType.STOP:
9143 
        break
9144 
      else:
9145 
        iprot.skip(ftype)
9146 
      iprot.readFieldEnd()
9147 
    iprot.readStructEnd()
9148 
 
9149 
  def write(self, oprot):
9150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9152 
      return
9153 
    oprot.writeStructBegin('getLatestArrivalsCount_args')
9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
9172 
class getLatestArrivalsCount_result:
9173 
  """
9174 
  Attributes:
9175 
   - success
9176 
   - cex
9177 
  """
9178 
 
9179 
  thrift_spec = (
9180 
    (0, TType.I64, 'success', None, None, ), # 0
9181 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9182 
  )
9183 
 
9184 
  def __init__(self, success=None, cex=None,):
9185 
    self.success = success
9186 
    self.cex = cex
9187 
 
9188 
  def read(self, iprot):
9189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9191 
      return
9192 
    iprot.readStructBegin()
9193 
    while True:
9194 
      (fname, ftype, fid) = iprot.readFieldBegin()
9195 
      if ftype == TType.STOP:
9196 
        break
9197 
      if fid == 0:
9198 
        if ftype == TType.I64:
9199 
          self.success = iprot.readI64();
9200 
        else:
9201 
          iprot.skip(ftype)
9202 
      elif fid == 1:
9203 
        if ftype == TType.STRUCT:
9204 
          self.cex = CatalogServiceException()
9205 
          self.cex.read(iprot)
9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      else:
9209 
        iprot.skip(ftype)
9210 
      iprot.readFieldEnd()
9211 
    iprot.readStructEnd()
9212 
 
9213 
  def write(self, oprot):
9214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9216 
      return
9217 
    oprot.writeStructBegin('getLatestArrivalsCount_result')
9218 
    if self.success is not None:
9219 
      oprot.writeFieldBegin('success', TType.I64, 0)
9220 
      oprot.writeI64(self.success)
9221 
      oprot.writeFieldEnd()
9222 
    if self.cex is not None:
9223 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9224 
      self.cex.write(oprot)
9225 
      oprot.writeFieldEnd()
9226 
    oprot.writeFieldStop()
9227 
    oprot.writeStructEnd()
9228 
 
9229 
  def validate(self):
9230 
    return
9231 
 
9232 
 
9233 
  def __repr__(self):
9234 
    L = ['%s=%r' % (key, value)
9235 
      for key, value in self.__dict__.iteritems()]
9236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9237 
 
9238 
  def __eq__(self, other):
9239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9240 
 
9241 
  def __ne__(self, other):
9242 
    return not (self == other)
9243 
 
9244 
class generateNewEntityID_args:
9245 
 
9246 
  thrift_spec = (
9247 
  )
9248 
 
9249 
  def read(self, iprot):
9250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9252 
      return
9253 
    iprot.readStructBegin()
9254 
    while True:
9255 
      (fname, ftype, fid) = iprot.readFieldBegin()
9256 
      if ftype == TType.STOP:
9257 
        break
9258 
      else:
9259 
        iprot.skip(ftype)
9260 
      iprot.readFieldEnd()
9261 
    iprot.readStructEnd()
9262 
 
9263 
  def write(self, oprot):
9264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9266 
      return
9267 
    oprot.writeStructBegin('generateNewEntityID_args')
9268 
    oprot.writeFieldStop()
9269 
    oprot.writeStructEnd()
9270 
 
9271 
  def validate(self):
9272 
    return
9273 
 
9274 
 
9275 
  def __repr__(self):
9276 
    L = ['%s=%r' % (key, value)
9277 
      for key, value in self.__dict__.iteritems()]
9278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9279 
 
9280 
  def __eq__(self, other):
9281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9282 
 
9283 
  def __ne__(self, other):
9284 
    return not (self == other)
9285 
 
9286 
class generateNewEntityID_result:
9287 
  """
9288 
  Attributes:
9289 
   - success
9290 
  """
9291 
 
9292 
  thrift_spec = (
9293 
    (0, TType.I64, 'success', None, None, ), # 0
9294 
  )
9295 
 
9296 
  def __init__(self, success=None,):
9297 
    self.success = success
9298 
 
9299 
  def read(self, iprot):
9300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9302 
      return
9303 
    iprot.readStructBegin()
9304 
    while True:
9305 
      (fname, ftype, fid) = iprot.readFieldBegin()
9306 
      if ftype == TType.STOP:
9307 
        break
9308 
      if fid == 0:
9309 
        if ftype == TType.I64:
9310 
          self.success = iprot.readI64();
9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      else:
9314 
        iprot.skip(ftype)
9315 
      iprot.readFieldEnd()
9316 
    iprot.readStructEnd()
9317 
 
9318 
  def write(self, oprot):
9319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9321 
      return
9322 
    oprot.writeStructBegin('generateNewEntityID_result')
9323 
    if self.success is not None:
9324 
      oprot.writeFieldBegin('success', TType.I64, 0)
9325 
      oprot.writeI64(self.success)
9326 
      oprot.writeFieldEnd()
9327 
    oprot.writeFieldStop()
9328 
    oprot.writeStructEnd()
9329 
 
9330 
  def validate(self):
9331 
    return
9332 
 
9333 
 
9334 
  def __repr__(self):
9335 
    L = ['%s=%r' % (key, value)
9336 
      for key, value in self.__dict__.iteritems()]
9337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9338 
 
9339 
  def __eq__(self, other):
9340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9341 
 
9342 
  def __ne__(self, other):
9343 
    return not (self == other)
9344 
 
9345 
class addCategory_args:
9346 
  """
9347 
  Attributes:
9348 
   - category
9349 
  """
9350 
 
9351 
  thrift_spec = (
9352 
    None, # 0
9353 
    (1, TType.STRUCT, 'category', (Category, Category.thrift_spec), None, ), # 1
9354 
  )
9355 
 
9356 
  def __init__(self, category=None,):
9357 
    self.category = category
9358 
 
9359 
  def read(self, iprot):
9360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9362 
      return
9363 
    iprot.readStructBegin()
9364 
    while True:
9365 
      (fname, ftype, fid) = iprot.readFieldBegin()
9366 
      if ftype == TType.STOP:
9367 
        break
9368 
      if fid == 1:
9369 
        if ftype == TType.STRUCT:
9370 
          self.category = Category()
9371 
          self.category.read(iprot)
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      else:
9375 
        iprot.skip(ftype)
9376 
      iprot.readFieldEnd()
9377 
    iprot.readStructEnd()
9378 
 
9379 
  def write(self, oprot):
9380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9382 
      return
9383 
    oprot.writeStructBegin('addCategory_args')
9384 
    if self.category is not None:
9385 
      oprot.writeFieldBegin('category', TType.STRUCT, 1)
9386 
      self.category.write(oprot)
9387 
      oprot.writeFieldEnd()
9388 
    oprot.writeFieldStop()
9389 
    oprot.writeStructEnd()
9390 
 
9391 
  def validate(self):
9392 
    return
9393 
 
9394 
 
9395 
  def __repr__(self):
9396 
    L = ['%s=%r' % (key, value)
9397 
      for key, value in self.__dict__.iteritems()]
9398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9399 
 
9400 
  def __eq__(self, other):
9401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9402 
 
9403 
  def __ne__(self, other):
9404 
    return not (self == other)
9405 
 
9406 
class addCategory_result:
9407 
  """
9408 
  Attributes:
9409 
   - success
9410 
  """
9411 
 
9412 
  thrift_spec = (
9413 
    (0, TType.BOOL, 'success', None, None, ), # 0
9414 
  )
9415 
 
9416 
  def __init__(self, success=None,):
9417 
    self.success = success
9418 
 
9419 
  def read(self, iprot):
9420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9422 
      return
9423 
    iprot.readStructBegin()
9424 
    while True:
9425 
      (fname, ftype, fid) = iprot.readFieldBegin()
9426 
      if ftype == TType.STOP:
9427 
        break
9428 
      if fid == 0:
9429 
        if ftype == TType.BOOL:
9430 
          self.success = iprot.readBool();
9431 
        else:
9432 
          iprot.skip(ftype)
9433 
      else:
9434 
        iprot.skip(ftype)
9435 
      iprot.readFieldEnd()
9436 
    iprot.readStructEnd()
9437 
 
9438 
  def write(self, oprot):
9439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9441 
      return
9442 
    oprot.writeStructBegin('addCategory_result')
9443 
    if self.success is not None:
9444 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9445 
      oprot.writeBool(self.success)
9446 
      oprot.writeFieldEnd()
9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
9465 
class getCategory_args:
9466 
  """
9467 
  Attributes:
9468 
   - id
9469 
  """
9470 
 
9471 
  thrift_spec = (
9472 
    None, # 0
9473 
    (1, TType.I64, 'id', None, None, ), # 1
9474 
  )
9475 
 
9476 
  def __init__(self, id=None,):
9477 
    self.id = id
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 1:
9489 
        if ftype == TType.I64:
9490 
          self.id = iprot.readI64();
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      else:
9494 
        iprot.skip(ftype)
9495 
      iprot.readFieldEnd()
9496 
    iprot.readStructEnd()
9497 
 
9498 
  def write(self, oprot):
9499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9501 
      return
9502 
    oprot.writeStructBegin('getCategory_args')
9503 
    if self.id is not None:
9504 
      oprot.writeFieldBegin('id', TType.I64, 1)
9505 
      oprot.writeI64(self.id)
9506 
      oprot.writeFieldEnd()
9507 
    oprot.writeFieldStop()
9508 
    oprot.writeStructEnd()
9509 
 
9510 
  def validate(self):
9511 
    return
9512 
 
9513 
 
9514 
  def __repr__(self):
9515 
    L = ['%s=%r' % (key, value)
9516 
      for key, value in self.__dict__.iteritems()]
9517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9518 
 
9519 
  def __eq__(self, other):
9520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9521 
 
9522 
  def __ne__(self, other):
9523 
    return not (self == other)
9524 
 
9525 
class getCategory_result:
9526 
  """
9527 
  Attributes:
9528 
   - success
9529 
  """
9530 
 
9531 
  thrift_spec = (
9532 
    (0, TType.STRUCT, 'success', (Category, Category.thrift_spec), None, ), # 0
9533 
  )
9534 
 
9535 
  def __init__(self, success=None,):
9536 
    self.success = success
9537 
 
9538 
  def read(self, iprot):
9539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9541 
      return
9542 
    iprot.readStructBegin()
9543 
    while True:
9544 
      (fname, ftype, fid) = iprot.readFieldBegin()
9545 
      if ftype == TType.STOP:
9546 
        break
9547 
      if fid == 0:
9548 
        if ftype == TType.STRUCT:
9549 
          self.success = Category()
9550 
          self.success.read(iprot)
9551 
        else:
9552 
          iprot.skip(ftype)
9553 
      else:
9554 
        iprot.skip(ftype)
9555 
      iprot.readFieldEnd()
9556 
    iprot.readStructEnd()
9557 
 
9558 
  def write(self, oprot):
9559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9561 
      return
9562 
    oprot.writeStructBegin('getCategory_result')
9563 
    if self.success is not None:
9564 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9565 
      self.success.write(oprot)
9566 
      oprot.writeFieldEnd()
9567 
    oprot.writeFieldStop()
9568 
    oprot.writeStructEnd()
9569 
 
9570 
  def validate(self):
9571 
    return
9572 
 
9573 
 
9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
9585 
class getAllCategories_args:
9586 
 
9587 
  thrift_spec = (
9588 
  )
9589 
 
9590 
  def read(self, iprot):
9591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9593 
      return
9594 
    iprot.readStructBegin()
9595 
    while True:
9596 
      (fname, ftype, fid) = iprot.readFieldBegin()
9597 
      if ftype == TType.STOP:
9598 
        break
9599 
      else:
9600 
        iprot.skip(ftype)
9601 
      iprot.readFieldEnd()
9602 
    iprot.readStructEnd()
9603 
 
9604 
  def write(self, oprot):
9605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9607 
      return
9608 
    oprot.writeStructBegin('getAllCategories_args')
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 getAllCategories_result:
9628 
  """
9629 
  Attributes:
9630 
   - success
9631 
  """
9632 
 
9633 
  thrift_spec = (
9634 
    (0, TType.LIST, 'success', (TType.STRUCT,(Category, Category.thrift_spec)), None, ), # 0
9635 
  )
9636 
 
9637 
  def __init__(self, success=None,):
9638 
    self.success = success
9639 
 
9640 
  def read(self, iprot):
9641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9643 
      return
9644 
    iprot.readStructBegin()
9645 
    while True:
9646 
      (fname, ftype, fid) = iprot.readFieldBegin()
9647 
      if ftype == TType.STOP:
9648 
        break
9649 
      if fid == 0:
9650 
        if ftype == TType.LIST:
9651 
          self.success = []
7438 amit.gupta 9652 
          (_etype140, _size137) = iprot.readListBegin()
9653 
          for _i141 in xrange(_size137):
9654 
            _elem142 = Category()
9655 
            _elem142.read(iprot)
9656 
            self.success.append(_elem142)
5944 mandeep.dh 9657 
          iprot.readListEnd()
9658 
        else:
9659 
          iprot.skip(ftype)
9660 
      else:
9661 
        iprot.skip(ftype)
9662 
      iprot.readFieldEnd()
9663 
    iprot.readStructEnd()
9664 
 
9665 
  def write(self, oprot):
9666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9668 
      return
9669 
    oprot.writeStructBegin('getAllCategories_result')
9670 
    if self.success is not None:
9671 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9672 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9673 
      for iter143 in self.success:
9674 
        iter143.write(oprot)
5944 mandeep.dh 9675 
      oprot.writeListEnd()
9676 
      oprot.writeFieldEnd()
9677 
    oprot.writeFieldStop()
9678 
    oprot.writeStructEnd()
9679 
 
9680 
  def validate(self):
9681 
    return
9682 
 
9683 
 
9684 
  def __repr__(self):
9685 
    L = ['%s=%r' % (key, value)
9686 
      for key, value in self.__dict__.iteritems()]
9687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9688 
 
9689 
  def __eq__(self, other):
9690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9691 
 
9692 
  def __ne__(self, other):
9693 
    return not (self == other)
9694 
 
9695 
class getAllSimilarItems_args:
9696 
  """
9697 
  Attributes:
9698 
   - itemId
9699 
  """
9700 
 
9701 
  thrift_spec = (
9702 
    None, # 0
9703 
    (1, TType.I64, 'itemId', None, None, ), # 1
9704 
  )
9705 
 
9706 
  def __init__(self, itemId=None,):
9707 
    self.itemId = itemId
9708 
 
9709 
  def read(self, iprot):
9710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9712 
      return
9713 
    iprot.readStructBegin()
9714 
    while True:
9715 
      (fname, ftype, fid) = iprot.readFieldBegin()
9716 
      if ftype == TType.STOP:
9717 
        break
9718 
      if fid == 1:
9719 
        if ftype == TType.I64:
9720 
          self.itemId = iprot.readI64();
9721 
        else:
9722 
          iprot.skip(ftype)
9723 
      else:
9724 
        iprot.skip(ftype)
9725 
      iprot.readFieldEnd()
9726 
    iprot.readStructEnd()
9727 
 
9728 
  def write(self, oprot):
9729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9731 
      return
9732 
    oprot.writeStructBegin('getAllSimilarItems_args')
9733 
    if self.itemId is not None:
9734 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9735 
      oprot.writeI64(self.itemId)
9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
9740 
  def validate(self):
9741 
    return
9742 
 
9743 
 
9744 
  def __repr__(self):
9745 
    L = ['%s=%r' % (key, value)
9746 
      for key, value in self.__dict__.iteritems()]
9747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9748 
 
9749 
  def __eq__(self, other):
9750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9751 
 
9752 
  def __ne__(self, other):
9753 
    return not (self == other)
9754 
 
9755 
class getAllSimilarItems_result:
9756 
  """
9757 
  Attributes:
9758 
   - success
9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
9763 
  )
9764 
 
9765 
  def __init__(self, success=None,):
9766 
    self.success = success
9767 
 
9768 
  def read(self, iprot):
9769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9771 
      return
9772 
    iprot.readStructBegin()
9773 
    while True:
9774 
      (fname, ftype, fid) = iprot.readFieldBegin()
9775 
      if ftype == TType.STOP:
9776 
        break
9777 
      if fid == 0:
9778 
        if ftype == TType.LIST:
9779 
          self.success = []
7438 amit.gupta 9780 
          (_etype147, _size144) = iprot.readListBegin()
9781 
          for _i148 in xrange(_size144):
9782 
            _elem149 = Item()
9783 
            _elem149.read(iprot)
9784 
            self.success.append(_elem149)
5944 mandeep.dh 9785 
          iprot.readListEnd()
9786 
        else:
9787 
          iprot.skip(ftype)
9788 
      else:
9789 
        iprot.skip(ftype)
9790 
      iprot.readFieldEnd()
9791 
    iprot.readStructEnd()
9792 
 
9793 
  def write(self, oprot):
9794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9796 
      return
9797 
    oprot.writeStructBegin('getAllSimilarItems_result')
9798 
    if self.success is not None:
9799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 9801 
      for iter150 in self.success:
9802 
        iter150.write(oprot)
5944 mandeep.dh 9803 
      oprot.writeListEnd()
9804 
      oprot.writeFieldEnd()
9805 
    oprot.writeFieldStop()
9806 
    oprot.writeStructEnd()
9807 
 
9808 
  def validate(self):
9809 
    return
9810 
 
9811 
 
9812 
  def __repr__(self):
9813 
    L = ['%s=%r' % (key, value)
9814 
      for key, value in self.__dict__.iteritems()]
9815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9816 
 
9817 
  def __eq__(self, other):
9818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9819 
 
9820 
  def __ne__(self, other):
9821 
    return not (self == other)
9822 
 
9823 
class addSimilarItem_args:
9824 
  """
9825 
  Attributes:
9826 
   - itemId
9827 
   - catalogItemId
9828 
  """
9829 
 
9830 
  thrift_spec = (
9831 
    None, # 0
9832 
    (1, TType.I64, 'itemId', None, None, ), # 1
9833 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
9834 
  )
9835 
 
9836 
  def __init__(self, itemId=None, catalogItemId=None,):
9837 
    self.itemId = itemId
9838 
    self.catalogItemId = catalogItemId
9839 
 
9840 
  def read(self, iprot):
9841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9843 
      return
9844 
    iprot.readStructBegin()
9845 
    while True:
9846 
      (fname, ftype, fid) = iprot.readFieldBegin()
9847 
      if ftype == TType.STOP:
9848 
        break
9849 
      if fid == 1:
9850 
        if ftype == TType.I64:
9851 
          self.itemId = iprot.readI64();
9852 
        else:
9853 
          iprot.skip(ftype)
9854 
      elif fid == 2:
9855 
        if ftype == TType.I64:
9856 
          self.catalogItemId = iprot.readI64();
9857 
        else:
9858 
          iprot.skip(ftype)
9859 
      else:
9860 
        iprot.skip(ftype)
9861 
      iprot.readFieldEnd()
9862 
    iprot.readStructEnd()
9863 
 
9864 
  def write(self, oprot):
9865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9867 
      return
9868 
    oprot.writeStructBegin('addSimilarItem_args')
9869 
    if self.itemId is not None:
9870 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9871 
      oprot.writeI64(self.itemId)
9872 
      oprot.writeFieldEnd()
9873 
    if self.catalogItemId is not None:
9874 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
9875 
      oprot.writeI64(self.catalogItemId)
9876 
      oprot.writeFieldEnd()
9877 
    oprot.writeFieldStop()
9878 
    oprot.writeStructEnd()
9879 
 
9880 
  def validate(self):
9881 
    return
9882 
 
9883 
 
9884 
  def __repr__(self):
9885 
    L = ['%s=%r' % (key, value)
9886 
      for key, value in self.__dict__.iteritems()]
9887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9888 
 
9889 
  def __eq__(self, other):
9890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9891 
 
9892 
  def __ne__(self, other):
9893 
    return not (self == other)
9894 
 
9895 
class addSimilarItem_result:
9896 
  """
9897 
  Attributes:
9898 
   - success
9899 
   - cex
9900 
  """
9901 
 
9902 
  thrift_spec = (
9903 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
9904 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
9905 
  )
9906 
 
9907 
  def __init__(self, success=None, cex=None,):
9908 
    self.success = success
9909 
    self.cex = cex
9910 
 
9911 
  def read(self, iprot):
9912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9914 
      return
9915 
    iprot.readStructBegin()
9916 
    while True:
9917 
      (fname, ftype, fid) = iprot.readFieldBegin()
9918 
      if ftype == TType.STOP:
9919 
        break
9920 
      if fid == 0:
9921 
        if ftype == TType.STRUCT:
9922 
          self.success = Item()
9923 
          self.success.read(iprot)
9924 
        else:
9925 
          iprot.skip(ftype)
9926 
      elif fid == 1:
9927 
        if ftype == TType.STRUCT:
9928 
          self.cex = CatalogServiceException()
9929 
          self.cex.read(iprot)
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      else:
9933 
        iprot.skip(ftype)
9934 
      iprot.readFieldEnd()
9935 
    iprot.readStructEnd()
9936 
 
9937 
  def write(self, oprot):
9938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9940 
      return
9941 
    oprot.writeStructBegin('addSimilarItem_result')
9942 
    if self.success is not None:
9943 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9944 
      self.success.write(oprot)
9945 
      oprot.writeFieldEnd()
9946 
    if self.cex is not None:
9947 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
9948 
      self.cex.write(oprot)
9949 
      oprot.writeFieldEnd()
9950 
    oprot.writeFieldStop()
9951 
    oprot.writeStructEnd()
9952 
 
9953 
  def validate(self):
9954 
    return
9955 
 
9956 
 
9957 
  def __repr__(self):
9958 
    L = ['%s=%r' % (key, value)
9959 
      for key, value in self.__dict__.iteritems()]
9960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9961 
 
9962 
  def __eq__(self, other):
9963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9964 
 
9965 
  def __ne__(self, other):
9966 
    return not (self == other)
9967 
 
6512 kshitij.so 9968 
class addTag_args:
9969 
  """
9970 
  Attributes:
9971 
   - displayName
9972 
   - itemId
9973 
  """
9974 
 
9975 
  thrift_spec = (
9976 
    None, # 0
9977 
    (1, TType.STRING, 'displayName', None, None, ), # 1
9978 
    (2, TType.I64, 'itemId', None, None, ), # 2
9979 
  )
9980 
 
9981 
  def __init__(self, displayName=None, itemId=None,):
9982 
    self.displayName = displayName
9983 
    self.itemId = itemId
9984 
 
9985 
  def read(self, iprot):
9986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9988 
      return
9989 
    iprot.readStructBegin()
9990 
    while True:
9991 
      (fname, ftype, fid) = iprot.readFieldBegin()
9992 
      if ftype == TType.STOP:
9993 
        break
9994 
      if fid == 1:
9995 
        if ftype == TType.STRING:
9996 
          self.displayName = iprot.readString();
9997 
        else:
9998 
          iprot.skip(ftype)
9999 
      elif fid == 2:
10000 
        if ftype == TType.I64:
10001 
          self.itemId = iprot.readI64();
10002 
        else:
10003 
          iprot.skip(ftype)
10004 
      else:
10005 
        iprot.skip(ftype)
10006 
      iprot.readFieldEnd()
10007 
    iprot.readStructEnd()
10008 
 
10009 
  def write(self, oprot):
10010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10012 
      return
10013 
    oprot.writeStructBegin('addTag_args')
10014 
    if self.displayName is not None:
10015 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10016 
      oprot.writeString(self.displayName)
10017 
      oprot.writeFieldEnd()
10018 
    if self.itemId is not None:
10019 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10020 
      oprot.writeI64(self.itemId)
10021 
      oprot.writeFieldEnd()
10022 
    oprot.writeFieldStop()
10023 
    oprot.writeStructEnd()
10024 
 
10025 
  def validate(self):
10026 
    return
10027 
 
10028 
 
10029 
  def __repr__(self):
10030 
    L = ['%s=%r' % (key, value)
10031 
      for key, value in self.__dict__.iteritems()]
10032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10033 
 
10034 
  def __eq__(self, other):
10035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10036 
 
10037 
  def __ne__(self, other):
10038 
    return not (self == other)
10039 
 
10040 
class addTag_result:
10041 
  """
10042 
  Attributes:
10043 
   - success
10044 
  """
10045 
 
10046 
  thrift_spec = (
10047 
    (0, TType.BOOL, 'success', None, None, ), # 0
10048 
  )
10049 
 
10050 
  def __init__(self, success=None,):
10051 
    self.success = success
10052 
 
10053 
  def read(self, iprot):
10054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10056 
      return
10057 
    iprot.readStructBegin()
10058 
    while True:
10059 
      (fname, ftype, fid) = iprot.readFieldBegin()
10060 
      if ftype == TType.STOP:
10061 
        break
10062 
      if fid == 0:
10063 
        if ftype == TType.BOOL:
10064 
          self.success = iprot.readBool();
10065 
        else:
10066 
          iprot.skip(ftype)
10067 
      else:
10068 
        iprot.skip(ftype)
10069 
      iprot.readFieldEnd()
10070 
    iprot.readStructEnd()
10071 
 
10072 
  def write(self, oprot):
10073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10075 
      return
10076 
    oprot.writeStructBegin('addTag_result')
10077 
    if self.success is not None:
10078 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10079 
      oprot.writeBool(self.success)
10080 
      oprot.writeFieldEnd()
10081 
    oprot.writeFieldStop()
10082 
    oprot.writeStructEnd()
10083 
 
10084 
  def validate(self):
10085 
    return
10086 
 
10087 
 
10088 
  def __repr__(self):
10089 
    L = ['%s=%r' % (key, value)
10090 
      for key, value in self.__dict__.iteritems()]
10091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10092 
 
10093 
  def __eq__(self, other):
10094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10095 
 
10096 
  def __ne__(self, other):
10097 
    return not (self == other)
10098 
 
10099 
class deleteEntityTag_args:
10100 
  """
10101 
  Attributes:
10102 
   - displayName
10103 
   - itemId
10104 
  """
10105 
 
10106 
  thrift_spec = (
10107 
    None, # 0
10108 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10109 
    (2, TType.I64, 'itemId', None, None, ), # 2
10110 
  )
10111 
 
10112 
  def __init__(self, displayName=None, itemId=None,):
10113 
    self.displayName = displayName
10114 
    self.itemId = itemId
10115 
 
10116 
  def read(self, iprot):
10117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10119 
      return
10120 
    iprot.readStructBegin()
10121 
    while True:
10122 
      (fname, ftype, fid) = iprot.readFieldBegin()
10123 
      if ftype == TType.STOP:
10124 
        break
10125 
      if fid == 1:
10126 
        if ftype == TType.STRING:
10127 
          self.displayName = iprot.readString();
10128 
        else:
10129 
          iprot.skip(ftype)
10130 
      elif fid == 2:
10131 
        if ftype == TType.I64:
10132 
          self.itemId = iprot.readI64();
10133 
        else:
10134 
          iprot.skip(ftype)
10135 
      else:
10136 
        iprot.skip(ftype)
10137 
      iprot.readFieldEnd()
10138 
    iprot.readStructEnd()
10139 
 
10140 
  def write(self, oprot):
10141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10143 
      return
10144 
    oprot.writeStructBegin('deleteEntityTag_args')
10145 
    if self.displayName is not None:
10146 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10147 
      oprot.writeString(self.displayName)
10148 
      oprot.writeFieldEnd()
10149 
    if self.itemId is not None:
10150 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10151 
      oprot.writeI64(self.itemId)
10152 
      oprot.writeFieldEnd()
10153 
    oprot.writeFieldStop()
10154 
    oprot.writeStructEnd()
10155 
 
10156 
  def validate(self):
10157 
    return
10158 
 
10159 
 
10160 
  def __repr__(self):
10161 
    L = ['%s=%r' % (key, value)
10162 
      for key, value in self.__dict__.iteritems()]
10163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10164 
 
10165 
  def __eq__(self, other):
10166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10167 
 
10168 
  def __ne__(self, other):
10169 
    return not (self == other)
10170 
 
10171 
class deleteEntityTag_result:
10172 
  """
10173 
  Attributes:
10174 
   - success
10175 
  """
10176 
 
10177 
  thrift_spec = (
10178 
    (0, TType.BOOL, 'success', None, None, ), # 0
10179 
  )
10180 
 
10181 
  def __init__(self, success=None,):
10182 
    self.success = success
10183 
 
10184 
  def read(self, iprot):
10185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10187 
      return
10188 
    iprot.readStructBegin()
10189 
    while True:
10190 
      (fname, ftype, fid) = iprot.readFieldBegin()
10191 
      if ftype == TType.STOP:
10192 
        break
10193 
      if fid == 0:
10194 
        if ftype == TType.BOOL:
10195 
          self.success = iprot.readBool();
10196 
        else:
10197 
          iprot.skip(ftype)
10198 
      else:
10199 
        iprot.skip(ftype)
10200 
      iprot.readFieldEnd()
10201 
    iprot.readStructEnd()
10202 
 
10203 
  def write(self, oprot):
10204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10206 
      return
10207 
    oprot.writeStructBegin('deleteEntityTag_result')
10208 
    if self.success is not None:
10209 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10210 
      oprot.writeBool(self.success)
10211 
      oprot.writeFieldEnd()
10212 
    oprot.writeFieldStop()
10213 
    oprot.writeStructEnd()
10214 
 
10215 
  def validate(self):
10216 
    return
10217 
 
10218 
 
10219 
  def __repr__(self):
10220 
    L = ['%s=%r' % (key, value)
10221 
      for key, value in self.__dict__.iteritems()]
10222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10223 
 
10224 
  def __eq__(self, other):
10225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10226 
 
10227 
  def __ne__(self, other):
10228 
    return not (self == other)
10229 
 
10230 
class deleteTag_args:
10231 
  """
10232 
  Attributes:
10233 
   - displayName
10234 
  """
10235 
 
10236 
  thrift_spec = (
10237 
    None, # 0
10238 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10239 
  )
10240 
 
10241 
  def __init__(self, displayName=None,):
10242 
    self.displayName = displayName
10243 
 
10244 
  def read(self, iprot):
10245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10247 
      return
10248 
    iprot.readStructBegin()
10249 
    while True:
10250 
      (fname, ftype, fid) = iprot.readFieldBegin()
10251 
      if ftype == TType.STOP:
10252 
        break
10253 
      if fid == 1:
10254 
        if ftype == TType.STRING:
10255 
          self.displayName = iprot.readString();
10256 
        else:
10257 
          iprot.skip(ftype)
10258 
      else:
10259 
        iprot.skip(ftype)
10260 
      iprot.readFieldEnd()
10261 
    iprot.readStructEnd()
10262 
 
10263 
  def write(self, oprot):
10264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10266 
      return
10267 
    oprot.writeStructBegin('deleteTag_args')
10268 
    if self.displayName is not None:
10269 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10270 
      oprot.writeString(self.displayName)
10271 
      oprot.writeFieldEnd()
10272 
    oprot.writeFieldStop()
10273 
    oprot.writeStructEnd()
10274 
 
10275 
  def validate(self):
10276 
    return
10277 
 
10278 
 
10279 
  def __repr__(self):
10280 
    L = ['%s=%r' % (key, value)
10281 
      for key, value in self.__dict__.iteritems()]
10282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10283 
 
10284 
  def __eq__(self, other):
10285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10286 
 
10287 
  def __ne__(self, other):
10288 
    return not (self == other)
10289 
 
10290 
class deleteTag_result:
10291 
  """
10292 
  Attributes:
10293 
   - success
10294 
  """
10295 
 
10296 
  thrift_spec = (
10297 
    (0, TType.BOOL, 'success', None, None, ), # 0
10298 
  )
10299 
 
10300 
  def __init__(self, success=None,):
10301 
    self.success = success
10302 
 
10303 
  def read(self, iprot):
10304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10306 
      return
10307 
    iprot.readStructBegin()
10308 
    while True:
10309 
      (fname, ftype, fid) = iprot.readFieldBegin()
10310 
      if ftype == TType.STOP:
10311 
        break
10312 
      if fid == 0:
10313 
        if ftype == TType.BOOL:
10314 
          self.success = iprot.readBool();
10315 
        else:
10316 
          iprot.skip(ftype)
10317 
      else:
10318 
        iprot.skip(ftype)
10319 
      iprot.readFieldEnd()
10320 
    iprot.readStructEnd()
10321 
 
10322 
  def write(self, oprot):
10323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10325 
      return
10326 
    oprot.writeStructBegin('deleteTag_result')
10327 
    if self.success is not None:
10328 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10329 
      oprot.writeBool(self.success)
10330 
      oprot.writeFieldEnd()
10331 
    oprot.writeFieldStop()
10332 
    oprot.writeStructEnd()
10333 
 
10334 
  def validate(self):
10335 
    return
10336 
 
10337 
 
10338 
  def __repr__(self):
10339 
    L = ['%s=%r' % (key, value)
10340 
      for key, value in self.__dict__.iteritems()]
10341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10342 
 
10343 
  def __eq__(self, other):
10344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10345 
 
10346 
  def __ne__(self, other):
10347 
    return not (self == other)
10348 
 
10349 
class getAllTags_args:
10350 
 
10351 
  thrift_spec = (
10352 
  )
10353 
 
10354 
  def read(self, iprot):
10355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10357 
      return
10358 
    iprot.readStructBegin()
10359 
    while True:
10360 
      (fname, ftype, fid) = iprot.readFieldBegin()
10361 
      if ftype == TType.STOP:
10362 
        break
10363 
      else:
10364 
        iprot.skip(ftype)
10365 
      iprot.readFieldEnd()
10366 
    iprot.readStructEnd()
10367 
 
10368 
  def write(self, oprot):
10369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10371 
      return
10372 
    oprot.writeStructBegin('getAllTags_args')
10373 
    oprot.writeFieldStop()
10374 
    oprot.writeStructEnd()
10375 
 
10376 
  def validate(self):
10377 
    return
10378 
 
10379 
 
10380 
  def __repr__(self):
10381 
    L = ['%s=%r' % (key, value)
10382 
      for key, value in self.__dict__.iteritems()]
10383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10384 
 
10385 
  def __eq__(self, other):
10386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10387 
 
10388 
  def __ne__(self, other):
10389 
    return not (self == other)
10390 
 
10391 
class getAllTags_result:
10392 
  """
10393 
  Attributes:
10394 
   - success
10395 
  """
10396 
 
10397 
  thrift_spec = (
10398 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10399 
  )
10400 
 
10401 
  def __init__(self, success=None,):
10402 
    self.success = success
10403 
 
10404 
  def read(self, iprot):
10405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10407 
      return
10408 
    iprot.readStructBegin()
10409 
    while True:
10410 
      (fname, ftype, fid) = iprot.readFieldBegin()
10411 
      if ftype == TType.STOP:
10412 
        break
10413 
      if fid == 0:
10414 
        if ftype == TType.LIST:
10415 
          self.success = []
7438 amit.gupta 10416 
          (_etype154, _size151) = iprot.readListBegin()
10417 
          for _i155 in xrange(_size151):
10418 
            _elem156 = iprot.readString();
10419 
            self.success.append(_elem156)
6512 kshitij.so 10420 
          iprot.readListEnd()
10421 
        else:
10422 
          iprot.skip(ftype)
10423 
      else:
10424 
        iprot.skip(ftype)
10425 
      iprot.readFieldEnd()
10426 
    iprot.readStructEnd()
10427 
 
10428 
  def write(self, oprot):
10429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10431 
      return
10432 
    oprot.writeStructBegin('getAllTags_result')
10433 
    if self.success is not None:
10434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10435 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10436 
      for iter157 in self.success:
10437 
        oprot.writeString(iter157)
6512 kshitij.so 10438 
      oprot.writeListEnd()
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
10458 
class getAllEntitiesByTagName_args:
10459 
  """
10460 
  Attributes:
10461 
   - displayName
10462 
  """
10463 
 
10464 
  thrift_spec = (
10465 
    None, # 0
10466 
    (1, TType.STRING, 'displayName', None, None, ), # 1
10467 
  )
10468 
 
10469 
  def __init__(self, displayName=None,):
10470 
    self.displayName = displayName
10471 
 
10472 
  def read(self, iprot):
10473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10475 
      return
10476 
    iprot.readStructBegin()
10477 
    while True:
10478 
      (fname, ftype, fid) = iprot.readFieldBegin()
10479 
      if ftype == TType.STOP:
10480 
        break
10481 
      if fid == 1:
10482 
        if ftype == TType.STRING:
10483 
          self.displayName = iprot.readString();
10484 
        else:
10485 
          iprot.skip(ftype)
10486 
      else:
10487 
        iprot.skip(ftype)
10488 
      iprot.readFieldEnd()
10489 
    iprot.readStructEnd()
10490 
 
10491 
  def write(self, oprot):
10492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10494 
      return
10495 
    oprot.writeStructBegin('getAllEntitiesByTagName_args')
10496 
    if self.displayName is not None:
10497 
      oprot.writeFieldBegin('displayName', TType.STRING, 1)
10498 
      oprot.writeString(self.displayName)
10499 
      oprot.writeFieldEnd()
10500 
    oprot.writeFieldStop()
10501 
    oprot.writeStructEnd()
10502 
 
10503 
  def validate(self):
10504 
    return
10505 
 
10506 
 
10507 
  def __repr__(self):
10508 
    L = ['%s=%r' % (key, value)
10509 
      for key, value in self.__dict__.iteritems()]
10510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10511 
 
10512 
  def __eq__(self, other):
10513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10514 
 
10515 
  def __ne__(self, other):
10516 
    return not (self == other)
10517 
 
10518 
class getAllEntitiesByTagName_result:
10519 
  """
10520 
  Attributes:
10521 
   - success
10522 
  """
10523 
 
10524 
  thrift_spec = (
10525 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10526 
  )
10527 
 
10528 
  def __init__(self, success=None,):
10529 
    self.success = success
10530 
 
10531 
  def read(self, iprot):
10532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10534 
      return
10535 
    iprot.readStructBegin()
10536 
    while True:
10537 
      (fname, ftype, fid) = iprot.readFieldBegin()
10538 
      if ftype == TType.STOP:
10539 
        break
10540 
      if fid == 0:
10541 
        if ftype == TType.LIST:
10542 
          self.success = []
7438 amit.gupta 10543 
          (_etype161, _size158) = iprot.readListBegin()
10544 
          for _i162 in xrange(_size158):
10545 
            _elem163 = iprot.readI64();
10546 
            self.success.append(_elem163)
6512 kshitij.so 10547 
          iprot.readListEnd()
10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
10559 
    oprot.writeStructBegin('getAllEntitiesByTagName_result')
10560 
    if self.success is not None:
10561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10562 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 10563 
      for iter164 in self.success:
10564 
        oprot.writeI64(iter164)
6512 kshitij.so 10565 
      oprot.writeListEnd()
10566 
      oprot.writeFieldEnd()
10567 
    oprot.writeFieldStop()
10568 
    oprot.writeStructEnd()
10569 
 
10570 
  def validate(self):
10571 
    return
10572 
 
10573 
 
10574 
  def __repr__(self):
10575 
    L = ['%s=%r' % (key, value)
10576 
      for key, value in self.__dict__.iteritems()]
10577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10578 
 
10579 
  def __eq__(self, other):
10580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10581 
 
10582 
  def __ne__(self, other):
10583 
    return not (self == other)
10584 
 
6845 amit.gupta 10585 
class getAllEntityTags_args:
10586 
 
10587 
  thrift_spec = (
10588 
  )
10589 
 
10590 
  def read(self, iprot):
10591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10593 
      return
10594 
    iprot.readStructBegin()
10595 
    while True:
10596 
      (fname, ftype, fid) = iprot.readFieldBegin()
10597 
      if ftype == TType.STOP:
10598 
        break
10599 
      else:
10600 
        iprot.skip(ftype)
10601 
      iprot.readFieldEnd()
10602 
    iprot.readStructEnd()
10603 
 
10604 
  def write(self, oprot):
10605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10607 
      return
10608 
    oprot.writeStructBegin('getAllEntityTags_args')
10609 
    oprot.writeFieldStop()
10610 
    oprot.writeStructEnd()
10611 
 
10612 
  def validate(self):
10613 
    return
10614 
 
10615 
 
10616 
  def __repr__(self):
10617 
    L = ['%s=%r' % (key, value)
10618 
      for key, value in self.__dict__.iteritems()]
10619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10620 
 
10621 
  def __eq__(self, other):
10622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10623 
 
10624 
  def __ne__(self, other):
10625 
    return not (self == other)
10626 
 
10627 
class getAllEntityTags_result:
10628 
  """
10629 
  Attributes:
10630 
   - success
10631 
  """
10632 
 
10633 
  thrift_spec = (
10634 
    (0, TType.MAP, 'success', (TType.I64,None,TType.LIST,(TType.STRING,None)), None, ), # 0
10635 
  )
10636 
 
10637 
  def __init__(self, success=None,):
10638 
    self.success = success
10639 
 
10640 
  def read(self, iprot):
10641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10643 
      return
10644 
    iprot.readStructBegin()
10645 
    while True:
10646 
      (fname, ftype, fid) = iprot.readFieldBegin()
10647 
      if ftype == TType.STOP:
10648 
        break
10649 
      if fid == 0:
10650 
        if ftype == TType.MAP:
10651 
          self.success = {}
7438 amit.gupta 10652 
          (_ktype166, _vtype167, _size165 ) = iprot.readMapBegin()
10653 
          for _i169 in xrange(_size165):
10654 
            _key170 = iprot.readI64();
10655 
            _val171 = []
10656 
            (_etype175, _size172) = iprot.readListBegin()
10657 
            for _i176 in xrange(_size172):
10658 
              _elem177 = iprot.readString();
10659 
              _val171.append(_elem177)
6845 amit.gupta 10660 
            iprot.readListEnd()
7438 amit.gupta 10661 
            self.success[_key170] = _val171
6845 amit.gupta 10662 
          iprot.readMapEnd()
10663 
        else:
10664 
          iprot.skip(ftype)
10665 
      else:
10666 
        iprot.skip(ftype)
10667 
      iprot.readFieldEnd()
10668 
    iprot.readStructEnd()
10669 
 
10670 
  def write(self, oprot):
10671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10673 
      return
10674 
    oprot.writeStructBegin('getAllEntityTags_result')
10675 
    if self.success is not None:
10676 
      oprot.writeFieldBegin('success', TType.MAP, 0)
10677 
      oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
7438 amit.gupta 10678 
      for kiter178,viter179 in self.success.items():
10679 
        oprot.writeI64(kiter178)
10680 
        oprot.writeListBegin(TType.STRING, len(viter179))
10681 
        for iter180 in viter179:
10682 
          oprot.writeString(iter180)
6845 amit.gupta 10683 
        oprot.writeListEnd()
10684 
      oprot.writeMapEnd()
10685 
      oprot.writeFieldEnd()
10686 
    oprot.writeFieldStop()
10687 
    oprot.writeStructEnd()
10688 
 
10689 
  def validate(self):
10690 
    return
10691 
 
10692 
 
10693 
  def __repr__(self):
10694 
    L = ['%s=%r' % (key, value)
10695 
      for key, value in self.__dict__.iteritems()]
10696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10697 
 
10698 
  def __eq__(self, other):
10699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10700 
 
10701 
  def __ne__(self, other):
10702 
    return not (self == other)
10703 
 
6850 kshitij.so 10704 
class addBanner_args:
10705 
  """
10706 
  Attributes:
10707 
   - bannerName
10708 
   - imageName
10709 
   - link
10710 
   - priority
10711 
   - isActive
10712 
   - hasMap
10713 
  """
10714 
 
10715 
  thrift_spec = (
10716 
    None, # 0
10717 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
10718 
    (2, TType.STRING, 'imageName', None, None, ), # 2
10719 
    (3, TType.STRING, 'link', None, None, ), # 3
10720 
    (4, TType.I64, 'priority', None, None, ), # 4
10721 
    (5, TType.BOOL, 'isActive', None, None, ), # 5
10722 
    (6, TType.BOOL, 'hasMap', None, None, ), # 6
10723 
  )
10724 
 
10725 
  def __init__(self, bannerName=None, imageName=None, link=None, priority=None, isActive=None, hasMap=None,):
10726 
    self.bannerName = bannerName
10727 
    self.imageName = imageName
10728 
    self.link = link
10729 
    self.priority = priority
10730 
    self.isActive = isActive
10731 
    self.hasMap = hasMap
10732 
 
10733 
  def read(self, iprot):
10734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10736 
      return
10737 
    iprot.readStructBegin()
10738 
    while True:
10739 
      (fname, ftype, fid) = iprot.readFieldBegin()
10740 
      if ftype == TType.STOP:
10741 
        break
10742 
      if fid == 1:
10743 
        if ftype == TType.STRING:
10744 
          self.bannerName = iprot.readString();
10745 
        else:
10746 
          iprot.skip(ftype)
10747 
      elif fid == 2:
10748 
        if ftype == TType.STRING:
10749 
          self.imageName = iprot.readString();
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      elif fid == 3:
10753 
        if ftype == TType.STRING:
10754 
          self.link = iprot.readString();
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      elif fid == 4:
10758 
        if ftype == TType.I64:
10759 
          self.priority = iprot.readI64();
10760 
        else:
10761 
          iprot.skip(ftype)
10762 
      elif fid == 5:
10763 
        if ftype == TType.BOOL:
10764 
          self.isActive = iprot.readBool();
10765 
        else:
10766 
          iprot.skip(ftype)
10767 
      elif fid == 6:
10768 
        if ftype == TType.BOOL:
10769 
          self.hasMap = iprot.readBool();
10770 
        else:
10771 
          iprot.skip(ftype)
10772 
      else:
10773 
        iprot.skip(ftype)
10774 
      iprot.readFieldEnd()
10775 
    iprot.readStructEnd()
10776 
 
10777 
  def write(self, oprot):
10778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10780 
      return
10781 
    oprot.writeStructBegin('addBanner_args')
10782 
    if self.bannerName is not None:
10783 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
10784 
      oprot.writeString(self.bannerName)
10785 
      oprot.writeFieldEnd()
10786 
    if self.imageName is not None:
10787 
      oprot.writeFieldBegin('imageName', TType.STRING, 2)
10788 
      oprot.writeString(self.imageName)
10789 
      oprot.writeFieldEnd()
10790 
    if self.link is not None:
10791 
      oprot.writeFieldBegin('link', TType.STRING, 3)
10792 
      oprot.writeString(self.link)
10793 
      oprot.writeFieldEnd()
10794 
    if self.priority is not None:
10795 
      oprot.writeFieldBegin('priority', TType.I64, 4)
10796 
      oprot.writeI64(self.priority)
10797 
      oprot.writeFieldEnd()
10798 
    if self.isActive is not None:
10799 
      oprot.writeFieldBegin('isActive', TType.BOOL, 5)
10800 
      oprot.writeBool(self.isActive)
10801 
      oprot.writeFieldEnd()
10802 
    if self.hasMap is not None:
10803 
      oprot.writeFieldBegin('hasMap', TType.BOOL, 6)
10804 
      oprot.writeBool(self.hasMap)
10805 
      oprot.writeFieldEnd()
10806 
    oprot.writeFieldStop()
10807 
    oprot.writeStructEnd()
10808 
 
10809 
  def validate(self):
10810 
    return
10811 
 
10812 
 
10813 
  def __repr__(self):
10814 
    L = ['%s=%r' % (key, value)
10815 
      for key, value in self.__dict__.iteritems()]
10816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10817 
 
10818 
  def __eq__(self, other):
10819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10820 
 
10821 
  def __ne__(self, other):
10822 
    return not (self == other)
10823 
 
10824 
class addBanner_result:
10825 
  """
10826 
  Attributes:
10827 
   - success
10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    (0, TType.BOOL, 'success', None, None, ), # 0
10832 
  )
10833 
 
10834 
  def __init__(self, success=None,):
10835 
    self.success = success
10836 
 
10837 
  def read(self, iprot):
10838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10840 
      return
10841 
    iprot.readStructBegin()
10842 
    while True:
10843 
      (fname, ftype, fid) = iprot.readFieldBegin()
10844 
      if ftype == TType.STOP:
10845 
        break
10846 
      if fid == 0:
10847 
        if ftype == TType.BOOL:
10848 
          self.success = iprot.readBool();
10849 
        else:
10850 
          iprot.skip(ftype)
10851 
      else:
10852 
        iprot.skip(ftype)
10853 
      iprot.readFieldEnd()
10854 
    iprot.readStructEnd()
10855 
 
10856 
  def write(self, oprot):
10857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10859 
      return
10860 
    oprot.writeStructBegin('addBanner_result')
10861 
    if self.success is not None:
10862 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10863 
      oprot.writeBool(self.success)
10864 
      oprot.writeFieldEnd()
10865 
    oprot.writeFieldStop()
10866 
    oprot.writeStructEnd()
10867 
 
10868 
  def validate(self):
10869 
    return
10870 
 
10871 
 
10872 
  def __repr__(self):
10873 
    L = ['%s=%r' % (key, value)
10874 
      for key, value in self.__dict__.iteritems()]
10875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10876 
 
10877 
  def __eq__(self, other):
10878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10879 
 
10880 
  def __ne__(self, other):
10881 
    return not (self == other)
10882 
 
10883 
class getAllBanners_args:
10884 
 
10885 
  thrift_spec = (
10886 
  )
10887 
 
10888 
  def read(self, iprot):
10889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10891 
      return
10892 
    iprot.readStructBegin()
10893 
    while True:
10894 
      (fname, ftype, fid) = iprot.readFieldBegin()
10895 
      if ftype == TType.STOP:
10896 
        break
10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
10906 
    oprot.writeStructBegin('getAllBanners_args')
10907 
    oprot.writeFieldStop()
10908 
    oprot.writeStructEnd()
10909 
 
10910 
  def validate(self):
10911 
    return
10912 
 
10913 
 
10914 
  def __repr__(self):
10915 
    L = ['%s=%r' % (key, value)
10916 
      for key, value in self.__dict__.iteritems()]
10917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10918 
 
10919 
  def __eq__(self, other):
10920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10921 
 
10922 
  def __ne__(self, other):
10923 
    return not (self == other)
10924 
 
10925 
class getAllBanners_result:
10926 
  """
10927 
  Attributes:
10928 
   - success
10929 
  """
10930 
 
10931 
  thrift_spec = (
10932 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
10933 
  )
10934 
 
10935 
  def __init__(self, success=None,):
10936 
    self.success = success
10937 
 
10938 
  def read(self, iprot):
10939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10941 
      return
10942 
    iprot.readStructBegin()
10943 
    while True:
10944 
      (fname, ftype, fid) = iprot.readFieldBegin()
10945 
      if ftype == TType.STOP:
10946 
        break
10947 
      if fid == 0:
10948 
        if ftype == TType.LIST:
10949 
          self.success = []
7438 amit.gupta 10950 
          (_etype184, _size181) = iprot.readListBegin()
10951 
          for _i185 in xrange(_size181):
10952 
            _elem186 = iprot.readString();
10953 
            self.success.append(_elem186)
6850 kshitij.so 10954 
          iprot.readListEnd()
10955 
        else:
10956 
          iprot.skip(ftype)
10957 
      else:
10958 
        iprot.skip(ftype)
10959 
      iprot.readFieldEnd()
10960 
    iprot.readStructEnd()
10961 
 
10962 
  def write(self, oprot):
10963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10965 
      return
10966 
    oprot.writeStructBegin('getAllBanners_result')
10967 
    if self.success is not None:
10968 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10969 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 10970 
      for iter187 in self.success:
10971 
        oprot.writeString(iter187)
6850 kshitij.so 10972 
      oprot.writeListEnd()
10973 
      oprot.writeFieldEnd()
10974 
    oprot.writeFieldStop()
10975 
    oprot.writeStructEnd()
10976 
 
10977 
  def validate(self):
10978 
    return
10979 
 
10980 
 
10981 
  def __repr__(self):
10982 
    L = ['%s=%r' % (key, value)
10983 
      for key, value in self.__dict__.iteritems()]
10984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10985 
 
10986 
  def __eq__(self, other):
10987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10988 
 
10989 
  def __ne__(self, other):
10990 
    return not (self == other)
10991 
 
10992 
class deleteBanner_args:
10993 
  """
10994 
  Attributes:
10995 
   - bannerName
10996 
  """
10997 
 
10998 
  thrift_spec = (
10999 
    None, # 0
11000 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11001 
  )
11002 
 
11003 
  def __init__(self, bannerName=None,):
11004 
    self.bannerName = bannerName
11005 
 
11006 
  def read(self, iprot):
11007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11009 
      return
11010 
    iprot.readStructBegin()
11011 
    while True:
11012 
      (fname, ftype, fid) = iprot.readFieldBegin()
11013 
      if ftype == TType.STOP:
11014 
        break
11015 
      if fid == 1:
11016 
        if ftype == TType.STRING:
11017 
          self.bannerName = iprot.readString();
11018 
        else:
11019 
          iprot.skip(ftype)
11020 
      else:
11021 
        iprot.skip(ftype)
11022 
      iprot.readFieldEnd()
11023 
    iprot.readStructEnd()
11024 
 
11025 
  def write(self, oprot):
11026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11028 
      return
11029 
    oprot.writeStructBegin('deleteBanner_args')
11030 
    if self.bannerName is not None:
11031 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11032 
      oprot.writeString(self.bannerName)
11033 
      oprot.writeFieldEnd()
11034 
    oprot.writeFieldStop()
11035 
    oprot.writeStructEnd()
11036 
 
11037 
  def validate(self):
11038 
    return
11039 
 
11040 
 
11041 
  def __repr__(self):
11042 
    L = ['%s=%r' % (key, value)
11043 
      for key, value in self.__dict__.iteritems()]
11044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11045 
 
11046 
  def __eq__(self, other):
11047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11048 
 
11049 
  def __ne__(self, other):
11050 
    return not (self == other)
11051 
 
11052 
class deleteBanner_result:
11053 
  """
11054 
  Attributes:
11055 
   - success
11056 
  """
11057 
 
11058 
  thrift_spec = (
11059 
    (0, TType.BOOL, 'success', None, None, ), # 0
11060 
  )
11061 
 
11062 
  def __init__(self, success=None,):
11063 
    self.success = success
11064 
 
11065 
  def read(self, iprot):
11066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11068 
      return
11069 
    iprot.readStructBegin()
11070 
    while True:
11071 
      (fname, ftype, fid) = iprot.readFieldBegin()
11072 
      if ftype == TType.STOP:
11073 
        break
11074 
      if fid == 0:
11075 
        if ftype == TType.BOOL:
11076 
          self.success = iprot.readBool();
11077 
        else:
11078 
          iprot.skip(ftype)
11079 
      else:
11080 
        iprot.skip(ftype)
11081 
      iprot.readFieldEnd()
11082 
    iprot.readStructEnd()
11083 
 
11084 
  def write(self, oprot):
11085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11087 
      return
11088 
    oprot.writeStructBegin('deleteBanner_result')
11089 
    if self.success is not None:
11090 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11091 
      oprot.writeBool(self.success)
11092 
      oprot.writeFieldEnd()
11093 
    oprot.writeFieldStop()
11094 
    oprot.writeStructEnd()
11095 
 
11096 
  def validate(self):
11097 
    return
11098 
 
11099 
 
11100 
  def __repr__(self):
11101 
    L = ['%s=%r' % (key, value)
11102 
      for key, value in self.__dict__.iteritems()]
11103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11104 
 
11105 
  def __eq__(self, other):
11106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11107 
 
11108 
  def __ne__(self, other):
11109 
    return not (self == other)
11110 
 
11111 
class getBannerDetails_args:
11112 
  """
11113 
  Attributes:
11114 
   - bannerName
11115 
  """
11116 
 
11117 
  thrift_spec = (
11118 
    None, # 0
11119 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11120 
  )
11121 
 
11122 
  def __init__(self, bannerName=None,):
11123 
    self.bannerName = bannerName
11124 
 
11125 
  def read(self, iprot):
11126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11128 
      return
11129 
    iprot.readStructBegin()
11130 
    while True:
11131 
      (fname, ftype, fid) = iprot.readFieldBegin()
11132 
      if ftype == TType.STOP:
11133 
        break
11134 
      if fid == 1:
11135 
        if ftype == TType.STRING:
11136 
          self.bannerName = iprot.readString();
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('getBannerDetails_args')
11149 
    if self.bannerName is not None:
11150 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11151 
      oprot.writeString(self.bannerName)
11152 
      oprot.writeFieldEnd()
11153 
    oprot.writeFieldStop()
11154 
    oprot.writeStructEnd()
11155 
 
11156 
  def validate(self):
11157 
    return
11158 
 
11159 
 
11160 
  def __repr__(self):
11161 
    L = ['%s=%r' % (key, value)
11162 
      for key, value in self.__dict__.iteritems()]
11163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11164 
 
11165 
  def __eq__(self, other):
11166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11167 
 
11168 
  def __ne__(self, other):
11169 
    return not (self == other)
11170 
 
11171 
class getBannerDetails_result:
11172 
  """
11173 
  Attributes:
11174 
   - success
11175 
  """
11176 
 
11177 
  thrift_spec = (
11178 
    (0, TType.STRUCT, 'success', (Banner, Banner.thrift_spec), None, ), # 0
11179 
  )
11180 
 
11181 
  def __init__(self, success=None,):
11182 
    self.success = success
11183 
 
11184 
  def read(self, iprot):
11185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11187 
      return
11188 
    iprot.readStructBegin()
11189 
    while True:
11190 
      (fname, ftype, fid) = iprot.readFieldBegin()
11191 
      if ftype == TType.STOP:
11192 
        break
11193 
      if fid == 0:
11194 
        if ftype == TType.STRUCT:
11195 
          self.success = Banner()
11196 
          self.success.read(iprot)
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      else:
11200 
        iprot.skip(ftype)
11201 
      iprot.readFieldEnd()
11202 
    iprot.readStructEnd()
11203 
 
11204 
  def write(self, oprot):
11205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11207 
      return
11208 
    oprot.writeStructBegin('getBannerDetails_result')
11209 
    if self.success is not None:
11210 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11211 
      self.success.write(oprot)
11212 
      oprot.writeFieldEnd()
11213 
    oprot.writeFieldStop()
11214 
    oprot.writeStructEnd()
11215 
 
11216 
  def validate(self):
11217 
    return
11218 
 
11219 
 
11220 
  def __repr__(self):
11221 
    L = ['%s=%r' % (key, value)
11222 
      for key, value in self.__dict__.iteritems()]
11223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11224 
 
11225 
  def __eq__(self, other):
11226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11227 
 
11228 
  def __ne__(self, other):
11229 
    return not (self == other)
11230 
 
11231 
class getActiveBanners_args:
11232 
 
11233 
  thrift_spec = (
11234 
  )
11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      else:
11246 
        iprot.skip(ftype)
11247 
      iprot.readFieldEnd()
11248 
    iprot.readStructEnd()
11249 
 
11250 
  def write(self, oprot):
11251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11253 
      return
11254 
    oprot.writeStructBegin('getActiveBanners_args')
11255 
    oprot.writeFieldStop()
11256 
    oprot.writeStructEnd()
11257 
 
11258 
  def validate(self):
11259 
    return
11260 
 
11261 
 
11262 
  def __repr__(self):
11263 
    L = ['%s=%r' % (key, value)
11264 
      for key, value in self.__dict__.iteritems()]
11265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11266 
 
11267 
  def __eq__(self, other):
11268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11269 
 
11270 
  def __ne__(self, other):
11271 
    return not (self == other)
11272 
 
11273 
class getActiveBanners_result:
11274 
  """
11275 
  Attributes:
11276 
   - success
11277 
  """
11278 
 
11279 
  thrift_spec = (
11280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Banner, Banner.thrift_spec)), None, ), # 0
11281 
  )
11282 
 
11283 
  def __init__(self, success=None,):
11284 
    self.success = success
11285 
 
11286 
  def read(self, iprot):
11287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11289 
      return
11290 
    iprot.readStructBegin()
11291 
    while True:
11292 
      (fname, ftype, fid) = iprot.readFieldBegin()
11293 
      if ftype == TType.STOP:
11294 
        break
11295 
      if fid == 0:
11296 
        if ftype == TType.LIST:
11297 
          self.success = []
7438 amit.gupta 11298 
          (_etype191, _size188) = iprot.readListBegin()
11299 
          for _i192 in xrange(_size188):
11300 
            _elem193 = Banner()
11301 
            _elem193.read(iprot)
11302 
            self.success.append(_elem193)
6850 kshitij.so 11303 
          iprot.readListEnd()
11304 
        else:
11305 
          iprot.skip(ftype)
11306 
      else:
11307 
        iprot.skip(ftype)
11308 
      iprot.readFieldEnd()
11309 
    iprot.readStructEnd()
11310 
 
11311 
  def write(self, oprot):
11312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11314 
      return
11315 
    oprot.writeStructBegin('getActiveBanners_result')
11316 
    if self.success is not None:
11317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11319 
      for iter194 in self.success:
11320 
        iter194.write(oprot)
6850 kshitij.so 11321 
      oprot.writeListEnd()
11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
6849 kshitij.so 11341 
class addBannerMap_args:
11342 
  """
11343 
  Attributes:
11344 
   - bannerName
11345 
   - mapLink
11346 
   - coordinates
11347 
  """
11348 
 
11349 
  thrift_spec = (
11350 
    None, # 0
11351 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11352 
    (2, TType.STRING, 'mapLink', None, None, ), # 2
11353 
    (3, TType.STRING, 'coordinates', None, None, ), # 3
11354 
  )
11355 
 
11356 
  def __init__(self, bannerName=None, mapLink=None, coordinates=None,):
11357 
    self.bannerName = bannerName
11358 
    self.mapLink = mapLink
11359 
    self.coordinates = coordinates
11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 1:
11371 
        if ftype == TType.STRING:
11372 
          self.bannerName = iprot.readString();
11373 
        else:
11374 
          iprot.skip(ftype)
11375 
      elif fid == 2:
11376 
        if ftype == TType.STRING:
11377 
          self.mapLink = iprot.readString();
11378 
        else:
11379 
          iprot.skip(ftype)
11380 
      elif fid == 3:
11381 
        if ftype == TType.STRING:
11382 
          self.coordinates = iprot.readString();
11383 
        else:
11384 
          iprot.skip(ftype)
11385 
      else:
11386 
        iprot.skip(ftype)
11387 
      iprot.readFieldEnd()
11388 
    iprot.readStructEnd()
11389 
 
11390 
  def write(self, oprot):
11391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11393 
      return
11394 
    oprot.writeStructBegin('addBannerMap_args')
11395 
    if self.bannerName is not None:
11396 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11397 
      oprot.writeString(self.bannerName)
11398 
      oprot.writeFieldEnd()
11399 
    if self.mapLink is not None:
11400 
      oprot.writeFieldBegin('mapLink', TType.STRING, 2)
11401 
      oprot.writeString(self.mapLink)
11402 
      oprot.writeFieldEnd()
11403 
    if self.coordinates is not None:
11404 
      oprot.writeFieldBegin('coordinates', TType.STRING, 3)
11405 
      oprot.writeString(self.coordinates)
11406 
      oprot.writeFieldEnd()
11407 
    oprot.writeFieldStop()
11408 
    oprot.writeStructEnd()
11409 
 
11410 
  def validate(self):
11411 
    return
11412 
 
11413 
 
11414 
  def __repr__(self):
11415 
    L = ['%s=%r' % (key, value)
11416 
      for key, value in self.__dict__.iteritems()]
11417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11418 
 
11419 
  def __eq__(self, other):
11420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11421 
 
11422 
  def __ne__(self, other):
11423 
    return not (self == other)
11424 
 
11425 
class addBannerMap_result:
11426 
  """
11427 
  Attributes:
11428 
   - success
11429 
  """
11430 
 
11431 
  thrift_spec = (
11432 
    (0, TType.BOOL, 'success', None, None, ), # 0
11433 
  )
11434 
 
11435 
  def __init__(self, success=None,):
11436 
    self.success = success
11437 
 
11438 
  def read(self, iprot):
11439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11441 
      return
11442 
    iprot.readStructBegin()
11443 
    while True:
11444 
      (fname, ftype, fid) = iprot.readFieldBegin()
11445 
      if ftype == TType.STOP:
11446 
        break
11447 
      if fid == 0:
11448 
        if ftype == TType.BOOL:
11449 
          self.success = iprot.readBool();
11450 
        else:
11451 
          iprot.skip(ftype)
11452 
      else:
11453 
        iprot.skip(ftype)
11454 
      iprot.readFieldEnd()
11455 
    iprot.readStructEnd()
11456 
 
11457 
  def write(self, oprot):
11458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11460 
      return
11461 
    oprot.writeStructBegin('addBannerMap_result')
11462 
    if self.success is not None:
11463 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11464 
      oprot.writeBool(self.success)
11465 
      oprot.writeFieldEnd()
11466 
    oprot.writeFieldStop()
11467 
    oprot.writeStructEnd()
11468 
 
11469 
  def validate(self):
11470 
    return
11471 
 
11472 
 
11473 
  def __repr__(self):
11474 
    L = ['%s=%r' % (key, value)
11475 
      for key, value in self.__dict__.iteritems()]
11476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11477 
 
11478 
  def __eq__(self, other):
11479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11480 
 
11481 
  def __ne__(self, other):
11482 
    return not (self == other)
11483 
 
11484 
class deleteBannerMap_args:
11485 
  """
11486 
  Attributes:
11487 
   - bannerName
11488 
  """
11489 
 
11490 
  thrift_spec = (
11491 
    None, # 0
11492 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11493 
  )
11494 
 
11495 
  def __init__(self, bannerName=None,):
11496 
    self.bannerName = bannerName
11497 
 
11498 
  def read(self, iprot):
11499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11501 
      return
11502 
    iprot.readStructBegin()
11503 
    while True:
11504 
      (fname, ftype, fid) = iprot.readFieldBegin()
11505 
      if ftype == TType.STOP:
11506 
        break
11507 
      if fid == 1:
11508 
        if ftype == TType.STRING:
11509 
          self.bannerName = iprot.readString();
11510 
        else:
11511 
          iprot.skip(ftype)
11512 
      else:
11513 
        iprot.skip(ftype)
11514 
      iprot.readFieldEnd()
11515 
    iprot.readStructEnd()
11516 
 
11517 
  def write(self, oprot):
11518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11520 
      return
11521 
    oprot.writeStructBegin('deleteBannerMap_args')
11522 
    if self.bannerName is not None:
11523 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11524 
      oprot.writeString(self.bannerName)
11525 
      oprot.writeFieldEnd()
11526 
    oprot.writeFieldStop()
11527 
    oprot.writeStructEnd()
11528 
 
11529 
  def validate(self):
11530 
    return
11531 
 
11532 
 
11533 
  def __repr__(self):
11534 
    L = ['%s=%r' % (key, value)
11535 
      for key, value in self.__dict__.iteritems()]
11536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11537 
 
11538 
  def __eq__(self, other):
11539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11540 
 
11541 
  def __ne__(self, other):
11542 
    return not (self == other)
11543 
 
11544 
class deleteBannerMap_result:
11545 
  """
11546 
  Attributes:
11547 
   - success
11548 
  """
11549 
 
11550 
  thrift_spec = (
11551 
    (0, TType.BOOL, 'success', None, None, ), # 0
11552 
  )
11553 
 
11554 
  def __init__(self, success=None,):
11555 
    self.success = success
11556 
 
11557 
  def read(self, iprot):
11558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11560 
      return
11561 
    iprot.readStructBegin()
11562 
    while True:
11563 
      (fname, ftype, fid) = iprot.readFieldBegin()
11564 
      if ftype == TType.STOP:
11565 
        break
11566 
      if fid == 0:
11567 
        if ftype == TType.BOOL:
11568 
          self.success = iprot.readBool();
11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      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('deleteBannerMap_result')
11581 
    if self.success is not None:
11582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11583 
      oprot.writeBool(self.success)
11584 
      oprot.writeFieldEnd()
11585 
    oprot.writeFieldStop()
11586 
    oprot.writeStructEnd()
11587 
 
11588 
  def validate(self):
11589 
    return
11590 
 
11591 
 
11592 
  def __repr__(self):
11593 
    L = ['%s=%r' % (key, value)
11594 
      for key, value in self.__dict__.iteritems()]
11595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11596 
 
11597 
  def __eq__(self, other):
11598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11599 
 
11600 
  def __ne__(self, other):
11601 
    return not (self == other)
11602 
 
11603 
class getBannerMapDetails_args:
11604 
  """
11605 
  Attributes:
11606 
   - bannerName
11607 
  """
11608 
 
11609 
  thrift_spec = (
11610 
    None, # 0
11611 
    (1, TType.STRING, 'bannerName', None, None, ), # 1
11612 
  )
11613 
 
11614 
  def __init__(self, bannerName=None,):
11615 
    self.bannerName = bannerName
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 1:
11627 
        if ftype == TType.STRING:
11628 
          self.bannerName = iprot.readString();
11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      else:
11632 
        iprot.skip(ftype)
11633 
      iprot.readFieldEnd()
11634 
    iprot.readStructEnd()
11635 
 
11636 
  def write(self, oprot):
11637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11639 
      return
11640 
    oprot.writeStructBegin('getBannerMapDetails_args')
11641 
    if self.bannerName is not None:
11642 
      oprot.writeFieldBegin('bannerName', TType.STRING, 1)
11643 
      oprot.writeString(self.bannerName)
11644 
      oprot.writeFieldEnd()
11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
11648 
  def validate(self):
11649 
    return
11650 
 
11651 
 
11652 
  def __repr__(self):
11653 
    L = ['%s=%r' % (key, value)
11654 
      for key, value in self.__dict__.iteritems()]
11655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11656 
 
11657 
  def __eq__(self, other):
11658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11659 
 
11660 
  def __ne__(self, other):
11661 
    return not (self == other)
11662 
 
11663 
class getBannerMapDetails_result:
11664 
  """
11665 
  Attributes:
11666 
   - success
11667 
  """
11668 
 
11669 
  thrift_spec = (
11670 
    (0, TType.LIST, 'success', (TType.STRUCT,(BannerMap, BannerMap.thrift_spec)), None, ), # 0
11671 
  )
11672 
 
11673 
  def __init__(self, success=None,):
11674 
    self.success = success
11675 
 
11676 
  def read(self, iprot):
11677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11679 
      return
11680 
    iprot.readStructBegin()
11681 
    while True:
11682 
      (fname, ftype, fid) = iprot.readFieldBegin()
11683 
      if ftype == TType.STOP:
11684 
        break
11685 
      if fid == 0:
11686 
        if ftype == TType.LIST:
11687 
          self.success = []
7438 amit.gupta 11688 
          (_etype198, _size195) = iprot.readListBegin()
11689 
          for _i199 in xrange(_size195):
11690 
            _elem200 = BannerMap()
11691 
            _elem200.read(iprot)
11692 
            self.success.append(_elem200)
6849 kshitij.so 11693 
          iprot.readListEnd()
11694 
        else:
11695 
          iprot.skip(ftype)
11696 
      else:
11697 
        iprot.skip(ftype)
11698 
      iprot.readFieldEnd()
11699 
    iprot.readStructEnd()
11700 
 
11701 
  def write(self, oprot):
11702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11704 
      return
11705 
    oprot.writeStructBegin('getBannerMapDetails_result')
11706 
    if self.success is not None:
11707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 11709 
      for iter201 in self.success:
11710 
        iter201.write(oprot)
6849 kshitij.so 11711 
      oprot.writeListEnd()
11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
11716 
  def validate(self):
11717 
    return
11718 
 
11719 
 
11720 
  def __repr__(self):
11721 
    L = ['%s=%r' % (key, value)
11722 
      for key, value in self.__dict__.iteritems()]
11723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11724 
 
11725 
  def __eq__(self, other):
11726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11727 
 
11728 
  def __ne__(self, other):
11729 
    return not (self == other)
11730 
 
5944 mandeep.dh 11731 
class deleteSimilarItem_args:
11732 
  """
11733 
  Attributes:
11734 
   - itemId
11735 
   - catalogItemId
11736 
  """
11737 
 
11738 
  thrift_spec = (
11739 
    None, # 0
11740 
    (1, TType.I64, 'itemId', None, None, ), # 1
11741 
    (2, TType.I64, 'catalogItemId', None, None, ), # 2
11742 
  )
11743 
 
11744 
  def __init__(self, itemId=None, catalogItemId=None,):
11745 
    self.itemId = itemId
11746 
    self.catalogItemId = catalogItemId
11747 
 
11748 
  def read(self, iprot):
11749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11751 
      return
11752 
    iprot.readStructBegin()
11753 
    while True:
11754 
      (fname, ftype, fid) = iprot.readFieldBegin()
11755 
      if ftype == TType.STOP:
11756 
        break
11757 
      if fid == 1:
11758 
        if ftype == TType.I64:
11759 
          self.itemId = iprot.readI64();
11760 
        else:
11761 
          iprot.skip(ftype)
11762 
      elif fid == 2:
11763 
        if ftype == TType.I64:
11764 
          self.catalogItemId = iprot.readI64();
11765 
        else:
11766 
          iprot.skip(ftype)
11767 
      else:
11768 
        iprot.skip(ftype)
11769 
      iprot.readFieldEnd()
11770 
    iprot.readStructEnd()
11771 
 
11772 
  def write(self, oprot):
11773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11775 
      return
11776 
    oprot.writeStructBegin('deleteSimilarItem_args')
11777 
    if self.itemId is not None:
11778 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11779 
      oprot.writeI64(self.itemId)
11780 
      oprot.writeFieldEnd()
11781 
    if self.catalogItemId is not None:
11782 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 2)
11783 
      oprot.writeI64(self.catalogItemId)
11784 
      oprot.writeFieldEnd()
11785 
    oprot.writeFieldStop()
11786 
    oprot.writeStructEnd()
11787 
 
11788 
  def validate(self):
11789 
    return
11790 
 
11791 
 
11792 
  def __repr__(self):
11793 
    L = ['%s=%r' % (key, value)
11794 
      for key, value in self.__dict__.iteritems()]
11795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11796 
 
11797 
  def __eq__(self, other):
11798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11799 
 
11800 
  def __ne__(self, other):
11801 
    return not (self == other)
11802 
 
11803 
class deleteSimilarItem_result:
11804 
  """
11805 
  Attributes:
11806 
   - success
11807 
   - cex
11808 
  """
11809 
 
11810 
  thrift_spec = (
11811 
    (0, TType.BOOL, 'success', None, None, ), # 0
11812 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
11813 
  )
11814 
 
11815 
  def __init__(self, success=None, cex=None,):
11816 
    self.success = success
11817 
    self.cex = cex
11818 
 
11819 
  def read(self, iprot):
11820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11822 
      return
11823 
    iprot.readStructBegin()
11824 
    while True:
11825 
      (fname, ftype, fid) = iprot.readFieldBegin()
11826 
      if ftype == TType.STOP:
11827 
        break
11828 
      if fid == 0:
11829 
        if ftype == TType.BOOL:
11830 
          self.success = iprot.readBool();
11831 
        else:
11832 
          iprot.skip(ftype)
11833 
      elif fid == 1:
11834 
        if ftype == TType.STRUCT:
11835 
          self.cex = CatalogServiceException()
11836 
          self.cex.read(iprot)
11837 
        else:
11838 
          iprot.skip(ftype)
11839 
      else:
11840 
        iprot.skip(ftype)
11841 
      iprot.readFieldEnd()
11842 
    iprot.readStructEnd()
11843 
 
11844 
  def write(self, oprot):
11845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11847 
      return
11848 
    oprot.writeStructBegin('deleteSimilarItem_result')
11849 
    if self.success is not None:
11850 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11851 
      oprot.writeBool(self.success)
11852 
      oprot.writeFieldEnd()
11853 
    if self.cex is not None:
11854 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
11855 
      self.cex.write(oprot)
11856 
      oprot.writeFieldEnd()
11857 
    oprot.writeFieldStop()
11858 
    oprot.writeStructEnd()
11859 
 
11860 
  def validate(self):
11861 
    return
11862 
 
11863 
 
11864 
  def __repr__(self):
11865 
    L = ['%s=%r' % (key, value)
11866 
      for key, value in self.__dict__.iteritems()]
11867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11868 
 
11869 
  def __eq__(self, other):
11870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11871 
 
11872 
  def __ne__(self, other):
11873 
    return not (self == other)
11874 
 
11875 
class checkSimilarItem_args:
11876 
  """
11877 
  Attributes:
11878 
   - brand
11879 
   - modelNumber
11880 
   - modelName
11881 
   - color
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    None, # 0
11886 
    (1, TType.STRING, 'brand', None, None, ), # 1
11887 
    (2, TType.STRING, 'modelNumber', None, None, ), # 2
11888 
    (3, TType.STRING, 'modelName', None, None, ), # 3
11889 
    (4, TType.STRING, 'color', None, None, ), # 4
11890 
  )
11891 
 
11892 
  def __init__(self, brand=None, modelNumber=None, modelName=None, color=None,):
11893 
    self.brand = brand
11894 
    self.modelNumber = modelNumber
11895 
    self.modelName = modelName
11896 
    self.color = color
11897 
 
11898 
  def read(self, iprot):
11899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11901 
      return
11902 
    iprot.readStructBegin()
11903 
    while True:
11904 
      (fname, ftype, fid) = iprot.readFieldBegin()
11905 
      if ftype == TType.STOP:
11906 
        break
11907 
      if fid == 1:
11908 
        if ftype == TType.STRING:
11909 
          self.brand = iprot.readString();
11910 
        else:
11911 
          iprot.skip(ftype)
11912 
      elif fid == 2:
11913 
        if ftype == TType.STRING:
11914 
          self.modelNumber = iprot.readString();
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      elif fid == 3:
11918 
        if ftype == TType.STRING:
11919 
          self.modelName = iprot.readString();
11920 
        else:
11921 
          iprot.skip(ftype)
11922 
      elif fid == 4:
11923 
        if ftype == TType.STRING:
11924 
          self.color = iprot.readString();
11925 
        else:
11926 
          iprot.skip(ftype)
11927 
      else:
11928 
        iprot.skip(ftype)
11929 
      iprot.readFieldEnd()
11930 
    iprot.readStructEnd()
11931 
 
11932 
  def write(self, oprot):
11933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11935 
      return
11936 
    oprot.writeStructBegin('checkSimilarItem_args')
11937 
    if self.brand is not None:
11938 
      oprot.writeFieldBegin('brand', TType.STRING, 1)
11939 
      oprot.writeString(self.brand)
11940 
      oprot.writeFieldEnd()
11941 
    if self.modelNumber is not None:
11942 
      oprot.writeFieldBegin('modelNumber', TType.STRING, 2)
11943 
      oprot.writeString(self.modelNumber)
11944 
      oprot.writeFieldEnd()
11945 
    if self.modelName is not None:
11946 
      oprot.writeFieldBegin('modelName', TType.STRING, 3)
11947 
      oprot.writeString(self.modelName)
11948 
      oprot.writeFieldEnd()
11949 
    if self.color is not None:
11950 
      oprot.writeFieldBegin('color', TType.STRING, 4)
11951 
      oprot.writeString(self.color)
11952 
      oprot.writeFieldEnd()
11953 
    oprot.writeFieldStop()
11954 
    oprot.writeStructEnd()
11955 
 
11956 
  def validate(self):
11957 
    return
11958 
 
11959 
 
11960 
  def __repr__(self):
11961 
    L = ['%s=%r' % (key, value)
11962 
      for key, value in self.__dict__.iteritems()]
11963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11964 
 
11965 
  def __eq__(self, other):
11966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11967 
 
11968 
  def __ne__(self, other):
11969 
    return not (self == other)
11970 
 
11971 
class checkSimilarItem_result:
11972 
  """
11973 
  Attributes:
11974 
   - success
11975 
  """
11976 
 
11977 
  thrift_spec = (
11978 
    (0, TType.I64, 'success', None, None, ), # 0
11979 
  )
11980 
 
11981 
  def __init__(self, success=None,):
11982 
    self.success = success
11983 
 
11984 
  def read(self, iprot):
11985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11987 
      return
11988 
    iprot.readStructBegin()
11989 
    while True:
11990 
      (fname, ftype, fid) = iprot.readFieldBegin()
11991 
      if ftype == TType.STOP:
11992 
        break
11993 
      if fid == 0:
11994 
        if ftype == TType.I64:
11995 
          self.success = iprot.readI64();
11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      else:
11999 
        iprot.skip(ftype)
12000 
      iprot.readFieldEnd()
12001 
    iprot.readStructEnd()
12002 
 
12003 
  def write(self, oprot):
12004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12006 
      return
12007 
    oprot.writeStructBegin('checkSimilarItem_result')
12008 
    if self.success is not None:
12009 
      oprot.writeFieldBegin('success', TType.I64, 0)
12010 
      oprot.writeI64(self.success)
12011 
      oprot.writeFieldEnd()
12012 
    oprot.writeFieldStop()
12013 
    oprot.writeStructEnd()
12014 
 
12015 
  def validate(self):
12016 
    return
12017 
 
12018 
 
12019 
  def __repr__(self):
12020 
    L = ['%s=%r' % (key, value)
12021 
      for key, value in self.__dict__.iteritems()]
12022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12023 
 
12024 
  def __eq__(self, other):
12025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12026 
 
12027 
  def __ne__(self, other):
12028 
    return not (self == other)
12029 
 
12030 
class validateRiskyStatus_args:
12031 
  """
12032 
  Attributes:
12033 
   - itemId
12034 
  """
12035 
 
12036 
  thrift_spec = (
12037 
    None, # 0
12038 
    (1, TType.I64, 'itemId', None, None, ), # 1
12039 
  )
12040 
 
12041 
  def __init__(self, itemId=None,):
12042 
    self.itemId = itemId
12043 
 
12044 
  def read(self, iprot):
12045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12047 
      return
12048 
    iprot.readStructBegin()
12049 
    while True:
12050 
      (fname, ftype, fid) = iprot.readFieldBegin()
12051 
      if ftype == TType.STOP:
12052 
        break
12053 
      if fid == 1:
12054 
        if ftype == TType.I64:
12055 
          self.itemId = iprot.readI64();
12056 
        else:
12057 
          iprot.skip(ftype)
12058 
      else:
12059 
        iprot.skip(ftype)
12060 
      iprot.readFieldEnd()
12061 
    iprot.readStructEnd()
12062 
 
12063 
  def write(self, oprot):
12064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12066 
      return
12067 
    oprot.writeStructBegin('validateRiskyStatus_args')
12068 
    if self.itemId is not None:
12069 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12070 
      oprot.writeI64(self.itemId)
12071 
      oprot.writeFieldEnd()
12072 
    oprot.writeFieldStop()
12073 
    oprot.writeStructEnd()
12074 
 
12075 
  def validate(self):
12076 
    return
12077 
 
12078 
 
12079 
  def __repr__(self):
12080 
    L = ['%s=%r' % (key, value)
12081 
      for key, value in self.__dict__.iteritems()]
12082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12083 
 
12084 
  def __eq__(self, other):
12085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12086 
 
12087 
  def __ne__(self, other):
12088 
    return not (self == other)
12089 
 
12090 
class validateRiskyStatus_result:
12091 
 
12092 
  thrift_spec = (
12093 
  )
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      else:
12105 
        iprot.skip(ftype)
12106 
      iprot.readFieldEnd()
12107 
    iprot.readStructEnd()
12108 
 
12109 
  def write(self, oprot):
12110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12112 
      return
12113 
    oprot.writeStructBegin('validateRiskyStatus_result')
12114 
    oprot.writeFieldStop()
12115 
    oprot.writeStructEnd()
12116 
 
12117 
  def validate(self):
12118 
    return
12119 
 
12120 
 
12121 
  def __repr__(self):
12122 
    L = ['%s=%r' % (key, value)
12123 
      for key, value in self.__dict__.iteritems()]
12124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12125 
 
12126 
  def __eq__(self, other):
12127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12128 
 
12129 
  def __ne__(self, other):
12130 
    return not (self == other)
12131 
 
12132 
class changeItemRiskyFlag_args:
12133 
  """
12134 
  Attributes:
12135 
   - itemId
12136 
   - risky
12137 
  """
12138 
 
12139 
  thrift_spec = (
12140 
    None, # 0
12141 
    (1, TType.I64, 'itemId', None, None, ), # 1
12142 
    (2, TType.BOOL, 'risky', None, None, ), # 2
12143 
  )
12144 
 
12145 
  def __init__(self, itemId=None, risky=None,):
12146 
    self.itemId = itemId
12147 
    self.risky = risky
12148 
 
12149 
  def read(self, iprot):
12150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12152 
      return
12153 
    iprot.readStructBegin()
12154 
    while True:
12155 
      (fname, ftype, fid) = iprot.readFieldBegin()
12156 
      if ftype == TType.STOP:
12157 
        break
12158 
      if fid == 1:
12159 
        if ftype == TType.I64:
12160 
          self.itemId = iprot.readI64();
12161 
        else:
12162 
          iprot.skip(ftype)
12163 
      elif fid == 2:
12164 
        if ftype == TType.BOOL:
12165 
          self.risky = iprot.readBool();
12166 
        else:
12167 
          iprot.skip(ftype)
12168 
      else:
12169 
        iprot.skip(ftype)
12170 
      iprot.readFieldEnd()
12171 
    iprot.readStructEnd()
12172 
 
12173 
  def write(self, oprot):
12174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12176 
      return
12177 
    oprot.writeStructBegin('changeItemRiskyFlag_args')
12178 
    if self.itemId is not None:
12179 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12180 
      oprot.writeI64(self.itemId)
12181 
      oprot.writeFieldEnd()
12182 
    if self.risky is not None:
12183 
      oprot.writeFieldBegin('risky', TType.BOOL, 2)
12184 
      oprot.writeBool(self.risky)
12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
12204 
class changeItemRiskyFlag_result:
12205 
 
12206 
  thrift_spec = (
12207 
  )
12208 
 
12209 
  def read(self, iprot):
12210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12212 
      return
12213 
    iprot.readStructBegin()
12214 
    while True:
12215 
      (fname, ftype, fid) = iprot.readFieldBegin()
12216 
      if ftype == TType.STOP:
12217 
        break
12218 
      else:
12219 
        iprot.skip(ftype)
12220 
      iprot.readFieldEnd()
12221 
    iprot.readStructEnd()
12222 
 
12223 
  def write(self, oprot):
12224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12226 
      return
12227 
    oprot.writeStructBegin('changeItemRiskyFlag_result')
12228 
    oprot.writeFieldStop()
12229 
    oprot.writeStructEnd()
12230 
 
12231 
  def validate(self):
12232 
    return
12233 
 
12234 
 
12235 
  def __repr__(self):
12236 
    L = ['%s=%r' % (key, value)
12237 
      for key, value in self.__dict__.iteritems()]
12238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12239 
 
12240 
  def __eq__(self, other):
12241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12242 
 
12243 
  def __ne__(self, other):
12244 
    return not (self == other)
12245 
 
12246 
class getItemsByRiskyFlag_args:
12247 
 
12248 
  thrift_spec = (
12249 
  )
12250 
 
12251 
  def read(self, iprot):
12252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12254 
      return
12255 
    iprot.readStructBegin()
12256 
    while True:
12257 
      (fname, ftype, fid) = iprot.readFieldBegin()
12258 
      if ftype == TType.STOP:
12259 
        break
12260 
      else:
12261 
        iprot.skip(ftype)
12262 
      iprot.readFieldEnd()
12263 
    iprot.readStructEnd()
12264 
 
12265 
  def write(self, oprot):
12266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12268 
      return
12269 
    oprot.writeStructBegin('getItemsByRiskyFlag_args')
12270 
    oprot.writeFieldStop()
12271 
    oprot.writeStructEnd()
12272 
 
12273 
  def validate(self):
12274 
    return
12275 
 
12276 
 
12277 
  def __repr__(self):
12278 
    L = ['%s=%r' % (key, value)
12279 
      for key, value in self.__dict__.iteritems()]
12280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12281 
 
12282 
  def __eq__(self, other):
12283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12284 
 
12285 
  def __ne__(self, other):
12286 
    return not (self == other)
12287 
 
12288 
class getItemsByRiskyFlag_result:
12289 
  """
12290 
  Attributes:
12291 
   - success
12292 
  """
12293 
 
12294 
  thrift_spec = (
12295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12296 
  )
12297 
 
12298 
  def __init__(self, success=None,):
12299 
    self.success = success
12300 
 
12301 
  def read(self, iprot):
12302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12304 
      return
12305 
    iprot.readStructBegin()
12306 
    while True:
12307 
      (fname, ftype, fid) = iprot.readFieldBegin()
12308 
      if ftype == TType.STOP:
12309 
        break
12310 
      if fid == 0:
12311 
        if ftype == TType.LIST:
12312 
          self.success = []
7438 amit.gupta 12313 
          (_etype205, _size202) = iprot.readListBegin()
12314 
          for _i206 in xrange(_size202):
12315 
            _elem207 = Item()
12316 
            _elem207.read(iprot)
12317 
            self.success.append(_elem207)
5944 mandeep.dh 12318 
          iprot.readListEnd()
12319 
        else:
12320 
          iprot.skip(ftype)
12321 
      else:
12322 
        iprot.skip(ftype)
12323 
      iprot.readFieldEnd()
12324 
    iprot.readStructEnd()
12325 
 
12326 
  def write(self, oprot):
12327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12329 
      return
12330 
    oprot.writeStructBegin('getItemsByRiskyFlag_result')
12331 
    if self.success is not None:
12332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12334 
      for iter208 in self.success:
12335 
        iter208.write(oprot)
5944 mandeep.dh 12336 
      oprot.writeListEnd()
12337 
      oprot.writeFieldEnd()
12338 
    oprot.writeFieldStop()
12339 
    oprot.writeStructEnd()
12340 
 
12341 
  def validate(self):
12342 
    return
12343 
 
12344 
 
12345 
  def __repr__(self):
12346 
    L = ['%s=%r' % (key, value)
12347 
      for key, value in self.__dict__.iteritems()]
12348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12349 
 
12350 
  def __eq__(self, other):
12351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12352 
 
12353 
  def __ne__(self, other):
12354 
    return not (self == other)
12355 
 
12356 
class getItemsForMasterSheet_args:
12357 
  """
12358 
  Attributes:
12359 
   - category
12360 
   - brand
12361 
  """
12362 
 
12363 
  thrift_spec = (
12364 
    None, # 0
12365 
    (1, TType.STRING, 'category', None, None, ), # 1
12366 
    (2, TType.STRING, 'brand', None, None, ), # 2
12367 
  )
12368 
 
12369 
  def __init__(self, category=None, brand=None,):
12370 
    self.category = category
12371 
    self.brand = brand
12372 
 
12373 
  def read(self, iprot):
12374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12376 
      return
12377 
    iprot.readStructBegin()
12378 
    while True:
12379 
      (fname, ftype, fid) = iprot.readFieldBegin()
12380 
      if ftype == TType.STOP:
12381 
        break
12382 
      if fid == 1:
12383 
        if ftype == TType.STRING:
12384 
          self.category = iprot.readString();
12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      elif fid == 2:
12388 
        if ftype == TType.STRING:
12389 
          self.brand = iprot.readString();
12390 
        else:
12391 
          iprot.skip(ftype)
12392 
      else:
12393 
        iprot.skip(ftype)
12394 
      iprot.readFieldEnd()
12395 
    iprot.readStructEnd()
12396 
 
12397 
  def write(self, oprot):
12398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12400 
      return
12401 
    oprot.writeStructBegin('getItemsForMasterSheet_args')
12402 
    if self.category is not None:
12403 
      oprot.writeFieldBegin('category', TType.STRING, 1)
12404 
      oprot.writeString(self.category)
12405 
      oprot.writeFieldEnd()
12406 
    if self.brand is not None:
12407 
      oprot.writeFieldBegin('brand', TType.STRING, 2)
12408 
      oprot.writeString(self.brand)
12409 
      oprot.writeFieldEnd()
12410 
    oprot.writeFieldStop()
12411 
    oprot.writeStructEnd()
12412 
 
12413 
  def validate(self):
12414 
    return
12415 
 
12416 
 
12417 
  def __repr__(self):
12418 
    L = ['%s=%r' % (key, value)
12419 
      for key, value in self.__dict__.iteritems()]
12420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12421 
 
12422 
  def __eq__(self, other):
12423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12424 
 
12425 
  def __ne__(self, other):
12426 
    return not (self == other)
12427 
 
12428 
class getItemsForMasterSheet_result:
12429 
  """
12430 
  Attributes:
12431 
   - success
12432 
  """
12433 
 
12434 
  thrift_spec = (
12435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
12436 
  )
12437 
 
12438 
  def __init__(self, success=None,):
12439 
    self.success = success
12440 
 
12441 
  def read(self, iprot):
12442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12444 
      return
12445 
    iprot.readStructBegin()
12446 
    while True:
12447 
      (fname, ftype, fid) = iprot.readFieldBegin()
12448 
      if ftype == TType.STOP:
12449 
        break
12450 
      if fid == 0:
12451 
        if ftype == TType.LIST:
12452 
          self.success = []
7438 amit.gupta 12453 
          (_etype212, _size209) = iprot.readListBegin()
12454 
          for _i213 in xrange(_size209):
12455 
            _elem214 = Item()
12456 
            _elem214.read(iprot)
12457 
            self.success.append(_elem214)
5944 mandeep.dh 12458 
          iprot.readListEnd()
12459 
        else:
12460 
          iprot.skip(ftype)
12461 
      else:
12462 
        iprot.skip(ftype)
12463 
      iprot.readFieldEnd()
12464 
    iprot.readStructEnd()
12465 
 
12466 
  def write(self, oprot):
12467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12469 
      return
12470 
    oprot.writeStructBegin('getItemsForMasterSheet_result')
12471 
    if self.success is not None:
12472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 12474 
      for iter215 in self.success:
12475 
        iter215.write(oprot)
5944 mandeep.dh 12476 
      oprot.writeListEnd()
12477 
      oprot.writeFieldEnd()
12478 
    oprot.writeFieldStop()
12479 
    oprot.writeStructEnd()
12480 
 
12481 
  def validate(self):
12482 
    return
12483 
 
12484 
 
12485 
  def __repr__(self):
12486 
    L = ['%s=%r' % (key, value)
12487 
      for key, value in self.__dict__.iteritems()]
12488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12489 
 
12490 
  def __eq__(self, other):
12491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12492 
 
12493 
  def __ne__(self, other):
12494 
    return not (self == other)
12495 
 
12496 
class getSimilarItemsCatalogIds_args:
12497 
  """
12498 
  Attributes:
12499 
   - beginIndex
12500 
   - totalItems
12501 
   - itemId
12502 
  """
12503 
 
12504 
  thrift_spec = (
12505 
    None, # 0
12506 
    (1, TType.I64, 'beginIndex', None, None, ), # 1
12507 
    (2, TType.I64, 'totalItems', None, None, ), # 2
12508 
    (3, TType.I64, 'itemId', None, None, ), # 3
12509 
  )
12510 
 
12511 
  def __init__(self, beginIndex=None, totalItems=None, itemId=None,):
12512 
    self.beginIndex = beginIndex
12513 
    self.totalItems = totalItems
12514 
    self.itemId = itemId
12515 
 
12516 
  def read(self, iprot):
12517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12519 
      return
12520 
    iprot.readStructBegin()
12521 
    while True:
12522 
      (fname, ftype, fid) = iprot.readFieldBegin()
12523 
      if ftype == TType.STOP:
12524 
        break
12525 
      if fid == 1:
12526 
        if ftype == TType.I64:
12527 
          self.beginIndex = iprot.readI64();
12528 
        else:
12529 
          iprot.skip(ftype)
12530 
      elif fid == 2:
12531 
        if ftype == TType.I64:
12532 
          self.totalItems = iprot.readI64();
12533 
        else:
12534 
          iprot.skip(ftype)
12535 
      elif fid == 3:
12536 
        if ftype == TType.I64:
12537 
          self.itemId = iprot.readI64();
12538 
        else:
12539 
          iprot.skip(ftype)
12540 
      else:
12541 
        iprot.skip(ftype)
12542 
      iprot.readFieldEnd()
12543 
    iprot.readStructEnd()
12544 
 
12545 
  def write(self, oprot):
12546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12548 
      return
12549 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_args')
12550 
    if self.beginIndex is not None:
12551 
      oprot.writeFieldBegin('beginIndex', TType.I64, 1)
12552 
      oprot.writeI64(self.beginIndex)
12553 
      oprot.writeFieldEnd()
12554 
    if self.totalItems is not None:
12555 
      oprot.writeFieldBegin('totalItems', TType.I64, 2)
12556 
      oprot.writeI64(self.totalItems)
12557 
      oprot.writeFieldEnd()
12558 
    if self.itemId is not None:
12559 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
12560 
      oprot.writeI64(self.itemId)
12561 
      oprot.writeFieldEnd()
12562 
    oprot.writeFieldStop()
12563 
    oprot.writeStructEnd()
12564 
 
12565 
  def validate(self):
12566 
    return
12567 
 
12568 
 
12569 
  def __repr__(self):
12570 
    L = ['%s=%r' % (key, value)
12571 
      for key, value in self.__dict__.iteritems()]
12572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12573 
 
12574 
  def __eq__(self, other):
12575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12576 
 
12577 
  def __ne__(self, other):
12578 
    return not (self == other)
12579 
 
12580 
class getSimilarItemsCatalogIds_result:
12581 
  """
12582 
  Attributes:
12583 
   - success
12584 
  """
12585 
 
12586 
  thrift_spec = (
12587 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12588 
  )
12589 
 
12590 
  def __init__(self, success=None,):
12591 
    self.success = success
12592 
 
12593 
  def read(self, iprot):
12594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12596 
      return
12597 
    iprot.readStructBegin()
12598 
    while True:
12599 
      (fname, ftype, fid) = iprot.readFieldBegin()
12600 
      if ftype == TType.STOP:
12601 
        break
12602 
      if fid == 0:
12603 
        if ftype == TType.LIST:
12604 
          self.success = []
7438 amit.gupta 12605 
          (_etype219, _size216) = iprot.readListBegin()
12606 
          for _i220 in xrange(_size216):
12607 
            _elem221 = iprot.readI64();
12608 
            self.success.append(_elem221)
5944 mandeep.dh 12609 
          iprot.readListEnd()
12610 
        else:
12611 
          iprot.skip(ftype)
12612 
      else:
12613 
        iprot.skip(ftype)
12614 
      iprot.readFieldEnd()
12615 
    iprot.readStructEnd()
12616 
 
12617 
  def write(self, oprot):
12618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12620 
      return
12621 
    oprot.writeStructBegin('getSimilarItemsCatalogIds_result')
12622 
    if self.success is not None:
12623 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12624 
      oprot.writeListBegin(TType.I64, len(self.success))
7438 amit.gupta 12625 
      for iter222 in self.success:
12626 
        oprot.writeI64(iter222)
5944 mandeep.dh 12627 
      oprot.writeListEnd()
12628 
      oprot.writeFieldEnd()
12629 
    oprot.writeFieldStop()
12630 
    oprot.writeStructEnd()
12631 
 
12632 
  def validate(self):
12633 
    return
12634 
 
12635 
 
12636 
  def __repr__(self):
12637 
    L = ['%s=%r' % (key, value)
12638 
      for key, value in self.__dict__.iteritems()]
12639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12640 
 
12641 
  def __eq__(self, other):
12642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12643 
 
12644 
  def __ne__(self, other):
12645 
    return not (self == other)
12646 
 
12647 
class addProductNotification_args:
12648 
  """
12649 
  Attributes:
12650 
   - itemId
12651 
   - email
12652 
  """
12653 
 
12654 
  thrift_spec = None
12655 
  def __init__(self, itemId=None, email=None,):
12656 
    self.itemId = itemId
12657 
    self.email = email
12658 
 
12659 
  def read(self, iprot):
12660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12662 
      return
12663 
    iprot.readStructBegin()
12664 
    while True:
12665 
      (fname, ftype, fid) = iprot.readFieldBegin()
12666 
      if ftype == TType.STOP:
12667 
        break
12668 
      if fid == -1:
12669 
        if ftype == TType.I64:
12670 
          self.itemId = iprot.readI64();
12671 
        else:
12672 
          iprot.skip(ftype)
12673 
      elif fid == -2:
12674 
        if ftype == TType.STRING:
12675 
          self.email = iprot.readString();
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      else:
12679 
        iprot.skip(ftype)
12680 
      iprot.readFieldEnd()
12681 
    iprot.readStructEnd()
12682 
 
12683 
  def write(self, oprot):
12684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12686 
      return
12687 
    oprot.writeStructBegin('addProductNotification_args')
12688 
    if self.email is not None:
12689 
      oprot.writeFieldBegin('email', TType.STRING, -2)
12690 
      oprot.writeString(self.email)
12691 
      oprot.writeFieldEnd()
12692 
    if self.itemId is not None:
12693 
      oprot.writeFieldBegin('itemId', TType.I64, -1)
12694 
      oprot.writeI64(self.itemId)
12695 
      oprot.writeFieldEnd()
12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
12699 
  def validate(self):
12700 
    return
12701 
 
12702 
 
12703 
  def __repr__(self):
12704 
    L = ['%s=%r' % (key, value)
12705 
      for key, value in self.__dict__.iteritems()]
12706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12707 
 
12708 
  def __eq__(self, other):
12709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12710 
 
12711 
  def __ne__(self, other):
12712 
    return not (self == other)
12713 
 
12714 
class addProductNotification_result:
12715 
  """
12716 
  Attributes:
12717 
   - success
12718 
  """
12719 
 
12720 
  thrift_spec = (
12721 
    (0, TType.BOOL, 'success', None, None, ), # 0
12722 
  )
12723 
 
12724 
  def __init__(self, success=None,):
12725 
    self.success = success
12726 
 
12727 
  def read(self, iprot):
12728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12730 
      return
12731 
    iprot.readStructBegin()
12732 
    while True:
12733 
      (fname, ftype, fid) = iprot.readFieldBegin()
12734 
      if ftype == TType.STOP:
12735 
        break
12736 
      if fid == 0:
12737 
        if ftype == TType.BOOL:
12738 
          self.success = iprot.readBool();
12739 
        else:
12740 
          iprot.skip(ftype)
12741 
      else:
12742 
        iprot.skip(ftype)
12743 
      iprot.readFieldEnd()
12744 
    iprot.readStructEnd()
12745 
 
12746 
  def write(self, oprot):
12747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12749 
      return
12750 
    oprot.writeStructBegin('addProductNotification_result')
12751 
    if self.success is not None:
12752 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12753 
      oprot.writeBool(self.success)
12754 
      oprot.writeFieldEnd()
12755 
    oprot.writeFieldStop()
12756 
    oprot.writeStructEnd()
12757 
 
12758 
  def validate(self):
12759 
    return
12760 
 
12761 
 
12762 
  def __repr__(self):
12763 
    L = ['%s=%r' % (key, value)
12764 
      for key, value in self.__dict__.iteritems()]
12765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12766 
 
12767 
  def __eq__(self, other):
12768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12769 
 
12770 
  def __ne__(self, other):
12771 
    return not (self == other)
12772 
 
12773 
class sendProductNotifications_args:
12774 
 
12775 
  thrift_spec = (
12776 
  )
12777 
 
12778 
  def read(self, iprot):
12779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12781 
      return
12782 
    iprot.readStructBegin()
12783 
    while True:
12784 
      (fname, ftype, fid) = iprot.readFieldBegin()
12785 
      if ftype == TType.STOP:
12786 
        break
12787 
      else:
12788 
        iprot.skip(ftype)
12789 
      iprot.readFieldEnd()
12790 
    iprot.readStructEnd()
12791 
 
12792 
  def write(self, oprot):
12793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12795 
      return
12796 
    oprot.writeStructBegin('sendProductNotifications_args')
12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
12815 
class sendProductNotifications_result:
12816 
  """
12817 
  Attributes:
12818 
   - success
12819 
  """
12820 
 
12821 
  thrift_spec = (
12822 
    (0, TType.BOOL, 'success', None, None, ), # 0
12823 
  )
12824 
 
12825 
  def __init__(self, success=None,):
12826 
    self.success = success
12827 
 
12828 
  def read(self, iprot):
12829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12831 
      return
12832 
    iprot.readStructBegin()
12833 
    while True:
12834 
      (fname, ftype, fid) = iprot.readFieldBegin()
12835 
      if ftype == TType.STOP:
12836 
        break
12837 
      if fid == 0:
12838 
        if ftype == TType.BOOL:
12839 
          self.success = iprot.readBool();
12840 
        else:
12841 
          iprot.skip(ftype)
12842 
      else:
12843 
        iprot.skip(ftype)
12844 
      iprot.readFieldEnd()
12845 
    iprot.readStructEnd()
12846 
 
12847 
  def write(self, oprot):
12848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12850 
      return
12851 
    oprot.writeStructBegin('sendProductNotifications_result')
12852 
    if self.success is not None:
12853 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12854 
      oprot.writeBool(self.success)
12855 
      oprot.writeFieldEnd()
12856 
    oprot.writeFieldStop()
12857 
    oprot.writeStructEnd()
12858 
 
12859 
  def validate(self):
12860 
    return
12861 
 
12862 
 
12863 
  def __repr__(self):
12864 
    L = ['%s=%r' % (key, value)
12865 
      for key, value in self.__dict__.iteritems()]
12866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12867 
 
12868 
  def __eq__(self, other):
12869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12870 
 
12871 
  def __ne__(self, other):
12872 
    return not (self == other)
12873 
 
12874 
class getAllBrandsByCategory_args:
12875 
  """
12876 
  Attributes:
12877 
   - categoryId
12878 
  """
12879 
 
12880 
  thrift_spec = (
12881 
    None, # 0
12882 
    (1, TType.I64, 'categoryId', None, None, ), # 1
12883 
  )
12884 
 
12885 
  def __init__(self, categoryId=None,):
12886 
    self.categoryId = categoryId
12887 
 
12888 
  def read(self, iprot):
12889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12891 
      return
12892 
    iprot.readStructBegin()
12893 
    while True:
12894 
      (fname, ftype, fid) = iprot.readFieldBegin()
12895 
      if ftype == TType.STOP:
12896 
        break
12897 
      if fid == 1:
12898 
        if ftype == TType.I64:
12899 
          self.categoryId = iprot.readI64();
12900 
        else:
12901 
          iprot.skip(ftype)
12902 
      else:
12903 
        iprot.skip(ftype)
12904 
      iprot.readFieldEnd()
12905 
    iprot.readStructEnd()
12906 
 
12907 
  def write(self, oprot):
12908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12910 
      return
12911 
    oprot.writeStructBegin('getAllBrandsByCategory_args')
12912 
    if self.categoryId is not None:
12913 
      oprot.writeFieldBegin('categoryId', TType.I64, 1)
12914 
      oprot.writeI64(self.categoryId)
12915 
      oprot.writeFieldEnd()
12916 
    oprot.writeFieldStop()
12917 
    oprot.writeStructEnd()
12918 
 
12919 
  def validate(self):
12920 
    return
12921 
 
12922 
 
12923 
  def __repr__(self):
12924 
    L = ['%s=%r' % (key, value)
12925 
      for key, value in self.__dict__.iteritems()]
12926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12927 
 
12928 
  def __eq__(self, other):
12929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12930 
 
12931 
  def __ne__(self, other):
12932 
    return not (self == other)
12933 
 
12934 
class getAllBrandsByCategory_result:
12935 
  """
12936 
  Attributes:
12937 
   - success
12938 
  """
12939 
 
12940 
  thrift_spec = (
12941 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12942 
  )
12943 
 
12944 
  def __init__(self, success=None,):
12945 
    self.success = success
12946 
 
12947 
  def read(self, iprot):
12948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12950 
      return
12951 
    iprot.readStructBegin()
12952 
    while True:
12953 
      (fname, ftype, fid) = iprot.readFieldBegin()
12954 
      if ftype == TType.STOP:
12955 
        break
12956 
      if fid == 0:
12957 
        if ftype == TType.LIST:
12958 
          self.success = []
7438 amit.gupta 12959 
          (_etype226, _size223) = iprot.readListBegin()
12960 
          for _i227 in xrange(_size223):
12961 
            _elem228 = iprot.readString();
12962 
            self.success.append(_elem228)
5944 mandeep.dh 12963 
          iprot.readListEnd()
12964 
        else:
12965 
          iprot.skip(ftype)
12966 
      else:
12967 
        iprot.skip(ftype)
12968 
      iprot.readFieldEnd()
12969 
    iprot.readStructEnd()
12970 
 
12971 
  def write(self, oprot):
12972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12974 
      return
12975 
    oprot.writeStructBegin('getAllBrandsByCategory_result')
12976 
    if self.success is not None:
12977 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12978 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 12979 
      for iter229 in self.success:
12980 
        oprot.writeString(iter229)
5944 mandeep.dh 12981 
      oprot.writeListEnd()
12982 
      oprot.writeFieldEnd()
12983 
    oprot.writeFieldStop()
12984 
    oprot.writeStructEnd()
12985 
 
12986 
  def validate(self):
12987 
    return
12988 
 
12989 
 
12990 
  def __repr__(self):
12991 
    L = ['%s=%r' % (key, value)
12992 
      for key, value in self.__dict__.iteritems()]
12993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12994 
 
12995 
  def __eq__(self, other):
12996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12997 
 
12998 
  def __ne__(self, other):
12999 
    return not (self == other)
13000 
 
13001 
class getAllBrands_args:
13002 
 
13003 
  thrift_spec = (
13004 
  )
13005 
 
13006 
  def read(self, iprot):
13007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13009 
      return
13010 
    iprot.readStructBegin()
13011 
    while True:
13012 
      (fname, ftype, fid) = iprot.readFieldBegin()
13013 
      if ftype == TType.STOP:
13014 
        break
13015 
      else:
13016 
        iprot.skip(ftype)
13017 
      iprot.readFieldEnd()
13018 
    iprot.readStructEnd()
13019 
 
13020 
  def write(self, oprot):
13021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13023 
      return
13024 
    oprot.writeStructBegin('getAllBrands_args')
13025 
    oprot.writeFieldStop()
13026 
    oprot.writeStructEnd()
13027 
 
13028 
  def validate(self):
13029 
    return
13030 
 
13031 
 
13032 
  def __repr__(self):
13033 
    L = ['%s=%r' % (key, value)
13034 
      for key, value in self.__dict__.iteritems()]
13035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13036 
 
13037 
  def __eq__(self, other):
13038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13039 
 
13040 
  def __ne__(self, other):
13041 
    return not (self == other)
13042 
 
13043 
class getAllBrands_result:
13044 
  """
13045 
  Attributes:
13046 
   - success
13047 
  """
13048 
 
13049 
  thrift_spec = (
13050 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
13051 
  )
13052 
 
13053 
  def __init__(self, success=None,):
13054 
    self.success = success
13055 
 
13056 
  def read(self, iprot):
13057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13059 
      return
13060 
    iprot.readStructBegin()
13061 
    while True:
13062 
      (fname, ftype, fid) = iprot.readFieldBegin()
13063 
      if ftype == TType.STOP:
13064 
        break
13065 
      if fid == 0:
13066 
        if ftype == TType.LIST:
13067 
          self.success = []
7438 amit.gupta 13068 
          (_etype233, _size230) = iprot.readListBegin()
13069 
          for _i234 in xrange(_size230):
13070 
            _elem235 = iprot.readString();
13071 
            self.success.append(_elem235)
5944 mandeep.dh 13072 
          iprot.readListEnd()
13073 
        else:
13074 
          iprot.skip(ftype)
13075 
      else:
13076 
        iprot.skip(ftype)
13077 
      iprot.readFieldEnd()
13078 
    iprot.readStructEnd()
13079 
 
13080 
  def write(self, oprot):
13081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13083 
      return
13084 
    oprot.writeStructBegin('getAllBrands_result')
13085 
    if self.success is not None:
13086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13087 
      oprot.writeListBegin(TType.STRING, len(self.success))
7438 amit.gupta 13088 
      for iter236 in self.success:
13089 
        oprot.writeString(iter236)
5944 mandeep.dh 13090 
      oprot.writeListEnd()
13091 
      oprot.writeFieldEnd()
13092 
    oprot.writeFieldStop()
13093 
    oprot.writeStructEnd()
13094 
 
13095 
  def validate(self):
13096 
    return
13097 
 
13098 
 
13099 
  def __repr__(self):
13100 
    L = ['%s=%r' % (key, value)
13101 
      for key, value in self.__dict__.iteritems()]
13102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13103 
 
13104 
  def __eq__(self, other):
13105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13106 
 
13107 
  def __ne__(self, other):
13108 
    return not (self == other)
13109 
 
13110 
class getAllSources_args:
13111 
 
13112 
  thrift_spec = (
13113 
  )
13114 
 
13115 
  def read(self, iprot):
13116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13118 
      return
13119 
    iprot.readStructBegin()
13120 
    while True:
13121 
      (fname, ftype, fid) = iprot.readFieldBegin()
13122 
      if ftype == TType.STOP:
13123 
        break
13124 
      else:
13125 
        iprot.skip(ftype)
13126 
      iprot.readFieldEnd()
13127 
    iprot.readStructEnd()
13128 
 
13129 
  def write(self, oprot):
13130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13132 
      return
13133 
    oprot.writeStructBegin('getAllSources_args')
13134 
    oprot.writeFieldStop()
13135 
    oprot.writeStructEnd()
13136 
 
13137 
  def validate(self):
13138 
    return
13139 
 
13140 
 
13141 
  def __repr__(self):
13142 
    L = ['%s=%r' % (key, value)
13143 
      for key, value in self.__dict__.iteritems()]
13144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13145 
 
13146 
  def __eq__(self, other):
13147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13148 
 
13149 
  def __ne__(self, other):
13150 
    return not (self == other)
13151 
 
13152 
class getAllSources_result:
13153 
  """
13154 
  Attributes:
13155 
   - success
13156 
  """
13157 
 
13158 
  thrift_spec = (
13159 
    (0, TType.LIST, 'success', (TType.STRUCT,(Source, Source.thrift_spec)), None, ), # 0
13160 
  )
13161 
 
13162 
  def __init__(self, success=None,):
13163 
    self.success = success
13164 
 
13165 
  def read(self, iprot):
13166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13168 
      return
13169 
    iprot.readStructBegin()
13170 
    while True:
13171 
      (fname, ftype, fid) = iprot.readFieldBegin()
13172 
      if ftype == TType.STOP:
13173 
        break
13174 
      if fid == 0:
13175 
        if ftype == TType.LIST:
13176 
          self.success = []
7438 amit.gupta 13177 
          (_etype240, _size237) = iprot.readListBegin()
13178 
          for _i241 in xrange(_size237):
13179 
            _elem242 = Source()
13180 
            _elem242.read(iprot)
13181 
            self.success.append(_elem242)
5944 mandeep.dh 13182 
          iprot.readListEnd()
13183 
        else:
13184 
          iprot.skip(ftype)
13185 
      else:
13186 
        iprot.skip(ftype)
13187 
      iprot.readFieldEnd()
13188 
    iprot.readStructEnd()
13189 
 
13190 
  def write(self, oprot):
13191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13193 
      return
13194 
    oprot.writeStructBegin('getAllSources_result')
13195 
    if self.success is not None:
13196 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13197 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13198 
      for iter243 in self.success:
13199 
        iter243.write(oprot)
5944 mandeep.dh 13200 
      oprot.writeListEnd()
13201 
      oprot.writeFieldEnd()
13202 
    oprot.writeFieldStop()
13203 
    oprot.writeStructEnd()
13204 
 
13205 
  def validate(self):
13206 
    return
13207 
 
13208 
 
13209 
  def __repr__(self):
13210 
    L = ['%s=%r' % (key, value)
13211 
      for key, value in self.__dict__.iteritems()]
13212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13213 
 
13214 
  def __eq__(self, other):
13215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13216 
 
13217 
  def __ne__(self, other):
13218 
    return not (self == other)
13219 
 
13220 
class getItemPricingBySource_args:
13221 
  """
13222 
  Attributes:
13223 
   - itemId
13224 
   - sourceId
13225 
  """
13226 
 
13227 
  thrift_spec = (
13228 
    None, # 0
13229 
    (1, TType.I64, 'itemId', None, None, ), # 1
13230 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13231 
  )
13232 
 
13233 
  def __init__(self, itemId=None, sourceId=None,):
13234 
    self.itemId = itemId
13235 
    self.sourceId = sourceId
13236 
 
13237 
  def read(self, iprot):
13238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13240 
      return
13241 
    iprot.readStructBegin()
13242 
    while True:
13243 
      (fname, ftype, fid) = iprot.readFieldBegin()
13244 
      if ftype == TType.STOP:
13245 
        break
13246 
      if fid == 1:
13247 
        if ftype == TType.I64:
13248 
          self.itemId = iprot.readI64();
13249 
        else:
13250 
          iprot.skip(ftype)
13251 
      elif fid == 2:
13252 
        if ftype == TType.I64:
13253 
          self.sourceId = iprot.readI64();
13254 
        else:
13255 
          iprot.skip(ftype)
13256 
      else:
13257 
        iprot.skip(ftype)
13258 
      iprot.readFieldEnd()
13259 
    iprot.readStructEnd()
13260 
 
13261 
  def write(self, oprot):
13262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13264 
      return
13265 
    oprot.writeStructBegin('getItemPricingBySource_args')
13266 
    if self.itemId is not None:
13267 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13268 
      oprot.writeI64(self.itemId)
13269 
      oprot.writeFieldEnd()
13270 
    if self.sourceId is not None:
13271 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13272 
      oprot.writeI64(self.sourceId)
13273 
      oprot.writeFieldEnd()
13274 
    oprot.writeFieldStop()
13275 
    oprot.writeStructEnd()
13276 
 
13277 
  def validate(self):
13278 
    return
13279 
 
13280 
 
13281 
  def __repr__(self):
13282 
    L = ['%s=%r' % (key, value)
13283 
      for key, value in self.__dict__.iteritems()]
13284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13285 
 
13286 
  def __eq__(self, other):
13287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13288 
 
13289 
  def __ne__(self, other):
13290 
    return not (self == other)
13291 
 
13292 
class getItemPricingBySource_result:
13293 
  """
13294 
  Attributes:
13295 
   - success
13296 
   - cex
13297 
  """
13298 
 
13299 
  thrift_spec = (
13300 
    (0, TType.STRUCT, 'success', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 0
13301 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13302 
  )
13303 
 
13304 
  def __init__(self, success=None, cex=None,):
13305 
    self.success = success
13306 
    self.cex = cex
13307 
 
13308 
  def read(self, iprot):
13309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13311 
      return
13312 
    iprot.readStructBegin()
13313 
    while True:
13314 
      (fname, ftype, fid) = iprot.readFieldBegin()
13315 
      if ftype == TType.STOP:
13316 
        break
13317 
      if fid == 0:
13318 
        if ftype == TType.STRUCT:
13319 
          self.success = SourceItemPricing()
13320 
          self.success.read(iprot)
13321 
        else:
13322 
          iprot.skip(ftype)
13323 
      elif fid == 1:
13324 
        if ftype == TType.STRUCT:
13325 
          self.cex = CatalogServiceException()
13326 
          self.cex.read(iprot)
13327 
        else:
13328 
          iprot.skip(ftype)
13329 
      else:
13330 
        iprot.skip(ftype)
13331 
      iprot.readFieldEnd()
13332 
    iprot.readStructEnd()
13333 
 
13334 
  def write(self, oprot):
13335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13337 
      return
13338 
    oprot.writeStructBegin('getItemPricingBySource_result')
13339 
    if self.success is not None:
13340 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13341 
      self.success.write(oprot)
13342 
      oprot.writeFieldEnd()
13343 
    if self.cex is not None:
13344 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13345 
      self.cex.write(oprot)
13346 
      oprot.writeFieldEnd()
13347 
    oprot.writeFieldStop()
13348 
    oprot.writeStructEnd()
13349 
 
13350 
  def validate(self):
13351 
    return
13352 
 
13353 
 
13354 
  def __repr__(self):
13355 
    L = ['%s=%r' % (key, value)
13356 
      for key, value in self.__dict__.iteritems()]
13357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13358 
 
13359 
  def __eq__(self, other):
13360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13361 
 
13362 
  def __ne__(self, other):
13363 
    return not (self == other)
13364 
 
13365 
class addSourceItemPricing_args:
13366 
  """
13367 
  Attributes:
13368 
   - sourceItemPricing
13369 
  """
13370 
 
13371 
  thrift_spec = (
13372 
    None, # 0
13373 
    (1, TType.STRUCT, 'sourceItemPricing', (SourceItemPricing, SourceItemPricing.thrift_spec), None, ), # 1
13374 
  )
13375 
 
13376 
  def __init__(self, sourceItemPricing=None,):
13377 
    self.sourceItemPricing = sourceItemPricing
13378 
 
13379 
  def read(self, iprot):
13380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13382 
      return
13383 
    iprot.readStructBegin()
13384 
    while True:
13385 
      (fname, ftype, fid) = iprot.readFieldBegin()
13386 
      if ftype == TType.STOP:
13387 
        break
13388 
      if fid == 1:
13389 
        if ftype == TType.STRUCT:
13390 
          self.sourceItemPricing = SourceItemPricing()
13391 
          self.sourceItemPricing.read(iprot)
13392 
        else:
13393 
          iprot.skip(ftype)
13394 
      else:
13395 
        iprot.skip(ftype)
13396 
      iprot.readFieldEnd()
13397 
    iprot.readStructEnd()
13398 
 
13399 
  def write(self, oprot):
13400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13402 
      return
13403 
    oprot.writeStructBegin('addSourceItemPricing_args')
13404 
    if self.sourceItemPricing is not None:
13405 
      oprot.writeFieldBegin('sourceItemPricing', TType.STRUCT, 1)
13406 
      self.sourceItemPricing.write(oprot)
13407 
      oprot.writeFieldEnd()
13408 
    oprot.writeFieldStop()
13409 
    oprot.writeStructEnd()
13410 
 
13411 
  def validate(self):
13412 
    return
13413 
 
13414 
 
13415 
  def __repr__(self):
13416 
    L = ['%s=%r' % (key, value)
13417 
      for key, value in self.__dict__.iteritems()]
13418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13419 
 
13420 
  def __eq__(self, other):
13421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13422 
 
13423 
  def __ne__(self, other):
13424 
    return not (self == other)
13425 
 
13426 
class addSourceItemPricing_result:
13427 
  """
13428 
  Attributes:
13429 
   - cex
13430 
  """
13431 
 
13432 
  thrift_spec = (
13433 
    None, # 0
13434 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13435 
  )
13436 
 
13437 
  def __init__(self, cex=None,):
13438 
    self.cex = cex
13439 
 
13440 
  def read(self, iprot):
13441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13443 
      return
13444 
    iprot.readStructBegin()
13445 
    while True:
13446 
      (fname, ftype, fid) = iprot.readFieldBegin()
13447 
      if ftype == TType.STOP:
13448 
        break
13449 
      if fid == 1:
13450 
        if ftype == TType.STRUCT:
13451 
          self.cex = CatalogServiceException()
13452 
          self.cex.read(iprot)
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      else:
13456 
        iprot.skip(ftype)
13457 
      iprot.readFieldEnd()
13458 
    iprot.readStructEnd()
13459 
 
13460 
  def write(self, oprot):
13461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13463 
      return
13464 
    oprot.writeStructBegin('addSourceItemPricing_result')
13465 
    if self.cex is not None:
13466 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13467 
      self.cex.write(oprot)
13468 
      oprot.writeFieldEnd()
13469 
    oprot.writeFieldStop()
13470 
    oprot.writeStructEnd()
13471 
 
13472 
  def validate(self):
13473 
    return
13474 
 
13475 
 
13476 
  def __repr__(self):
13477 
    L = ['%s=%r' % (key, value)
13478 
      for key, value in self.__dict__.iteritems()]
13479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13480 
 
13481 
  def __eq__(self, other):
13482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13483 
 
13484 
  def __ne__(self, other):
13485 
    return not (self == other)
13486 
 
13487 
class getAllSourcePricing_args:
13488 
  """
13489 
  Attributes:
13490 
   - itemId
13491 
  """
13492 
 
13493 
  thrift_spec = (
13494 
    None, # 0
13495 
    (1, TType.I64, 'itemId', None, None, ), # 1
13496 
  )
13497 
 
13498 
  def __init__(self, itemId=None,):
13499 
    self.itemId = itemId
13500 
 
13501 
  def read(self, iprot):
13502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13504 
      return
13505 
    iprot.readStructBegin()
13506 
    while True:
13507 
      (fname, ftype, fid) = iprot.readFieldBegin()
13508 
      if ftype == TType.STOP:
13509 
        break
13510 
      if fid == 1:
13511 
        if ftype == TType.I64:
13512 
          self.itemId = iprot.readI64();
13513 
        else:
13514 
          iprot.skip(ftype)
13515 
      else:
13516 
        iprot.skip(ftype)
13517 
      iprot.readFieldEnd()
13518 
    iprot.readStructEnd()
13519 
 
13520 
  def write(self, oprot):
13521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13523 
      return
13524 
    oprot.writeStructBegin('getAllSourcePricing_args')
13525 
    if self.itemId is not None:
13526 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
13527 
      oprot.writeI64(self.itemId)
13528 
      oprot.writeFieldEnd()
13529 
    oprot.writeFieldStop()
13530 
    oprot.writeStructEnd()
13531 
 
13532 
  def validate(self):
13533 
    return
13534 
 
13535 
 
13536 
  def __repr__(self):
13537 
    L = ['%s=%r' % (key, value)
13538 
      for key, value in self.__dict__.iteritems()]
13539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13540 
 
13541 
  def __eq__(self, other):
13542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13543 
 
13544 
  def __ne__(self, other):
13545 
    return not (self == other)
13546 
 
13547 
class getAllSourcePricing_result:
13548 
  """
13549 
  Attributes:
13550 
   - success
13551 
   - cex
13552 
  """
13553 
 
13554 
  thrift_spec = (
13555 
    (0, TType.LIST, 'success', (TType.STRUCT,(SourceItemPricing, SourceItemPricing.thrift_spec)), None, ), # 0
13556 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13557 
  )
13558 
 
13559 
  def __init__(self, success=None, cex=None,):
13560 
    self.success = success
13561 
    self.cex = cex
13562 
 
13563 
  def read(self, iprot):
13564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13566 
      return
13567 
    iprot.readStructBegin()
13568 
    while True:
13569 
      (fname, ftype, fid) = iprot.readFieldBegin()
13570 
      if ftype == TType.STOP:
13571 
        break
13572 
      if fid == 0:
13573 
        if ftype == TType.LIST:
13574 
          self.success = []
7438 amit.gupta 13575 
          (_etype247, _size244) = iprot.readListBegin()
13576 
          for _i248 in xrange(_size244):
13577 
            _elem249 = SourceItemPricing()
13578 
            _elem249.read(iprot)
13579 
            self.success.append(_elem249)
5944 mandeep.dh 13580 
          iprot.readListEnd()
13581 
        else:
13582 
          iprot.skip(ftype)
13583 
      elif fid == 1:
13584 
        if ftype == TType.STRUCT:
13585 
          self.cex = CatalogServiceException()
13586 
          self.cex.read(iprot)
13587 
        else:
13588 
          iprot.skip(ftype)
13589 
      else:
13590 
        iprot.skip(ftype)
13591 
      iprot.readFieldEnd()
13592 
    iprot.readStructEnd()
13593 
 
13594 
  def write(self, oprot):
13595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13597 
      return
13598 
    oprot.writeStructBegin('getAllSourcePricing_result')
13599 
    if self.success is not None:
13600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13602 
      for iter250 in self.success:
13603 
        iter250.write(oprot)
5944 mandeep.dh 13604 
      oprot.writeListEnd()
13605 
      oprot.writeFieldEnd()
13606 
    if self.cex is not None:
13607 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13608 
      self.cex.write(oprot)
13609 
      oprot.writeFieldEnd()
13610 
    oprot.writeFieldStop()
13611 
    oprot.writeStructEnd()
13612 
 
13613 
  def validate(self):
13614 
    return
13615 
 
13616 
 
13617 
  def __repr__(self):
13618 
    L = ['%s=%r' % (key, value)
13619 
      for key, value in self.__dict__.iteritems()]
13620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13621 
 
13622 
  def __eq__(self, other):
13623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13624 
 
13625 
  def __ne__(self, other):
13626 
    return not (self == other)
13627 
 
13628 
class getItemForSource_args:
13629 
  """
13630 
  Attributes:
13631 
   - item_id
13632 
   - sourceId
13633 
  """
13634 
 
13635 
  thrift_spec = (
13636 
    None, # 0
13637 
    (1, TType.I64, 'item_id', None, None, ), # 1
13638 
    (2, TType.I64, 'sourceId', None, None, ), # 2
13639 
  )
13640 
 
13641 
  def __init__(self, item_id=None, sourceId=None,):
13642 
    self.item_id = item_id
13643 
    self.sourceId = sourceId
13644 
 
13645 
  def read(self, iprot):
13646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13648 
      return
13649 
    iprot.readStructBegin()
13650 
    while True:
13651 
      (fname, ftype, fid) = iprot.readFieldBegin()
13652 
      if ftype == TType.STOP:
13653 
        break
13654 
      if fid == 1:
13655 
        if ftype == TType.I64:
13656 
          self.item_id = iprot.readI64();
13657 
        else:
13658 
          iprot.skip(ftype)
13659 
      elif fid == 2:
13660 
        if ftype == TType.I64:
13661 
          self.sourceId = iprot.readI64();
13662 
        else:
13663 
          iprot.skip(ftype)
13664 
      else:
13665 
        iprot.skip(ftype)
13666 
      iprot.readFieldEnd()
13667 
    iprot.readStructEnd()
13668 
 
13669 
  def write(self, oprot):
13670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13672 
      return
13673 
    oprot.writeStructBegin('getItemForSource_args')
13674 
    if self.item_id is not None:
13675 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
13676 
      oprot.writeI64(self.item_id)
13677 
      oprot.writeFieldEnd()
13678 
    if self.sourceId is not None:
13679 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
13680 
      oprot.writeI64(self.sourceId)
13681 
      oprot.writeFieldEnd()
13682 
    oprot.writeFieldStop()
13683 
    oprot.writeStructEnd()
13684 
 
13685 
  def validate(self):
13686 
    return
13687 
 
13688 
 
13689 
  def __repr__(self):
13690 
    L = ['%s=%r' % (key, value)
13691 
      for key, value in self.__dict__.iteritems()]
13692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13693 
 
13694 
  def __eq__(self, other):
13695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13696 
 
13697 
  def __ne__(self, other):
13698 
    return not (self == other)
13699 
 
13700 
class getItemForSource_result:
13701 
  """
13702 
  Attributes:
13703 
   - success
13704 
   - cex
13705 
  """
13706 
 
13707 
  thrift_spec = (
13708 
    (0, TType.STRUCT, 'success', (Item, Item.thrift_spec), None, ), # 0
13709 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
13710 
  )
13711 
 
13712 
  def __init__(self, success=None, cex=None,):
13713 
    self.success = success
13714 
    self.cex = cex
13715 
 
13716 
  def read(self, iprot):
13717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13719 
      return
13720 
    iprot.readStructBegin()
13721 
    while True:
13722 
      (fname, ftype, fid) = iprot.readFieldBegin()
13723 
      if ftype == TType.STOP:
13724 
        break
13725 
      if fid == 0:
13726 
        if ftype == TType.STRUCT:
13727 
          self.success = Item()
13728 
          self.success.read(iprot)
13729 
        else:
13730 
          iprot.skip(ftype)
13731 
      elif fid == 1:
13732 
        if ftype == TType.STRUCT:
13733 
          self.cex = CatalogServiceException()
13734 
          self.cex.read(iprot)
13735 
        else:
13736 
          iprot.skip(ftype)
13737 
      else:
13738 
        iprot.skip(ftype)
13739 
      iprot.readFieldEnd()
13740 
    iprot.readStructEnd()
13741 
 
13742 
  def write(self, oprot):
13743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13745 
      return
13746 
    oprot.writeStructBegin('getItemForSource_result')
13747 
    if self.success is not None:
13748 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13749 
      self.success.write(oprot)
13750 
      oprot.writeFieldEnd()
13751 
    if self.cex is not None:
13752 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
13753 
      self.cex.write(oprot)
13754 
      oprot.writeFieldEnd()
13755 
    oprot.writeFieldStop()
13756 
    oprot.writeStructEnd()
13757 
 
13758 
  def validate(self):
13759 
    return
13760 
 
13761 
 
13762 
  def __repr__(self):
13763 
    L = ['%s=%r' % (key, value)
13764 
      for key, value in self.__dict__.iteritems()]
13765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13766 
 
13767 
  def __eq__(self, other):
13768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13769 
 
13770 
  def __ne__(self, other):
13771 
    return not (self == other)
13772 
 
13773 
class searchItemsInRange_args:
13774 
  """
13775 
  Attributes:
13776 
   - searchTerms
13777 
   - offset
13778 
   - limit
13779 
  """
13780 
 
13781 
  thrift_spec = (
13782 
    None, # 0
13783 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13784 
    (2, TType.I64, 'offset', None, None, ), # 2
13785 
    (3, TType.I64, 'limit', None, None, ), # 3
13786 
  )
13787 
 
13788 
  def __init__(self, searchTerms=None, offset=None, limit=None,):
13789 
    self.searchTerms = searchTerms
13790 
    self.offset = offset
13791 
    self.limit = limit
13792 
 
13793 
  def read(self, iprot):
13794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13796 
      return
13797 
    iprot.readStructBegin()
13798 
    while True:
13799 
      (fname, ftype, fid) = iprot.readFieldBegin()
13800 
      if ftype == TType.STOP:
13801 
        break
13802 
      if fid == 1:
13803 
        if ftype == TType.LIST:
13804 
          self.searchTerms = []
7438 amit.gupta 13805 
          (_etype254, _size251) = iprot.readListBegin()
13806 
          for _i255 in xrange(_size251):
13807 
            _elem256 = iprot.readString();
13808 
            self.searchTerms.append(_elem256)
5944 mandeep.dh 13809 
          iprot.readListEnd()
13810 
        else:
13811 
          iprot.skip(ftype)
13812 
      elif fid == 2:
13813 
        if ftype == TType.I64:
13814 
          self.offset = iprot.readI64();
13815 
        else:
13816 
          iprot.skip(ftype)
13817 
      elif fid == 3:
13818 
        if ftype == TType.I64:
13819 
          self.limit = iprot.readI64();
13820 
        else:
13821 
          iprot.skip(ftype)
13822 
      else:
13823 
        iprot.skip(ftype)
13824 
      iprot.readFieldEnd()
13825 
    iprot.readStructEnd()
13826 
 
13827 
  def write(self, oprot):
13828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13830 
      return
13831 
    oprot.writeStructBegin('searchItemsInRange_args')
13832 
    if self.searchTerms is not None:
13833 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13834 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13835 
      for iter257 in self.searchTerms:
13836 
        oprot.writeString(iter257)
5944 mandeep.dh 13837 
      oprot.writeListEnd()
13838 
      oprot.writeFieldEnd()
13839 
    if self.offset is not None:
13840 
      oprot.writeFieldBegin('offset', TType.I64, 2)
13841 
      oprot.writeI64(self.offset)
13842 
      oprot.writeFieldEnd()
13843 
    if self.limit is not None:
13844 
      oprot.writeFieldBegin('limit', TType.I64, 3)
13845 
      oprot.writeI64(self.limit)
13846 
      oprot.writeFieldEnd()
13847 
    oprot.writeFieldStop()
13848 
    oprot.writeStructEnd()
13849 
 
13850 
  def validate(self):
13851 
    return
13852 
 
13853 
 
13854 
  def __repr__(self):
13855 
    L = ['%s=%r' % (key, value)
13856 
      for key, value in self.__dict__.iteritems()]
13857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13858 
 
13859 
  def __eq__(self, other):
13860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13861 
 
13862 
  def __ne__(self, other):
13863 
    return not (self == other)
13864 
 
13865 
class searchItemsInRange_result:
13866 
  """
13867 
  Attributes:
13868 
   - success
13869 
  """
13870 
 
13871 
  thrift_spec = (
13872 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
13873 
  )
13874 
 
13875 
  def __init__(self, success=None,):
13876 
    self.success = success
13877 
 
13878 
  def read(self, iprot):
13879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13881 
      return
13882 
    iprot.readStructBegin()
13883 
    while True:
13884 
      (fname, ftype, fid) = iprot.readFieldBegin()
13885 
      if ftype == TType.STOP:
13886 
        break
13887 
      if fid == 0:
13888 
        if ftype == TType.LIST:
13889 
          self.success = []
7438 amit.gupta 13890 
          (_etype261, _size258) = iprot.readListBegin()
13891 
          for _i262 in xrange(_size258):
13892 
            _elem263 = Item()
13893 
            _elem263.read(iprot)
13894 
            self.success.append(_elem263)
5944 mandeep.dh 13895 
          iprot.readListEnd()
13896 
        else:
13897 
          iprot.skip(ftype)
13898 
      else:
13899 
        iprot.skip(ftype)
13900 
      iprot.readFieldEnd()
13901 
    iprot.readStructEnd()
13902 
 
13903 
  def write(self, oprot):
13904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13906 
      return
13907 
    oprot.writeStructBegin('searchItemsInRange_result')
13908 
    if self.success is not None:
13909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 13911 
      for iter264 in self.success:
13912 
        iter264.write(oprot)
5944 mandeep.dh 13913 
      oprot.writeListEnd()
13914 
      oprot.writeFieldEnd()
13915 
    oprot.writeFieldStop()
13916 
    oprot.writeStructEnd()
13917 
 
13918 
  def validate(self):
13919 
    return
13920 
 
13921 
 
13922 
  def __repr__(self):
13923 
    L = ['%s=%r' % (key, value)
13924 
      for key, value in self.__dict__.iteritems()]
13925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13926 
 
13927 
  def __eq__(self, other):
13928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13929 
 
13930 
  def __ne__(self, other):
13931 
    return not (self == other)
13932 
 
13933 
class getSearchResultCount_args:
13934 
  """
13935 
  Attributes:
13936 
   - searchTerms
13937 
  """
13938 
 
13939 
  thrift_spec = (
13940 
    None, # 0
13941 
    (1, TType.LIST, 'searchTerms', (TType.STRING,None), None, ), # 1
13942 
  )
13943 
 
13944 
  def __init__(self, searchTerms=None,):
13945 
    self.searchTerms = searchTerms
13946 
 
13947 
  def read(self, iprot):
13948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13950 
      return
13951 
    iprot.readStructBegin()
13952 
    while True:
13953 
      (fname, ftype, fid) = iprot.readFieldBegin()
13954 
      if ftype == TType.STOP:
13955 
        break
13956 
      if fid == 1:
13957 
        if ftype == TType.LIST:
13958 
          self.searchTerms = []
7438 amit.gupta 13959 
          (_etype268, _size265) = iprot.readListBegin()
13960 
          for _i269 in xrange(_size265):
13961 
            _elem270 = iprot.readString();
13962 
            self.searchTerms.append(_elem270)
5944 mandeep.dh 13963 
          iprot.readListEnd()
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      else:
13967 
        iprot.skip(ftype)
13968 
      iprot.readFieldEnd()
13969 
    iprot.readStructEnd()
13970 
 
13971 
  def write(self, oprot):
13972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13974 
      return
13975 
    oprot.writeStructBegin('getSearchResultCount_args')
13976 
    if self.searchTerms is not None:
13977 
      oprot.writeFieldBegin('searchTerms', TType.LIST, 1)
13978 
      oprot.writeListBegin(TType.STRING, len(self.searchTerms))
7438 amit.gupta 13979 
      for iter271 in self.searchTerms:
13980 
        oprot.writeString(iter271)
5944 mandeep.dh 13981 
      oprot.writeListEnd()
13982 
      oprot.writeFieldEnd()
13983 
    oprot.writeFieldStop()
13984 
    oprot.writeStructEnd()
13985 
 
13986 
  def validate(self):
13987 
    return
13988 
 
13989 
 
13990 
  def __repr__(self):
13991 
    L = ['%s=%r' % (key, value)
13992 
      for key, value in self.__dict__.iteritems()]
13993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13994 
 
13995 
  def __eq__(self, other):
13996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13997 
 
13998 
  def __ne__(self, other):
13999 
    return not (self == other)
14000 
 
14001 
class getSearchResultCount_result:
14002 
  """
14003 
  Attributes:
14004 
   - success
14005 
  """
14006 
 
14007 
  thrift_spec = (
14008 
    (0, TType.I32, 'success', None, None, ), # 0
14009 
  )
14010 
 
14011 
  def __init__(self, success=None,):
14012 
    self.success = success
14013 
 
14014 
  def read(self, iprot):
14015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14017 
      return
14018 
    iprot.readStructBegin()
14019 
    while True:
14020 
      (fname, ftype, fid) = iprot.readFieldBegin()
14021 
      if ftype == TType.STOP:
14022 
        break
14023 
      if fid == 0:
14024 
        if ftype == TType.I32:
14025 
          self.success = iprot.readI32();
14026 
        else:
14027 
          iprot.skip(ftype)
14028 
      else:
14029 
        iprot.skip(ftype)
14030 
      iprot.readFieldEnd()
14031 
    iprot.readStructEnd()
14032 
 
14033 
  def write(self, oprot):
14034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14036 
      return
14037 
    oprot.writeStructBegin('getSearchResultCount_result')
14038 
    if self.success is not None:
14039 
      oprot.writeFieldBegin('success', TType.I32, 0)
14040 
      oprot.writeI32(self.success)
14041 
      oprot.writeFieldEnd()
14042 
    oprot.writeFieldStop()
14043 
    oprot.writeStructEnd()
14044 
 
14045 
  def validate(self):
14046 
    return
14047 
 
14048 
 
14049 
  def __repr__(self):
14050 
    L = ['%s=%r' % (key, value)
14051 
      for key, value in self.__dict__.iteritems()]
14052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14053 
 
14054 
  def __eq__(self, other):
14055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14056 
 
14057 
  def __ne__(self, other):
14058 
    return not (self == other)
14059 
 
14060 
class getProductNotifications_args:
14061 
  """
14062 
  Attributes:
14063 
   - startDateTime
14064 
  """
14065 
 
14066 
  thrift_spec = (
14067 
    None, # 0
14068 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14069 
  )
14070 
 
14071 
  def __init__(self, startDateTime=None,):
14072 
    self.startDateTime = startDateTime
14073 
 
14074 
  def read(self, iprot):
14075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14077 
      return
14078 
    iprot.readStructBegin()
14079 
    while True:
14080 
      (fname, ftype, fid) = iprot.readFieldBegin()
14081 
      if ftype == TType.STOP:
14082 
        break
14083 
      if fid == 1:
14084 
        if ftype == TType.I64:
14085 
          self.startDateTime = iprot.readI64();
14086 
        else:
14087 
          iprot.skip(ftype)
14088 
      else:
14089 
        iprot.skip(ftype)
14090 
      iprot.readFieldEnd()
14091 
    iprot.readStructEnd()
14092 
 
14093 
  def write(self, oprot):
14094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14096 
      return
14097 
    oprot.writeStructBegin('getProductNotifications_args')
14098 
    if self.startDateTime is not None:
14099 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14100 
      oprot.writeI64(self.startDateTime)
14101 
      oprot.writeFieldEnd()
14102 
    oprot.writeFieldStop()
14103 
    oprot.writeStructEnd()
14104 
 
14105 
  def validate(self):
14106 
    return
14107 
 
14108 
 
14109 
  def __repr__(self):
14110 
    L = ['%s=%r' % (key, value)
14111 
      for key, value in self.__dict__.iteritems()]
14112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14113 
 
14114 
  def __eq__(self, other):
14115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14116 
 
14117 
  def __ne__(self, other):
14118 
    return not (self == other)
14119 
 
14120 
class getProductNotifications_result:
14121 
  """
14122 
  Attributes:
14123 
   - success
14124 
  """
14125 
 
14126 
  thrift_spec = (
14127 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequest, ProductNotificationRequest.thrift_spec)), None, ), # 0
14128 
  )
14129 
 
14130 
  def __init__(self, success=None,):
14131 
    self.success = success
14132 
 
14133 
  def read(self, iprot):
14134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14136 
      return
14137 
    iprot.readStructBegin()
14138 
    while True:
14139 
      (fname, ftype, fid) = iprot.readFieldBegin()
14140 
      if ftype == TType.STOP:
14141 
        break
14142 
      if fid == 0:
14143 
        if ftype == TType.LIST:
14144 
          self.success = []
7438 amit.gupta 14145 
          (_etype275, _size272) = iprot.readListBegin()
14146 
          for _i276 in xrange(_size272):
14147 
            _elem277 = ProductNotificationRequest()
14148 
            _elem277.read(iprot)
14149 
            self.success.append(_elem277)
5944 mandeep.dh 14150 
          iprot.readListEnd()
14151 
        else:
14152 
          iprot.skip(ftype)
14153 
      else:
14154 
        iprot.skip(ftype)
14155 
      iprot.readFieldEnd()
14156 
    iprot.readStructEnd()
14157 
 
14158 
  def write(self, oprot):
14159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14161 
      return
14162 
    oprot.writeStructBegin('getProductNotifications_result')
14163 
    if self.success is not None:
14164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14166 
      for iter278 in self.success:
14167 
        iter278.write(oprot)
5944 mandeep.dh 14168 
      oprot.writeListEnd()
14169 
      oprot.writeFieldEnd()
14170 
    oprot.writeFieldStop()
14171 
    oprot.writeStructEnd()
14172 
 
14173 
  def validate(self):
14174 
    return
14175 
 
14176 
 
14177 
  def __repr__(self):
14178 
    L = ['%s=%r' % (key, value)
14179 
      for key, value in self.__dict__.iteritems()]
14180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14181 
 
14182 
  def __eq__(self, other):
14183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14184 
 
14185 
  def __ne__(self, other):
14186 
    return not (self == other)
14187 
 
14188 
class getProductNotificationRequestCount_args:
14189 
  """
14190 
  Attributes:
14191 
   - startDateTime
14192 
  """
14193 
 
14194 
  thrift_spec = (
14195 
    None, # 0
14196 
    (1, TType.I64, 'startDateTime', None, None, ), # 1
14197 
  )
14198 
 
14199 
  def __init__(self, startDateTime=None,):
14200 
    self.startDateTime = startDateTime
14201 
 
14202 
  def read(self, iprot):
14203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14205 
      return
14206 
    iprot.readStructBegin()
14207 
    while True:
14208 
      (fname, ftype, fid) = iprot.readFieldBegin()
14209 
      if ftype == TType.STOP:
14210 
        break
14211 
      if fid == 1:
14212 
        if ftype == TType.I64:
14213 
          self.startDateTime = iprot.readI64();
14214 
        else:
14215 
          iprot.skip(ftype)
14216 
      else:
14217 
        iprot.skip(ftype)
14218 
      iprot.readFieldEnd()
14219 
    iprot.readStructEnd()
14220 
 
14221 
  def write(self, oprot):
14222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14224 
      return
14225 
    oprot.writeStructBegin('getProductNotificationRequestCount_args')
14226 
    if self.startDateTime is not None:
14227 
      oprot.writeFieldBegin('startDateTime', TType.I64, 1)
14228 
      oprot.writeI64(self.startDateTime)
14229 
      oprot.writeFieldEnd()
14230 
    oprot.writeFieldStop()
14231 
    oprot.writeStructEnd()
14232 
 
14233 
  def validate(self):
14234 
    return
14235 
 
14236 
 
14237 
  def __repr__(self):
14238 
    L = ['%s=%r' % (key, value)
14239 
      for key, value in self.__dict__.iteritems()]
14240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14241 
 
14242 
  def __eq__(self, other):
14243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14244 
 
14245 
  def __ne__(self, other):
14246 
    return not (self == other)
14247 
 
14248 
class getProductNotificationRequestCount_result:
14249 
  """
14250 
  Attributes:
14251 
   - success
14252 
  """
14253 
 
14254 
  thrift_spec = (
14255 
    (0, TType.LIST, 'success', (TType.STRUCT,(ProductNotificationRequestCount, ProductNotificationRequestCount.thrift_spec)), None, ), # 0
14256 
  )
14257 
 
14258 
  def __init__(self, success=None,):
14259 
    self.success = success
14260 
 
14261 
  def read(self, iprot):
14262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14264 
      return
14265 
    iprot.readStructBegin()
14266 
    while True:
14267 
      (fname, ftype, fid) = iprot.readFieldBegin()
14268 
      if ftype == TType.STOP:
14269 
        break
14270 
      if fid == 0:
14271 
        if ftype == TType.LIST:
14272 
          self.success = []
7438 amit.gupta 14273 
          (_etype282, _size279) = iprot.readListBegin()
14274 
          for _i283 in xrange(_size279):
14275 
            _elem284 = ProductNotificationRequestCount()
14276 
            _elem284.read(iprot)
14277 
            self.success.append(_elem284)
5944 mandeep.dh 14278 
          iprot.readListEnd()
14279 
        else:
14280 
          iprot.skip(ftype)
14281 
      else:
14282 
        iprot.skip(ftype)
14283 
      iprot.readFieldEnd()
14284 
    iprot.readStructEnd()
14285 
 
14286 
  def write(self, oprot):
14287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14289 
      return
14290 
    oprot.writeStructBegin('getProductNotificationRequestCount_result')
14291 
    if self.success is not None:
14292 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14293 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 14294 
      for iter285 in self.success:
14295 
        iter285.write(oprot)
5944 mandeep.dh 14296 
      oprot.writeListEnd()
14297 
      oprot.writeFieldEnd()
14298 
    oprot.writeFieldStop()
14299 
    oprot.writeStructEnd()
14300 
 
14301 
  def validate(self):
14302 
    return
14303 
 
14304 
 
14305 
  def __repr__(self):
14306 
    L = ['%s=%r' % (key, value)
14307 
      for key, value in self.__dict__.iteritems()]
14308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14309 
 
14310 
  def __eq__(self, other):
14311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14312 
 
14313 
  def __ne__(self, other):
14314 
    return not (self == other)
14315 
 
14316 
class addAuthorizationLog_args:
14317 
  """
14318 
  Attributes:
14319 
   - itemId
14320 
   - username
14321 
   - reason
14322 
  """
14323 
 
14324 
  thrift_spec = (
14325 
    None, # 0
14326 
    (1, TType.I64, 'itemId', None, None, ), # 1
14327 
    (2, TType.STRING, 'username', None, None, ), # 2
14328 
    (3, TType.STRING, 'reason', None, None, ), # 3
14329 
  )
14330 
 
14331 
  def __init__(self, itemId=None, username=None, reason=None,):
14332 
    self.itemId = itemId
14333 
    self.username = username
14334 
    self.reason = reason
14335 
 
14336 
  def read(self, iprot):
14337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14339 
      return
14340 
    iprot.readStructBegin()
14341 
    while True:
14342 
      (fname, ftype, fid) = iprot.readFieldBegin()
14343 
      if ftype == TType.STOP:
14344 
        break
14345 
      if fid == 1:
14346 
        if ftype == TType.I64:
14347 
          self.itemId = iprot.readI64();
14348 
        else:
14349 
          iprot.skip(ftype)
14350 
      elif fid == 2:
14351 
        if ftype == TType.STRING:
14352 
          self.username = iprot.readString();
14353 
        else:
14354 
          iprot.skip(ftype)
14355 
      elif fid == 3:
14356 
        if ftype == TType.STRING:
14357 
          self.reason = iprot.readString();
14358 
        else:
14359 
          iprot.skip(ftype)
14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
14369 
    oprot.writeStructBegin('addAuthorizationLog_args')
14370 
    if self.itemId is not None:
14371 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14372 
      oprot.writeI64(self.itemId)
14373 
      oprot.writeFieldEnd()
14374 
    if self.username is not None:
14375 
      oprot.writeFieldBegin('username', TType.STRING, 2)
14376 
      oprot.writeString(self.username)
14377 
      oprot.writeFieldEnd()
14378 
    if self.reason is not None:
14379 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
14380 
      oprot.writeString(self.reason)
14381 
      oprot.writeFieldEnd()
14382 
    oprot.writeFieldStop()
14383 
    oprot.writeStructEnd()
14384 
 
14385 
  def validate(self):
14386 
    return
14387 
 
14388 
 
14389 
  def __repr__(self):
14390 
    L = ['%s=%r' % (key, value)
14391 
      for key, value in self.__dict__.iteritems()]
14392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14393 
 
14394 
  def __eq__(self, other):
14395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14396 
 
14397 
  def __ne__(self, other):
14398 
    return not (self == other)
14399 
 
14400 
class addAuthorizationLog_result:
14401 
  """
14402 
  Attributes:
14403 
   - success
14404 
   - cex
14405 
  """
14406 
 
14407 
  thrift_spec = (
14408 
    (0, TType.BOOL, 'success', None, None, ), # 0
14409 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14410 
  )
14411 
 
14412 
  def __init__(self, success=None, cex=None,):
14413 
    self.success = success
14414 
    self.cex = cex
14415 
 
14416 
  def read(self, iprot):
14417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14419 
      return
14420 
    iprot.readStructBegin()
14421 
    while True:
14422 
      (fname, ftype, fid) = iprot.readFieldBegin()
14423 
      if ftype == TType.STOP:
14424 
        break
14425 
      if fid == 0:
14426 
        if ftype == TType.BOOL:
14427 
          self.success = iprot.readBool();
14428 
        else:
14429 
          iprot.skip(ftype)
14430 
      elif fid == 1:
14431 
        if ftype == TType.STRUCT:
14432 
          self.cex = CatalogServiceException()
14433 
          self.cex.read(iprot)
14434 
        else:
14435 
          iprot.skip(ftype)
14436 
      else:
14437 
        iprot.skip(ftype)
14438 
      iprot.readFieldEnd()
14439 
    iprot.readStructEnd()
14440 
 
14441 
  def write(self, oprot):
14442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14444 
      return
14445 
    oprot.writeStructBegin('addAuthorizationLog_result')
14446 
    if self.success is not None:
14447 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14448 
      oprot.writeBool(self.success)
14449 
      oprot.writeFieldEnd()
14450 
    if self.cex is not None:
14451 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14452 
      self.cex.write(oprot)
14453 
      oprot.writeFieldEnd()
14454 
    oprot.writeFieldStop()
14455 
    oprot.writeStructEnd()
14456 
 
14457 
  def validate(self):
14458 
    return
14459 
 
14460 
 
14461 
  def __repr__(self):
14462 
    L = ['%s=%r' % (key, value)
14463 
      for key, value in self.__dict__.iteritems()]
14464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14465 
 
14466 
  def __eq__(self, other):
14467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14468 
 
14469 
  def __ne__(self, other):
14470 
    return not (self == other)
14471 
 
14472 
class addupdateVoucherForItem_args:
14473 
  """
14474 
  Attributes:
14475 
   - catalog_item_id
14476 
   - voucherType
14477 
   - voucherAmount
14478 
  """
14479 
 
14480 
  thrift_spec = (
14481 
    None, # 0
14482 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14483 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14484 
    (3, TType.I64, 'voucherAmount', None, None, ), # 3
14485 
  )
14486 
 
14487 
  def __init__(self, catalog_item_id=None, voucherType=None, voucherAmount=None,):
14488 
    self.catalog_item_id = catalog_item_id
14489 
    self.voucherType = voucherType
14490 
    self.voucherAmount = voucherAmount
14491 
 
14492 
  def read(self, iprot):
14493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14495 
      return
14496 
    iprot.readStructBegin()
14497 
    while True:
14498 
      (fname, ftype, fid) = iprot.readFieldBegin()
14499 
      if ftype == TType.STOP:
14500 
        break
14501 
      if fid == 1:
14502 
        if ftype == TType.I64:
14503 
          self.catalog_item_id = iprot.readI64();
14504 
        else:
14505 
          iprot.skip(ftype)
14506 
      elif fid == 2:
14507 
        if ftype == TType.I64:
14508 
          self.voucherType = iprot.readI64();
14509 
        else:
14510 
          iprot.skip(ftype)
14511 
      elif fid == 3:
14512 
        if ftype == TType.I64:
14513 
          self.voucherAmount = iprot.readI64();
14514 
        else:
14515 
          iprot.skip(ftype)
14516 
      else:
14517 
        iprot.skip(ftype)
14518 
      iprot.readFieldEnd()
14519 
    iprot.readStructEnd()
14520 
 
14521 
  def write(self, oprot):
14522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14524 
      return
14525 
    oprot.writeStructBegin('addupdateVoucherForItem_args')
14526 
    if self.catalog_item_id is not None:
14527 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14528 
      oprot.writeI64(self.catalog_item_id)
14529 
      oprot.writeFieldEnd()
14530 
    if self.voucherType is not None:
14531 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14532 
      oprot.writeI64(self.voucherType)
14533 
      oprot.writeFieldEnd()
14534 
    if self.voucherAmount is not None:
14535 
      oprot.writeFieldBegin('voucherAmount', TType.I64, 3)
14536 
      oprot.writeI64(self.voucherAmount)
14537 
      oprot.writeFieldEnd()
14538 
    oprot.writeFieldStop()
14539 
    oprot.writeStructEnd()
14540 
 
14541 
  def validate(self):
14542 
    return
14543 
 
14544 
 
14545 
  def __repr__(self):
14546 
    L = ['%s=%r' % (key, value)
14547 
      for key, value in self.__dict__.iteritems()]
14548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14549 
 
14550 
  def __eq__(self, other):
14551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14552 
 
14553 
  def __ne__(self, other):
14554 
    return not (self == other)
14555 
 
14556 
class addupdateVoucherForItem_result:
14557 
  """
14558 
  Attributes:
14559 
   - success
14560 
   - cex
14561 
  """
14562 
 
14563 
  thrift_spec = (
14564 
    (0, TType.BOOL, 'success', None, None, ), # 0
14565 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14566 
  )
14567 
 
14568 
  def __init__(self, success=None, cex=None,):
14569 
    self.success = success
14570 
    self.cex = cex
14571 
 
14572 
  def read(self, iprot):
14573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14575 
      return
14576 
    iprot.readStructBegin()
14577 
    while True:
14578 
      (fname, ftype, fid) = iprot.readFieldBegin()
14579 
      if ftype == TType.STOP:
14580 
        break
14581 
      if fid == 0:
14582 
        if ftype == TType.BOOL:
14583 
          self.success = iprot.readBool();
14584 
        else:
14585 
          iprot.skip(ftype)
14586 
      elif fid == 1:
14587 
        if ftype == TType.STRUCT:
14588 
          self.cex = CatalogServiceException()
14589 
          self.cex.read(iprot)
14590 
        else:
14591 
          iprot.skip(ftype)
14592 
      else:
14593 
        iprot.skip(ftype)
14594 
      iprot.readFieldEnd()
14595 
    iprot.readStructEnd()
14596 
 
14597 
  def write(self, oprot):
14598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14600 
      return
14601 
    oprot.writeStructBegin('addupdateVoucherForItem_result')
14602 
    if self.success is not None:
14603 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14604 
      oprot.writeBool(self.success)
14605 
      oprot.writeFieldEnd()
14606 
    if self.cex is not None:
14607 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14608 
      self.cex.write(oprot)
14609 
      oprot.writeFieldEnd()
14610 
    oprot.writeFieldStop()
14611 
    oprot.writeStructEnd()
14612 
 
14613 
  def validate(self):
14614 
    return
14615 
 
14616 
 
14617 
  def __repr__(self):
14618 
    L = ['%s=%r' % (key, value)
14619 
      for key, value in self.__dict__.iteritems()]
14620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14621 
 
14622 
  def __eq__(self, other):
14623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14624 
 
14625 
  def __ne__(self, other):
14626 
    return not (self == other)
14627 
 
14628 
class deleteVoucherForItem_args:
14629 
  """
14630 
  Attributes:
14631 
   - catalog_item_id
14632 
   - voucherType
14633 
  """
14634 
 
14635 
  thrift_spec = (
14636 
    None, # 0
14637 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
14638 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14639 
  )
14640 
 
14641 
  def __init__(self, catalog_item_id=None, voucherType=None,):
14642 
    self.catalog_item_id = catalog_item_id
14643 
    self.voucherType = voucherType
14644 
 
14645 
  def read(self, iprot):
14646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14648 
      return
14649 
    iprot.readStructBegin()
14650 
    while True:
14651 
      (fname, ftype, fid) = iprot.readFieldBegin()
14652 
      if ftype == TType.STOP:
14653 
        break
14654 
      if fid == 1:
14655 
        if ftype == TType.I64:
14656 
          self.catalog_item_id = iprot.readI64();
14657 
        else:
14658 
          iprot.skip(ftype)
14659 
      elif fid == 2:
14660 
        if ftype == TType.I64:
14661 
          self.voucherType = iprot.readI64();
14662 
        else:
14663 
          iprot.skip(ftype)
14664 
      else:
14665 
        iprot.skip(ftype)
14666 
      iprot.readFieldEnd()
14667 
    iprot.readStructEnd()
14668 
 
14669 
  def write(self, oprot):
14670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14672 
      return
14673 
    oprot.writeStructBegin('deleteVoucherForItem_args')
14674 
    if self.catalog_item_id is not None:
14675 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
14676 
      oprot.writeI64(self.catalog_item_id)
14677 
      oprot.writeFieldEnd()
14678 
    if self.voucherType is not None:
14679 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14680 
      oprot.writeI64(self.voucherType)
14681 
      oprot.writeFieldEnd()
14682 
    oprot.writeFieldStop()
14683 
    oprot.writeStructEnd()
14684 
 
14685 
  def validate(self):
14686 
    return
14687 
 
14688 
 
14689 
  def __repr__(self):
14690 
    L = ['%s=%r' % (key, value)
14691 
      for key, value in self.__dict__.iteritems()]
14692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14693 
 
14694 
  def __eq__(self, other):
14695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14696 
 
14697 
  def __ne__(self, other):
14698 
    return not (self == other)
14699 
 
14700 
class deleteVoucherForItem_result:
14701 
  """
14702 
  Attributes:
14703 
   - success
14704 
   - cex
14705 
  """
14706 
 
14707 
  thrift_spec = (
14708 
    (0, TType.BOOL, 'success', None, None, ), # 0
14709 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
14710 
  )
14711 
 
14712 
  def __init__(self, success=None, cex=None,):
14713 
    self.success = success
14714 
    self.cex = cex
14715 
 
14716 
  def read(self, iprot):
14717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14719 
      return
14720 
    iprot.readStructBegin()
14721 
    while True:
14722 
      (fname, ftype, fid) = iprot.readFieldBegin()
14723 
      if ftype == TType.STOP:
14724 
        break
14725 
      if fid == 0:
14726 
        if ftype == TType.BOOL:
14727 
          self.success = iprot.readBool();
14728 
        else:
14729 
          iprot.skip(ftype)
14730 
      elif fid == 1:
14731 
        if ftype == TType.STRUCT:
14732 
          self.cex = CatalogServiceException()
14733 
          self.cex.read(iprot)
14734 
        else:
14735 
          iprot.skip(ftype)
14736 
      else:
14737 
        iprot.skip(ftype)
14738 
      iprot.readFieldEnd()
14739 
    iprot.readStructEnd()
14740 
 
14741 
  def write(self, oprot):
14742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14744 
      return
14745 
    oprot.writeStructBegin('deleteVoucherForItem_result')
14746 
    if self.success is not None:
14747 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14748 
      oprot.writeBool(self.success)
14749 
      oprot.writeFieldEnd()
14750 
    if self.cex is not None:
14751 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
14752 
      self.cex.write(oprot)
14753 
      oprot.writeFieldEnd()
14754 
    oprot.writeFieldStop()
14755 
    oprot.writeStructEnd()
14756 
 
14757 
  def validate(self):
14758 
    return
14759 
 
14760 
 
14761 
  def __repr__(self):
14762 
    L = ['%s=%r' % (key, value)
14763 
      for key, value in self.__dict__.iteritems()]
14764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14765 
 
14766 
  def __eq__(self, other):
14767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14768 
 
14769 
  def __ne__(self, other):
14770 
    return not (self == other)
14771 
 
14772 
class getVoucherAmount_args:
14773 
  """
14774 
  Attributes:
14775 
   - itemId
14776 
   - voucherType
14777 
  """
14778 
 
14779 
  thrift_spec = (
14780 
    None, # 0
14781 
    (1, TType.I64, 'itemId', None, None, ), # 1
14782 
    (2, TType.I64, 'voucherType', None, None, ), # 2
14783 
  )
14784 
 
14785 
  def __init__(self, itemId=None, voucherType=None,):
14786 
    self.itemId = itemId
14787 
    self.voucherType = voucherType
14788 
 
14789 
  def read(self, iprot):
14790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14792 
      return
14793 
    iprot.readStructBegin()
14794 
    while True:
14795 
      (fname, ftype, fid) = iprot.readFieldBegin()
14796 
      if ftype == TType.STOP:
14797 
        break
14798 
      if fid == 1:
14799 
        if ftype == TType.I64:
14800 
          self.itemId = iprot.readI64();
14801 
        else:
14802 
          iprot.skip(ftype)
14803 
      elif fid == 2:
14804 
        if ftype == TType.I64:
14805 
          self.voucherType = iprot.readI64();
14806 
        else:
14807 
          iprot.skip(ftype)
14808 
      else:
14809 
        iprot.skip(ftype)
14810 
      iprot.readFieldEnd()
14811 
    iprot.readStructEnd()
14812 
 
14813 
  def write(self, oprot):
14814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14816 
      return
14817 
    oprot.writeStructBegin('getVoucherAmount_args')
14818 
    if self.itemId is not None:
14819 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14820 
      oprot.writeI64(self.itemId)
14821 
      oprot.writeFieldEnd()
14822 
    if self.voucherType is not None:
14823 
      oprot.writeFieldBegin('voucherType', TType.I64, 2)
14824 
      oprot.writeI64(self.voucherType)
14825 
      oprot.writeFieldEnd()
14826 
    oprot.writeFieldStop()
14827 
    oprot.writeStructEnd()
14828 
 
14829 
  def validate(self):
14830 
    return
14831 
 
14832 
 
14833 
  def __repr__(self):
14834 
    L = ['%s=%r' % (key, value)
14835 
      for key, value in self.__dict__.iteritems()]
14836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14837 
 
14838 
  def __eq__(self, other):
14839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14840 
 
14841 
  def __ne__(self, other):
14842 
    return not (self == other)
14843 
 
14844 
class getVoucherAmount_result:
14845 
  """
14846 
  Attributes:
14847 
   - success
14848 
  """
14849 
 
14850 
  thrift_spec = (
14851 
    (0, TType.I64, 'success', None, None, ), # 0
14852 
  )
14853 
 
14854 
  def __init__(self, success=None,):
14855 
    self.success = success
14856 
 
14857 
  def read(self, iprot):
14858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14860 
      return
14861 
    iprot.readStructBegin()
14862 
    while True:
14863 
      (fname, ftype, fid) = iprot.readFieldBegin()
14864 
      if ftype == TType.STOP:
14865 
        break
14866 
      if fid == 0:
14867 
        if ftype == TType.I64:
14868 
          self.success = iprot.readI64();
14869 
        else:
14870 
          iprot.skip(ftype)
14871 
      else:
14872 
        iprot.skip(ftype)
14873 
      iprot.readFieldEnd()
14874 
    iprot.readStructEnd()
14875 
 
14876 
  def write(self, oprot):
14877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14879 
      return
14880 
    oprot.writeStructBegin('getVoucherAmount_result')
14881 
    if self.success is not None:
14882 
      oprot.writeFieldBegin('success', TType.I64, 0)
14883 
      oprot.writeI64(self.success)
14884 
      oprot.writeFieldEnd()
14885 
    oprot.writeFieldStop()
14886 
    oprot.writeStructEnd()
14887 
 
14888 
  def validate(self):
14889 
    return
14890 
 
14891 
 
14892 
  def __repr__(self):
14893 
    L = ['%s=%r' % (key, value)
14894 
      for key, value in self.__dict__.iteritems()]
14895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14896 
 
14897 
  def __eq__(self, other):
14898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14899 
 
14900 
  def __ne__(self, other):
14901 
    return not (self == other)
14902 
 
14903 
class getAllItemVouchers_args:
14904 
  """
14905 
  Attributes:
14906 
   - itemId
14907 
  """
14908 
 
14909 
  thrift_spec = (
14910 
    None, # 0
14911 
    (1, TType.I64, 'itemId', None, None, ), # 1
14912 
  )
14913 
 
14914 
  def __init__(self, itemId=None,):
14915 
    self.itemId = itemId
14916 
 
14917 
  def read(self, iprot):
14918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14920 
      return
14921 
    iprot.readStructBegin()
14922 
    while True:
14923 
      (fname, ftype, fid) = iprot.readFieldBegin()
14924 
      if ftype == TType.STOP:
14925 
        break
14926 
      if fid == 1:
14927 
        if ftype == TType.I64:
14928 
          self.itemId = iprot.readI64();
14929 
        else:
14930 
          iprot.skip(ftype)
14931 
      else:
14932 
        iprot.skip(ftype)
14933 
      iprot.readFieldEnd()
14934 
    iprot.readStructEnd()
14935 
 
14936 
  def write(self, oprot):
14937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14939 
      return
14940 
    oprot.writeStructBegin('getAllItemVouchers_args')
14941 
    if self.itemId is not None:
14942 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
14943 
      oprot.writeI64(self.itemId)
14944 
      oprot.writeFieldEnd()
14945 
    oprot.writeFieldStop()
14946 
    oprot.writeStructEnd()
14947 
 
14948 
  def validate(self):
14949 
    return
14950 
 
14951 
 
14952 
  def __repr__(self):
14953 
    L = ['%s=%r' % (key, value)
14954 
      for key, value in self.__dict__.iteritems()]
14955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14956 
 
14957 
  def __eq__(self, other):
14958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14959 
 
14960 
  def __ne__(self, other):
14961 
    return not (self == other)
14962 
 
14963 
class getAllItemVouchers_result:
14964 
  """
14965 
  Attributes:
14966 
   - success
14967 
  """
14968 
 
14969 
  thrift_spec = (
14970 
    (0, TType.LIST, 'success', (TType.STRUCT,(VoucherItemMapping, VoucherItemMapping.thrift_spec)), None, ), # 0
14971 
  )
14972 
 
14973 
  def __init__(self, success=None,):
14974 
    self.success = success
14975 
 
14976 
  def read(self, iprot):
14977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14979 
      return
14980 
    iprot.readStructBegin()
14981 
    while True:
14982 
      (fname, ftype, fid) = iprot.readFieldBegin()
14983 
      if ftype == TType.STOP:
14984 
        break
14985 
      if fid == 0:
14986 
        if ftype == TType.LIST:
14987 
          self.success = []
7438 amit.gupta 14988 
          (_etype289, _size286) = iprot.readListBegin()
14989 
          for _i290 in xrange(_size286):
14990 
            _elem291 = VoucherItemMapping()
14991 
            _elem291.read(iprot)
14992 
            self.success.append(_elem291)
5944 mandeep.dh 14993 
          iprot.readListEnd()
14994 
        else:
14995 
          iprot.skip(ftype)
14996 
      else:
14997 
        iprot.skip(ftype)
14998 
      iprot.readFieldEnd()
14999 
    iprot.readStructEnd()
15000 
 
15001 
  def write(self, oprot):
15002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15004 
      return
15005 
    oprot.writeStructBegin('getAllItemVouchers_result')
15006 
    if self.success is not None:
15007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15009 
      for iter292 in self.success:
15010 
        iter292.write(oprot)
5944 mandeep.dh 15011 
      oprot.writeListEnd()
15012 
      oprot.writeFieldEnd()
15013 
    oprot.writeFieldStop()
15014 
    oprot.writeStructEnd()
15015 
 
15016 
  def validate(self):
15017 
    return
15018 
 
15019 
 
15020 
  def __repr__(self):
15021 
    L = ['%s=%r' % (key, value)
15022 
      for key, value in self.__dict__.iteritems()]
15023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15024 
 
15025 
  def __eq__(self, other):
15026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15027 
 
15028 
  def __ne__(self, other):
15029 
    return not (self == other)
15030 
 
15031 
class isValidCatalogItemId_args:
15032 
  """
15033 
  Attributes:
15034 
   - catalog_item_id
15035 
  """
15036 
 
15037 
  thrift_spec = (
15038 
    None, # 0
15039 
    (1, TType.I64, 'catalog_item_id', None, None, ), # 1
15040 
  )
15041 
 
15042 
  def __init__(self, catalog_item_id=None,):
15043 
    self.catalog_item_id = catalog_item_id
15044 
 
15045 
  def read(self, iprot):
15046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15048 
      return
15049 
    iprot.readStructBegin()
15050 
    while True:
15051 
      (fname, ftype, fid) = iprot.readFieldBegin()
15052 
      if ftype == TType.STOP:
15053 
        break
15054 
      if fid == 1:
15055 
        if ftype == TType.I64:
15056 
          self.catalog_item_id = iprot.readI64();
15057 
        else:
15058 
          iprot.skip(ftype)
15059 
      else:
15060 
        iprot.skip(ftype)
15061 
      iprot.readFieldEnd()
15062 
    iprot.readStructEnd()
15063 
 
15064 
  def write(self, oprot):
15065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15067 
      return
15068 
    oprot.writeStructBegin('isValidCatalogItemId_args')
15069 
    if self.catalog_item_id is not None:
15070 
      oprot.writeFieldBegin('catalog_item_id', TType.I64, 1)
15071 
      oprot.writeI64(self.catalog_item_id)
15072 
      oprot.writeFieldEnd()
15073 
    oprot.writeFieldStop()
15074 
    oprot.writeStructEnd()
15075 
 
15076 
  def validate(self):
15077 
    return
15078 
 
15079 
 
15080 
  def __repr__(self):
15081 
    L = ['%s=%r' % (key, value)
15082 
      for key, value in self.__dict__.iteritems()]
15083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15084 
 
15085 
  def __eq__(self, other):
15086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15087 
 
15088 
  def __ne__(self, other):
15089 
    return not (self == other)
15090 
 
15091 
class isValidCatalogItemId_result:
15092 
  """
15093 
  Attributes:
15094 
   - success
15095 
  """
15096 
 
15097 
  thrift_spec = (
15098 
    (0, TType.BOOL, 'success', None, None, ), # 0
15099 
  )
15100 
 
15101 
  def __init__(self, success=None,):
15102 
    self.success = success
15103 
 
15104 
  def read(self, iprot):
15105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15107 
      return
15108 
    iprot.readStructBegin()
15109 
    while True:
15110 
      (fname, ftype, fid) = iprot.readFieldBegin()
15111 
      if ftype == TType.STOP:
15112 
        break
15113 
      if fid == 0:
15114 
        if ftype == TType.BOOL:
15115 
          self.success = iprot.readBool();
15116 
        else:
15117 
          iprot.skip(ftype)
15118 
      else:
15119 
        iprot.skip(ftype)
15120 
      iprot.readFieldEnd()
15121 
    iprot.readStructEnd()
15122 
 
15123 
  def write(self, oprot):
15124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15126 
      return
15127 
    oprot.writeStructBegin('isValidCatalogItemId_result')
15128 
    if self.success is not None:
15129 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15130 
      oprot.writeBool(self.success)
15131 
      oprot.writeFieldEnd()
15132 
    oprot.writeFieldStop()
15133 
    oprot.writeStructEnd()
15134 
 
15135 
  def validate(self):
15136 
    return
15137 
 
15138 
 
15139 
  def __repr__(self):
15140 
    L = ['%s=%r' % (key, value)
15141 
      for key, value in self.__dict__.iteritems()]
15142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15143 
 
15144 
  def __eq__(self, other):
15145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15146 
 
15147 
  def __ne__(self, other):
15148 
    return not (self == other)
6039 amit.gupta 15149 
 
15150 
class getVatPercentageForItem_args:
15151 
  """
15152 
  Attributes:
15153 
   - itemId
7330 amit.gupta 15154 
   - stateId
6039 amit.gupta 15155 
   - price
15156 
  """
15157 
 
15158 
  thrift_spec = (
15159 
    None, # 0
15160 
    (1, TType.I64, 'itemId', None, None, ), # 1
7330 amit.gupta 15161 
    (2, TType.I64, 'stateId', None, None, ), # 2
15162 
    (3, TType.DOUBLE, 'price', None, None, ), # 3
6039 amit.gupta 15163 
  )
15164 
 
7330 amit.gupta 15165 
  def __init__(self, itemId=None, stateId=None, price=None,):
6039 amit.gupta 15166 
    self.itemId = itemId
7330 amit.gupta 15167 
    self.stateId = stateId
6039 amit.gupta 15168 
    self.price = price
15169 
 
15170 
  def read(self, iprot):
15171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15173 
      return
15174 
    iprot.readStructBegin()
15175 
    while True:
15176 
      (fname, ftype, fid) = iprot.readFieldBegin()
15177 
      if ftype == TType.STOP:
15178 
        break
15179 
      if fid == 1:
15180 
        if ftype == TType.I64:
15181 
          self.itemId = iprot.readI64();
15182 
        else:
15183 
          iprot.skip(ftype)
15184 
      elif fid == 2:
7330 amit.gupta 15185 
        if ftype == TType.I64:
15186 
          self.stateId = iprot.readI64();
15187 
        else:
15188 
          iprot.skip(ftype)
15189 
      elif fid == 3:
6039 amit.gupta 15190 
        if ftype == TType.DOUBLE:
15191 
          self.price = iprot.readDouble();
15192 
        else:
15193 
          iprot.skip(ftype)
15194 
      else:
15195 
        iprot.skip(ftype)
15196 
      iprot.readFieldEnd()
15197 
    iprot.readStructEnd()
15198 
 
15199 
  def write(self, oprot):
15200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15202 
      return
15203 
    oprot.writeStructBegin('getVatPercentageForItem_args')
15204 
    if self.itemId is not None:
15205 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15206 
      oprot.writeI64(self.itemId)
15207 
      oprot.writeFieldEnd()
7330 amit.gupta 15208 
    if self.stateId is not None:
15209 
      oprot.writeFieldBegin('stateId', TType.I64, 2)
15210 
      oprot.writeI64(self.stateId)
15211 
      oprot.writeFieldEnd()
6039 amit.gupta 15212 
    if self.price is not None:
7330 amit.gupta 15213 
      oprot.writeFieldBegin('price', TType.DOUBLE, 3)
6039 amit.gupta 15214 
      oprot.writeDouble(self.price)
15215 
      oprot.writeFieldEnd()
15216 
    oprot.writeFieldStop()
15217 
    oprot.writeStructEnd()
15218 
 
15219 
  def validate(self):
15220 
    return
15221 
 
15222 
 
15223 
  def __repr__(self):
15224 
    L = ['%s=%r' % (key, value)
15225 
      for key, value in self.__dict__.iteritems()]
15226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15227 
 
15228 
  def __eq__(self, other):
15229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15230 
 
15231 
  def __ne__(self, other):
15232 
    return not (self == other)
15233 
 
15234 
class getVatPercentageForItem_result:
15235 
  """
15236 
  Attributes:
15237 
   - success
7340 amit.gupta 15238 
   - cex
6039 amit.gupta 15239 
  """
15240 
 
15241 
  thrift_spec = (
15242 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
7340 amit.gupta 15243 
    (1, TType.STRUCT, 'cex', (CatalogServiceException, CatalogServiceException.thrift_spec), None, ), # 1
6039 amit.gupta 15244 
  )
15245 
 
7340 amit.gupta 15246 
  def __init__(self, success=None, cex=None,):
6039 amit.gupta 15247 
    self.success = success
7340 amit.gupta 15248 
    self.cex = cex
6039 amit.gupta 15249 
 
15250 
  def read(self, iprot):
15251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15253 
      return
15254 
    iprot.readStructBegin()
15255 
    while True:
15256 
      (fname, ftype, fid) = iprot.readFieldBegin()
15257 
      if ftype == TType.STOP:
15258 
        break
15259 
      if fid == 0:
15260 
        if ftype == TType.DOUBLE:
15261 
          self.success = iprot.readDouble();
15262 
        else:
15263 
          iprot.skip(ftype)
7340 amit.gupta 15264 
      elif fid == 1:
15265 
        if ftype == TType.STRUCT:
15266 
          self.cex = CatalogServiceException()
15267 
          self.cex.read(iprot)
15268 
        else:
15269 
          iprot.skip(ftype)
6039 amit.gupta 15270 
      else:
15271 
        iprot.skip(ftype)
15272 
      iprot.readFieldEnd()
15273 
    iprot.readStructEnd()
15274 
 
15275 
  def write(self, oprot):
15276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15278 
      return
15279 
    oprot.writeStructBegin('getVatPercentageForItem_result')
15280 
    if self.success is not None:
15281 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15282 
      oprot.writeDouble(self.success)
15283 
      oprot.writeFieldEnd()
7340 amit.gupta 15284 
    if self.cex is not None:
15285 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
15286 
      self.cex.write(oprot)
15287 
      oprot.writeFieldEnd()
6039 amit.gupta 15288 
    oprot.writeFieldStop()
15289 
    oprot.writeStructEnd()
15290 
 
15291 
  def validate(self):
15292 
    return
15293 
 
15294 
 
15295 
  def __repr__(self):
15296 
    L = ['%s=%r' % (key, value)
15297 
      for key, value in self.__dict__.iteritems()]
15298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15299 
 
15300 
  def __eq__(self, other):
15301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15302 
 
15303 
  def __ne__(self, other):
15304 
    return not (self == other)
15305 
 
15306 
class getVatAmountForItem_args:
15307 
  """
15308 
  Attributes:
15309 
   - itemId
15310 
   - price
15311 
  """
15312 
 
15313 
  thrift_spec = (
15314 
    None, # 0
15315 
    (1, TType.I64, 'itemId', None, None, ), # 1
15316 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15317 
  )
15318 
 
15319 
  def __init__(self, itemId=None, price=None,):
15320 
    self.itemId = itemId
15321 
    self.price = price
15322 
 
15323 
  def read(self, iprot):
15324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15326 
      return
15327 
    iprot.readStructBegin()
15328 
    while True:
15329 
      (fname, ftype, fid) = iprot.readFieldBegin()
15330 
      if ftype == TType.STOP:
15331 
        break
15332 
      if fid == 1:
15333 
        if ftype == TType.I64:
15334 
          self.itemId = iprot.readI64();
15335 
        else:
15336 
          iprot.skip(ftype)
15337 
      elif fid == 2:
15338 
        if ftype == TType.DOUBLE:
15339 
          self.price = iprot.readDouble();
15340 
        else:
15341 
          iprot.skip(ftype)
15342 
      else:
15343 
        iprot.skip(ftype)
15344 
      iprot.readFieldEnd()
15345 
    iprot.readStructEnd()
15346 
 
15347 
  def write(self, oprot):
15348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15350 
      return
15351 
    oprot.writeStructBegin('getVatAmountForItem_args')
15352 
    if self.itemId is not None:
15353 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15354 
      oprot.writeI64(self.itemId)
15355 
      oprot.writeFieldEnd()
15356 
    if self.price is not None:
15357 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15358 
      oprot.writeDouble(self.price)
15359 
      oprot.writeFieldEnd()
15360 
    oprot.writeFieldStop()
15361 
    oprot.writeStructEnd()
15362 
 
15363 
  def validate(self):
15364 
    return
15365 
 
15366 
 
15367 
  def __repr__(self):
15368 
    L = ['%s=%r' % (key, value)
15369 
      for key, value in self.__dict__.iteritems()]
15370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15371 
 
15372 
  def __eq__(self, other):
15373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15374 
 
15375 
  def __ne__(self, other):
15376 
    return not (self == other)
15377 
 
15378 
class getVatAmountForItem_result:
15379 
  """
15380 
  Attributes:
15381 
   - success
15382 
  """
15383 
 
15384 
  thrift_spec = (
15385 
    (0, TType.DOUBLE, 'success', None, None, ), # 0
15386 
  )
15387 
 
15388 
  def __init__(self, success=None,):
15389 
    self.success = success
15390 
 
15391 
  def read(self, iprot):
15392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15394 
      return
15395 
    iprot.readStructBegin()
15396 
    while True:
15397 
      (fname, ftype, fid) = iprot.readFieldBegin()
15398 
      if ftype == TType.STOP:
15399 
        break
15400 
      if fid == 0:
15401 
        if ftype == TType.DOUBLE:
15402 
          self.success = iprot.readDouble();
15403 
        else:
15404 
          iprot.skip(ftype)
15405 
      else:
15406 
        iprot.skip(ftype)
15407 
      iprot.readFieldEnd()
15408 
    iprot.readStructEnd()
15409 
 
15410 
  def write(self, oprot):
15411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15413 
      return
15414 
    oprot.writeStructBegin('getVatAmountForItem_result')
15415 
    if self.success is not None:
15416 
      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
15417 
      oprot.writeDouble(self.success)
15418 
      oprot.writeFieldEnd()
15419 
    oprot.writeFieldStop()
15420 
    oprot.writeStructEnd()
15421 
 
15422 
  def validate(self):
15423 
    return
15424 
 
15425 
 
15426 
  def __repr__(self):
15427 
    L = ['%s=%r' % (key, value)
15428 
      for key, value in self.__dict__.iteritems()]
15429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15430 
 
15431 
  def __eq__(self, other):
15432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15433 
 
15434 
  def __ne__(self, other):
15435 
    return not (self == other)
6531 vikram.rag 15436 
 
15437 
class getAllIgnoredInventoryUpdateItemsList_args:
15438 
  """
15439 
  Attributes:
15440 
   - offset
15441 
   - limit
15442 
  """
15443 
 
15444 
  thrift_spec = (
15445 
    None, # 0
15446 
    (1, TType.I32, 'offset', None, None, ), # 1
15447 
    (2, TType.I32, 'limit', None, None, ), # 2
15448 
  )
15449 
 
15450 
  def __init__(self, offset=None, limit=None,):
15451 
    self.offset = offset
15452 
    self.limit = limit
15453 
 
15454 
  def read(self, iprot):
15455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15457 
      return
15458 
    iprot.readStructBegin()
15459 
    while True:
15460 
      (fname, ftype, fid) = iprot.readFieldBegin()
15461 
      if ftype == TType.STOP:
15462 
        break
15463 
      if fid == 1:
15464 
        if ftype == TType.I32:
15465 
          self.offset = iprot.readI32();
15466 
        else:
15467 
          iprot.skip(ftype)
15468 
      elif fid == 2:
15469 
        if ftype == TType.I32:
15470 
          self.limit = iprot.readI32();
15471 
        else:
15472 
          iprot.skip(ftype)
15473 
      else:
15474 
        iprot.skip(ftype)
15475 
      iprot.readFieldEnd()
15476 
    iprot.readStructEnd()
15477 
 
15478 
  def write(self, oprot):
15479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15481 
      return
15482 
    oprot.writeStructBegin('getAllIgnoredInventoryUpdateItemsList_args')
15483 
    if self.offset is not None:
15484 
      oprot.writeFieldBegin('offset', TType.I32, 1)
15485 
      oprot.writeI32(self.offset)
15486 
      oprot.writeFieldEnd()
15487 
    if self.limit is not None:
15488 
      oprot.writeFieldBegin('limit', TType.I32, 2)
15489 
      oprot.writeI32(self.limit)
15490 
      oprot.writeFieldEnd()
15491 
    oprot.writeFieldStop()
15492 
    oprot.writeStructEnd()
15493 
 
15494 
  def validate(self):
15495 
    return
15496 
 
15497 
 
15498 
  def __repr__(self):
15499 
    L = ['%s=%r' % (key, value)
15500 
      for key, value in self.__dict__.iteritems()]
15501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15502 
 
15503 
  def __eq__(self, other):
15504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15505 
 
15506 
  def __ne__(self, other):
15507 
    return not (self == other)
15508 
 
15509 
class getAllIgnoredInventoryUpdateItemsList_result:
15510 
  """
15511 
  Attributes:
15512 
   - success
15513 
  """
15514 
 
15515 
  thrift_spec = (
15516 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15517 
  )
15518 
 
15519 
  def __init__(self, success=None,):
15520 
    self.success = success
15521 
 
15522 
  def read(self, iprot):
15523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15525 
      return
15526 
    iprot.readStructBegin()
15527 
    while True:
15528 
      (fname, ftype, fid) = iprot.readFieldBegin()
15529 
      if ftype == TType.STOP:
15530 
        break
15531 
      if fid == 0:
15532 
        if ftype == TType.LIST:
15533 
          self.success = []
7438 amit.gupta 15534 
          (_etype296, _size293) = iprot.readListBegin()
15535 
          for _i297 in xrange(_size293):
15536 
            _elem298 = Item()
15537 
            _elem298.read(iprot)
15538 
            self.success.append(_elem298)
6531 vikram.rag 15539 
          iprot.readListEnd()
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('getAllIgnoredInventoryUpdateItemsList_result')
15552 
    if self.success is not None:
15553 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15554 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15555 
      for iter299 in self.success:
15556 
        iter299.write(oprot)
6531 vikram.rag 15557 
      oprot.writeListEnd()
15558 
      oprot.writeFieldEnd()
15559 
    oprot.writeFieldStop()
15560 
    oprot.writeStructEnd()
15561 
 
15562 
  def validate(self):
15563 
    return
15564 
 
15565 
 
15566 
  def __repr__(self):
15567 
    L = ['%s=%r' % (key, value)
15568 
      for key, value in self.__dict__.iteritems()]
15569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15570 
 
15571 
  def __eq__(self, other):
15572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15573 
 
15574 
  def __ne__(self, other):
15575 
    return not (self == other)
6805 anupam.sin 15576 
 
6821 amar.kumar 15577 
class getAllAliveItems_args:
15578 
 
15579 
  thrift_spec = (
15580 
  )
15581 
 
15582 
  def read(self, iprot):
15583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15585 
      return
15586 
    iprot.readStructBegin()
15587 
    while True:
15588 
      (fname, ftype, fid) = iprot.readFieldBegin()
15589 
      if ftype == TType.STOP:
15590 
        break
15591 
      else:
15592 
        iprot.skip(ftype)
15593 
      iprot.readFieldEnd()
15594 
    iprot.readStructEnd()
15595 
 
15596 
  def write(self, oprot):
15597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15599 
      return
15600 
    oprot.writeStructBegin('getAllAliveItems_args')
15601 
    oprot.writeFieldStop()
15602 
    oprot.writeStructEnd()
15603 
 
15604 
  def validate(self):
15605 
    return
15606 
 
15607 
 
15608 
  def __repr__(self):
15609 
    L = ['%s=%r' % (key, value)
15610 
      for key, value in self.__dict__.iteritems()]
15611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15612 
 
15613 
  def __eq__(self, other):
15614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15615 
 
15616 
  def __ne__(self, other):
15617 
    return not (self == other)
15618 
 
15619 
class getAllAliveItems_result:
15620 
  """
15621 
  Attributes:
15622 
   - success
15623 
  """
15624 
 
15625 
  thrift_spec = (
15626 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
15627 
  )
15628 
 
15629 
  def __init__(self, success=None,):
15630 
    self.success = success
15631 
 
15632 
  def read(self, iprot):
15633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15635 
      return
15636 
    iprot.readStructBegin()
15637 
    while True:
15638 
      (fname, ftype, fid) = iprot.readFieldBegin()
15639 
      if ftype == TType.STOP:
15640 
        break
15641 
      if fid == 0:
15642 
        if ftype == TType.LIST:
15643 
          self.success = []
7438 amit.gupta 15644 
          (_etype303, _size300) = iprot.readListBegin()
15645 
          for _i304 in xrange(_size300):
15646 
            _elem305 = Item()
15647 
            _elem305.read(iprot)
15648 
            self.success.append(_elem305)
6821 amar.kumar 15649 
          iprot.readListEnd()
15650 
        else:
15651 
          iprot.skip(ftype)
15652 
      else:
15653 
        iprot.skip(ftype)
15654 
      iprot.readFieldEnd()
15655 
    iprot.readStructEnd()
15656 
 
15657 
  def write(self, oprot):
15658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15660 
      return
15661 
    oprot.writeStructBegin('getAllAliveItems_result')
15662 
    if self.success is not None:
15663 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15664 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 15665 
      for iter306 in self.success:
15666 
        iter306.write(oprot)
6821 amar.kumar 15667 
      oprot.writeListEnd()
15668 
      oprot.writeFieldEnd()
15669 
    oprot.writeFieldStop()
15670 
    oprot.writeStructEnd()
15671 
 
15672 
  def validate(self):
15673 
    return
15674 
 
15675 
 
15676 
  def __repr__(self):
15677 
    L = ['%s=%r' % (key, value)
15678 
      for key, value in self.__dict__.iteritems()]
15679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15680 
 
15681 
  def __eq__(self, other):
15682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15683 
 
15684 
  def __ne__(self, other):
15685 
    return not (self == other)
15686 
 
6805 anupam.sin 15687 
class getInsuranceAmount_args:
15688 
  """
15689 
  Attributes:
15690 
   - itemId
6921 anupam.sin 15691 
   - price
6805 anupam.sin 15692 
   - insurerId
15693 
   - quantity
15694 
  """
15695 
 
15696 
  thrift_spec = (
15697 
    None, # 0
15698 
    (1, TType.I64, 'itemId', None, None, ), # 1
6921 anupam.sin 15699 
    (2, TType.DOUBLE, 'price', None, None, ), # 2
15700 
    (3, TType.I64, 'insurerId', None, None, ), # 3
15701 
    (4, TType.I64, 'quantity', None, None, ), # 4
6805 anupam.sin 15702 
  )
15703 
 
6921 anupam.sin 15704 
  def __init__(self, itemId=None, price=None, insurerId=None, quantity=None,):
6805 anupam.sin 15705 
    self.itemId = itemId
6921 anupam.sin 15706 
    self.price = price
6805 anupam.sin 15707 
    self.insurerId = insurerId
15708 
    self.quantity = quantity
15709 
 
15710 
  def read(self, iprot):
15711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15713 
      return
15714 
    iprot.readStructBegin()
15715 
    while True:
15716 
      (fname, ftype, fid) = iprot.readFieldBegin()
15717 
      if ftype == TType.STOP:
15718 
        break
15719 
      if fid == 1:
15720 
        if ftype == TType.I64:
15721 
          self.itemId = iprot.readI64();
15722 
        else:
15723 
          iprot.skip(ftype)
15724 
      elif fid == 2:
6921 anupam.sin 15725 
        if ftype == TType.DOUBLE:
15726 
          self.price = iprot.readDouble();
15727 
        else:
15728 
          iprot.skip(ftype)
15729 
      elif fid == 3:
6805 anupam.sin 15730 
        if ftype == TType.I64:
15731 
          self.insurerId = iprot.readI64();
15732 
        else:
15733 
          iprot.skip(ftype)
6921 anupam.sin 15734 
      elif fid == 4:
6805 anupam.sin 15735 
        if ftype == TType.I64:
15736 
          self.quantity = iprot.readI64();
15737 
        else:
15738 
          iprot.skip(ftype)
15739 
      else:
15740 
        iprot.skip(ftype)
15741 
      iprot.readFieldEnd()
15742 
    iprot.readStructEnd()
15743 
 
15744 
  def write(self, oprot):
15745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15747 
      return
15748 
    oprot.writeStructBegin('getInsuranceAmount_args')
15749 
    if self.itemId is not None:
15750 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
15751 
      oprot.writeI64(self.itemId)
15752 
      oprot.writeFieldEnd()
6921 anupam.sin 15753 
    if self.price is not None:
15754 
      oprot.writeFieldBegin('price', TType.DOUBLE, 2)
15755 
      oprot.writeDouble(self.price)
15756 
      oprot.writeFieldEnd()
6805 anupam.sin 15757 
    if self.insurerId is not None:
6921 anupam.sin 15758 
      oprot.writeFieldBegin('insurerId', TType.I64, 3)
6805 anupam.sin 15759 
      oprot.writeI64(self.insurerId)
15760 
      oprot.writeFieldEnd()
15761 
    if self.quantity is not None:
6921 anupam.sin 15762 
      oprot.writeFieldBegin('quantity', TType.I64, 4)
6805 anupam.sin 15763 
      oprot.writeI64(self.quantity)
15764 
      oprot.writeFieldEnd()
15765 
    oprot.writeFieldStop()
15766 
    oprot.writeStructEnd()
15767 
 
15768 
  def validate(self):
15769 
    return
15770 
 
15771 
 
15772 
  def __repr__(self):
15773 
    L = ['%s=%r' % (key, value)
15774 
      for key, value in self.__dict__.iteritems()]
15775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15776 
 
15777 
  def __eq__(self, other):
15778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15779 
 
15780 
  def __ne__(self, other):
15781 
    return not (self == other)
15782 
 
15783 
class getInsuranceAmount_result:
15784 
  """
15785 
  Attributes:
15786 
   - success
15787 
  """
15788 
 
15789 
  thrift_spec = (
15790 
    (0, TType.I64, 'success', None, None, ), # 0
15791 
  )
15792 
 
15793 
  def __init__(self, success=None,):
15794 
    self.success = success
15795 
 
15796 
  def read(self, iprot):
15797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15799 
      return
15800 
    iprot.readStructBegin()
15801 
    while True:
15802 
      (fname, ftype, fid) = iprot.readFieldBegin()
15803 
      if ftype == TType.STOP:
15804 
        break
15805 
      if fid == 0:
15806 
        if ftype == TType.I64:
15807 
          self.success = iprot.readI64();
15808 
        else:
15809 
          iprot.skip(ftype)
15810 
      else:
15811 
        iprot.skip(ftype)
15812 
      iprot.readFieldEnd()
15813 
    iprot.readStructEnd()
15814 
 
15815 
  def write(self, oprot):
15816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15818 
      return
15819 
    oprot.writeStructBegin('getInsuranceAmount_result')
15820 
    if self.success is not None:
15821 
      oprot.writeFieldBegin('success', TType.I64, 0)
15822 
      oprot.writeI64(self.success)
15823 
      oprot.writeFieldEnd()
15824 
    oprot.writeFieldStop()
15825 
    oprot.writeStructEnd()
15826 
 
15827 
  def validate(self):
15828 
    return
15829 
 
15830 
 
15831 
  def __repr__(self):
15832 
    L = ['%s=%r' % (key, value)
15833 
      for key, value in self.__dict__.iteritems()]
15834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15835 
 
15836 
  def __eq__(self, other):
15837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15838 
 
15839 
  def __ne__(self, other):
15840 
    return not (self == other)
15841 
 
15842 
class getInsurer_args:
15843 
  """
15844 
  Attributes:
15845 
   - insurerId
15846 
  """
15847 
 
15848 
  thrift_spec = (
15849 
    None, # 0
15850 
    (1, TType.I64, 'insurerId', None, None, ), # 1
15851 
  )
15852 
 
15853 
  def __init__(self, insurerId=None,):
15854 
    self.insurerId = insurerId
15855 
 
15856 
  def read(self, iprot):
15857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15859 
      return
15860 
    iprot.readStructBegin()
15861 
    while True:
15862 
      (fname, ftype, fid) = iprot.readFieldBegin()
15863 
      if ftype == TType.STOP:
15864 
        break
15865 
      if fid == 1:
15866 
        if ftype == TType.I64:
15867 
          self.insurerId = iprot.readI64();
15868 
        else:
15869 
          iprot.skip(ftype)
15870 
      else:
15871 
        iprot.skip(ftype)
15872 
      iprot.readFieldEnd()
15873 
    iprot.readStructEnd()
15874 
 
15875 
  def write(self, oprot):
15876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15878 
      return
15879 
    oprot.writeStructBegin('getInsurer_args')
15880 
    if self.insurerId is not None:
15881 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
15882 
      oprot.writeI64(self.insurerId)
15883 
      oprot.writeFieldEnd()
15884 
    oprot.writeFieldStop()
15885 
    oprot.writeStructEnd()
15886 
 
15887 
  def validate(self):
15888 
    return
15889 
 
15890 
 
15891 
  def __repr__(self):
15892 
    L = ['%s=%r' % (key, value)
15893 
      for key, value in self.__dict__.iteritems()]
15894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15895 
 
15896 
  def __eq__(self, other):
15897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15898 
 
15899 
  def __ne__(self, other):
15900 
    return not (self == other)
15901 
 
15902 
class getInsurer_result:
15903 
  """
15904 
  Attributes:
15905 
   - success
15906 
  """
15907 
 
15908 
  thrift_spec = (
15909 
    (0, TType.STRUCT, 'success', (Insurer, Insurer.thrift_spec), None, ), # 0
15910 
  )
15911 
 
15912 
  def __init__(self, success=None,):
15913 
    self.success = success
15914 
 
15915 
  def read(self, iprot):
15916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15918 
      return
15919 
    iprot.readStructBegin()
15920 
    while True:
15921 
      (fname, ftype, fid) = iprot.readFieldBegin()
15922 
      if ftype == TType.STOP:
15923 
        break
15924 
      if fid == 0:
15925 
        if ftype == TType.STRUCT:
15926 
          self.success = Insurer()
15927 
          self.success.read(iprot)
15928 
        else:
15929 
          iprot.skip(ftype)
15930 
      else:
15931 
        iprot.skip(ftype)
15932 
      iprot.readFieldEnd()
15933 
    iprot.readStructEnd()
15934 
 
15935 
  def write(self, oprot):
15936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15938 
      return
15939 
    oprot.writeStructBegin('getInsurer_result')
15940 
    if self.success is not None:
15941 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
15942 
      self.success.write(oprot)
15943 
      oprot.writeFieldEnd()
15944 
    oprot.writeFieldStop()
15945 
    oprot.writeStructEnd()
15946 
 
15947 
  def validate(self):
15948 
    return
15949 
 
15950 
 
15951 
  def __repr__(self):
15952 
    L = ['%s=%r' % (key, value)
15953 
      for key, value in self.__dict__.iteritems()]
15954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15955 
 
15956 
  def __eq__(self, other):
15957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15958 
 
15959 
  def __ne__(self, other):
15960 
    return not (self == other)
6838 vikram.rag 15961 
 
15962 
class getAllInsurers_args:
15963 
 
15964 
  thrift_spec = (
15965 
  )
15966 
 
15967 
  def read(self, iprot):
15968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15970 
      return
15971 
    iprot.readStructBegin()
15972 
    while True:
15973 
      (fname, ftype, fid) = iprot.readFieldBegin()
15974 
      if ftype == TType.STOP:
15975 
        break
15976 
      else:
15977 
        iprot.skip(ftype)
15978 
      iprot.readFieldEnd()
15979 
    iprot.readStructEnd()
15980 
 
15981 
  def write(self, oprot):
15982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15984 
      return
15985 
    oprot.writeStructBegin('getAllInsurers_args')
15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
16003 
 
16004 
class getAllInsurers_result:
16005 
  """
16006 
  Attributes:
16007 
   - success
16008 
  """
16009 
 
16010 
  thrift_spec = (
16011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Insurer, Insurer.thrift_spec)), None, ), # 0
16012 
  )
16013 
 
16014 
  def __init__(self, success=None,):
16015 
    self.success = success
16016 
 
16017 
  def read(self, iprot):
16018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16020 
      return
16021 
    iprot.readStructBegin()
16022 
    while True:
16023 
      (fname, ftype, fid) = iprot.readFieldBegin()
16024 
      if ftype == TType.STOP:
16025 
        break
16026 
      if fid == 0:
16027 
        if ftype == TType.LIST:
16028 
          self.success = []
7438 amit.gupta 16029 
          (_etype310, _size307) = iprot.readListBegin()
16030 
          for _i311 in xrange(_size307):
16031 
            _elem312 = Insurer()
16032 
            _elem312.read(iprot)
16033 
            self.success.append(_elem312)
6838 vikram.rag 16034 
          iprot.readListEnd()
16035 
        else:
16036 
          iprot.skip(ftype)
16037 
      else:
16038 
        iprot.skip(ftype)
16039 
      iprot.readFieldEnd()
16040 
    iprot.readStructEnd()
16041 
 
16042 
  def write(self, oprot):
16043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16045 
      return
16046 
    oprot.writeStructBegin('getAllInsurers_result')
16047 
    if self.success is not None:
16048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16050 
      for iter313 in self.success:
16051 
        iter313.write(oprot)
6838 vikram.rag 16052 
      oprot.writeListEnd()
16053 
      oprot.writeFieldEnd()
16054 
    oprot.writeFieldStop()
16055 
    oprot.writeStructEnd()
16056 
 
16057 
  def validate(self):
16058 
    return
16059 
 
16060 
 
16061 
  def __repr__(self):
16062 
    L = ['%s=%r' % (key, value)
16063 
      for key, value in self.__dict__.iteritems()]
16064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16065 
 
16066 
  def __eq__(self, other):
16067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16068 
 
16069 
  def __ne__(self, other):
16070 
    return not (self == other)
6962 rajveer 16071 
 
16072 
class updateInsuranceDeclaredAmount_args:
16073 
  """
16074 
  Attributes:
16075 
   - insurerId
16076 
   - amount
16077 
  """
16078 
 
16079 
  thrift_spec = (
16080 
    None, # 0
16081 
    (1, TType.I64, 'insurerId', None, None, ), # 1
16082 
    (2, TType.DOUBLE, 'amount', None, None, ), # 2
16083 
  )
16084 
 
16085 
  def __init__(self, insurerId=None, amount=None,):
16086 
    self.insurerId = insurerId
16087 
    self.amount = amount
16088 
 
16089 
  def read(self, iprot):
16090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16092 
      return
16093 
    iprot.readStructBegin()
16094 
    while True:
16095 
      (fname, ftype, fid) = iprot.readFieldBegin()
16096 
      if ftype == TType.STOP:
16097 
        break
16098 
      if fid == 1:
16099 
        if ftype == TType.I64:
16100 
          self.insurerId = iprot.readI64();
16101 
        else:
16102 
          iprot.skip(ftype)
16103 
      elif fid == 2:
16104 
        if ftype == TType.DOUBLE:
16105 
          self.amount = iprot.readDouble();
16106 
        else:
16107 
          iprot.skip(ftype)
16108 
      else:
16109 
        iprot.skip(ftype)
16110 
      iprot.readFieldEnd()
16111 
    iprot.readStructEnd()
16112 
 
16113 
  def write(self, oprot):
16114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16116 
      return
16117 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_args')
16118 
    if self.insurerId is not None:
16119 
      oprot.writeFieldBegin('insurerId', TType.I64, 1)
16120 
      oprot.writeI64(self.insurerId)
16121 
      oprot.writeFieldEnd()
16122 
    if self.amount is not None:
16123 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 2)
16124 
      oprot.writeDouble(self.amount)
16125 
      oprot.writeFieldEnd()
16126 
    oprot.writeFieldStop()
16127 
    oprot.writeStructEnd()
16128 
 
16129 
  def validate(self):
16130 
    return
16131 
 
16132 
 
16133 
  def __repr__(self):
16134 
    L = ['%s=%r' % (key, value)
16135 
      for key, value in self.__dict__.iteritems()]
16136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16137 
 
16138 
  def __eq__(self, other):
16139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16140 
 
16141 
  def __ne__(self, other):
16142 
    return not (self == other)
16143 
 
16144 
class updateInsuranceDeclaredAmount_result:
16145 
 
16146 
  thrift_spec = (
16147 
  )
16148 
 
16149 
  def read(self, iprot):
16150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16152 
      return
16153 
    iprot.readStructBegin()
16154 
    while True:
16155 
      (fname, ftype, fid) = iprot.readFieldBegin()
16156 
      if ftype == TType.STOP:
16157 
        break
16158 
      else:
16159 
        iprot.skip(ftype)
16160 
      iprot.readFieldEnd()
16161 
    iprot.readStructEnd()
16162 
 
16163 
  def write(self, oprot):
16164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16166 
      return
16167 
    oprot.writeStructBegin('updateInsuranceDeclaredAmount_result')
16168 
    oprot.writeFieldStop()
16169 
    oprot.writeStructEnd()
16170 
 
16171 
  def validate(self):
16172 
    return
16173 
 
16174 
 
16175 
  def __repr__(self):
16176 
    L = ['%s=%r' % (key, value)
16177 
      for key, value in self.__dict__.iteritems()]
16178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16179 
 
16180 
  def __eq__(self, other):
16181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16182 
 
16183 
  def __ne__(self, other):
16184 
    return not (self == other)
7190 amar.kumar 16185 
 
16186 
class getFreebieForItem_args:
16187 
  """
16188 
  Attributes:
16189 
   - itemId
16190 
  """
16191 
 
16192 
  thrift_spec = (
16193 
    None, # 0
16194 
    (1, TType.I64, 'itemId', None, None, ), # 1
16195 
  )
16196 
 
16197 
  def __init__(self, itemId=None,):
16198 
    self.itemId = itemId
16199 
 
16200 
  def read(self, iprot):
16201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16203 
      return
16204 
    iprot.readStructBegin()
16205 
    while True:
16206 
      (fname, ftype, fid) = iprot.readFieldBegin()
16207 
      if ftype == TType.STOP:
16208 
        break
16209 
      if fid == 1:
16210 
        if ftype == TType.I64:
16211 
          self.itemId = iprot.readI64();
16212 
        else:
16213 
          iprot.skip(ftype)
16214 
      else:
16215 
        iprot.skip(ftype)
16216 
      iprot.readFieldEnd()
16217 
    iprot.readStructEnd()
16218 
 
16219 
  def write(self, oprot):
16220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16222 
      return
16223 
    oprot.writeStructBegin('getFreebieForItem_args')
16224 
    if self.itemId is not None:
16225 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16226 
      oprot.writeI64(self.itemId)
16227 
      oprot.writeFieldEnd()
16228 
    oprot.writeFieldStop()
16229 
    oprot.writeStructEnd()
16230 
 
16231 
  def validate(self):
16232 
    return
16233 
 
16234 
 
16235 
  def __repr__(self):
16236 
    L = ['%s=%r' % (key, value)
16237 
      for key, value in self.__dict__.iteritems()]
16238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16239 
 
16240 
  def __eq__(self, other):
16241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16242 
 
16243 
  def __ne__(self, other):
16244 
    return not (self == other)
16245 
 
16246 
class getFreebieForItem_result:
16247 
  """
16248 
  Attributes:
16249 
   - success
16250 
  """
16251 
 
16252 
  thrift_spec = (
16253 
    (0, TType.I64, 'success', None, None, ), # 0
16254 
  )
16255 
 
16256 
  def __init__(self, success=None,):
16257 
    self.success = success
16258 
 
16259 
  def read(self, iprot):
16260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16262 
      return
16263 
    iprot.readStructBegin()
16264 
    while True:
16265 
      (fname, ftype, fid) = iprot.readFieldBegin()
16266 
      if ftype == TType.STOP:
16267 
        break
16268 
      if fid == 0:
16269 
        if ftype == TType.I64:
16270 
          self.success = iprot.readI64();
16271 
        else:
16272 
          iprot.skip(ftype)
16273 
      else:
16274 
        iprot.skip(ftype)
16275 
      iprot.readFieldEnd()
16276 
    iprot.readStructEnd()
16277 
 
16278 
  def write(self, oprot):
16279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16281 
      return
16282 
    oprot.writeStructBegin('getFreebieForItem_result')
16283 
    if self.success is not None:
16284 
      oprot.writeFieldBegin('success', TType.I64, 0)
16285 
      oprot.writeI64(self.success)
16286 
      oprot.writeFieldEnd()
16287 
    oprot.writeFieldStop()
16288 
    oprot.writeStructEnd()
16289 
 
16290 
  def validate(self):
16291 
    return
16292 
 
16293 
 
16294 
  def __repr__(self):
16295 
    L = ['%s=%r' % (key, value)
16296 
      for key, value in self.__dict__.iteritems()]
16297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16298 
 
16299 
  def __eq__(self, other):
16300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16301 
 
16302 
  def __ne__(self, other):
16303 
    return not (self == other)
16304 
 
16305 
class addOrUpdateFreebieForItem_args:
16306 
  """
16307 
  Attributes:
16308 
   - freebieItem
16309 
  """
16310 
 
16311 
  thrift_spec = (
16312 
    None, # 0
16313 
    (1, TType.STRUCT, 'freebieItem', (FreebieItem, FreebieItem.thrift_spec), None, ), # 1
16314 
  )
16315 
 
16316 
  def __init__(self, freebieItem=None,):
16317 
    self.freebieItem = freebieItem
16318 
 
16319 
  def read(self, iprot):
16320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16322 
      return
16323 
    iprot.readStructBegin()
16324 
    while True:
16325 
      (fname, ftype, fid) = iprot.readFieldBegin()
16326 
      if ftype == TType.STOP:
16327 
        break
16328 
      if fid == 1:
16329 
        if ftype == TType.STRUCT:
16330 
          self.freebieItem = FreebieItem()
16331 
          self.freebieItem.read(iprot)
16332 
        else:
16333 
          iprot.skip(ftype)
16334 
      else:
16335 
        iprot.skip(ftype)
16336 
      iprot.readFieldEnd()
16337 
    iprot.readStructEnd()
16338 
 
16339 
  def write(self, oprot):
16340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16342 
      return
16343 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_args')
16344 
    if self.freebieItem is not None:
16345 
      oprot.writeFieldBegin('freebieItem', TType.STRUCT, 1)
16346 
      self.freebieItem.write(oprot)
16347 
      oprot.writeFieldEnd()
16348 
    oprot.writeFieldStop()
16349 
    oprot.writeStructEnd()
16350 
 
16351 
  def validate(self):
16352 
    return
16353 
 
16354 
 
16355 
  def __repr__(self):
16356 
    L = ['%s=%r' % (key, value)
16357 
      for key, value in self.__dict__.iteritems()]
16358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16359 
 
16360 
  def __eq__(self, other):
16361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16362 
 
16363 
  def __ne__(self, other):
16364 
    return not (self == other)
16365 
 
16366 
class addOrUpdateFreebieForItem_result:
16367 
 
16368 
  thrift_spec = (
16369 
  )
16370 
 
16371 
  def read(self, iprot):
16372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16374 
      return
16375 
    iprot.readStructBegin()
16376 
    while True:
16377 
      (fname, ftype, fid) = iprot.readFieldBegin()
16378 
      if ftype == TType.STOP:
16379 
        break
16380 
      else:
16381 
        iprot.skip(ftype)
16382 
      iprot.readFieldEnd()
16383 
    iprot.readStructEnd()
16384 
 
16385 
  def write(self, oprot):
16386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16388 
      return
16389 
    oprot.writeStructBegin('addOrUpdateFreebieForItem_result')
16390 
    oprot.writeFieldStop()
16391 
    oprot.writeStructEnd()
16392 
 
16393 
  def validate(self):
16394 
    return
16395 
 
16396 
 
16397 
  def __repr__(self):
16398 
    L = ['%s=%r' % (key, value)
16399 
      for key, value in self.__dict__.iteritems()]
16400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16401 
 
16402 
  def __eq__(self, other):
16403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16404 
 
16405 
  def __ne__(self, other):
16406 
    return not (self == other)
7256 rajveer 16407 
 
7272 amit.gupta 16408 
class addOrUpdateBrandInfo_args:
16409 
  """
16410 
  Attributes:
16411 
   - brandInfo
16412 
  """
16413 
 
16414 
  thrift_spec = (
16415 
    None, # 0
16416 
    (1, TType.STRUCT, 'brandInfo', (BrandInfo, BrandInfo.thrift_spec), None, ), # 1
16417 
  )
16418 
 
16419 
  def __init__(self, brandInfo=None,):
16420 
    self.brandInfo = brandInfo
16421 
 
16422 
  def read(self, iprot):
16423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16425 
      return
16426 
    iprot.readStructBegin()
16427 
    while True:
16428 
      (fname, ftype, fid) = iprot.readFieldBegin()
16429 
      if ftype == TType.STOP:
16430 
        break
16431 
      if fid == 1:
16432 
        if ftype == TType.STRUCT:
16433 
          self.brandInfo = BrandInfo()
16434 
          self.brandInfo.read(iprot)
16435 
        else:
16436 
          iprot.skip(ftype)
16437 
      else:
16438 
        iprot.skip(ftype)
16439 
      iprot.readFieldEnd()
16440 
    iprot.readStructEnd()
16441 
 
16442 
  def write(self, oprot):
16443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16445 
      return
16446 
    oprot.writeStructBegin('addOrUpdateBrandInfo_args')
16447 
    if self.brandInfo is not None:
16448 
      oprot.writeFieldBegin('brandInfo', TType.STRUCT, 1)
16449 
      self.brandInfo.write(oprot)
16450 
      oprot.writeFieldEnd()
16451 
    oprot.writeFieldStop()
16452 
    oprot.writeStructEnd()
16453 
 
16454 
  def validate(self):
16455 
    return
16456 
 
16457 
 
16458 
  def __repr__(self):
16459 
    L = ['%s=%r' % (key, value)
16460 
      for key, value in self.__dict__.iteritems()]
16461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16462 
 
16463 
  def __eq__(self, other):
16464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16465 
 
16466 
  def __ne__(self, other):
16467 
    return not (self == other)
16468 
 
16469 
class addOrUpdateBrandInfo_result:
16470 
 
16471 
  thrift_spec = (
16472 
  )
16473 
 
16474 
  def read(self, iprot):
16475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16477 
      return
16478 
    iprot.readStructBegin()
16479 
    while True:
16480 
      (fname, ftype, fid) = iprot.readFieldBegin()
16481 
      if ftype == TType.STOP:
16482 
        break
16483 
      else:
16484 
        iprot.skip(ftype)
16485 
      iprot.readFieldEnd()
16486 
    iprot.readStructEnd()
16487 
 
16488 
  def write(self, oprot):
16489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16491 
      return
16492 
    oprot.writeStructBegin('addOrUpdateBrandInfo_result')
16493 
    oprot.writeFieldStop()
16494 
    oprot.writeStructEnd()
16495 
 
16496 
  def validate(self):
16497 
    return
16498 
 
16499 
 
16500 
  def __repr__(self):
16501 
    L = ['%s=%r' % (key, value)
16502 
      for key, value in self.__dict__.iteritems()]
16503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16504 
 
16505 
  def __eq__(self, other):
16506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16507 
 
16508 
  def __ne__(self, other):
16509 
    return not (self == other)
16510 
 
16511 
class getBrandInfo_args:
16512 
 
16513 
  thrift_spec = (
16514 
  )
16515 
 
16516 
  def read(self, iprot):
16517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16519 
      return
16520 
    iprot.readStructBegin()
16521 
    while True:
16522 
      (fname, ftype, fid) = iprot.readFieldBegin()
16523 
      if ftype == TType.STOP:
16524 
        break
16525 
      else:
16526 
        iprot.skip(ftype)
16527 
      iprot.readFieldEnd()
16528 
    iprot.readStructEnd()
16529 
 
16530 
  def write(self, oprot):
16531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16533 
      return
16534 
    oprot.writeStructBegin('getBrandInfo_args')
16535 
    oprot.writeFieldStop()
16536 
    oprot.writeStructEnd()
16537 
 
16538 
  def validate(self):
16539 
    return
16540 
 
16541 
 
16542 
  def __repr__(self):
16543 
    L = ['%s=%r' % (key, value)
16544 
      for key, value in self.__dict__.iteritems()]
16545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16546 
 
16547 
  def __eq__(self, other):
16548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16549 
 
16550 
  def __ne__(self, other):
16551 
    return not (self == other)
16552 
 
16553 
class getBrandInfo_result:
16554 
  """
16555 
  Attributes:
16556 
   - success
16557 
  """
16558 
 
16559 
  thrift_spec = (
16560 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRUCT,(BrandInfo, BrandInfo.thrift_spec)), None, ), # 0
16561 
  )
16562 
 
16563 
  def __init__(self, success=None,):
16564 
    self.success = success
16565 
 
16566 
  def read(self, iprot):
16567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16569 
      return
16570 
    iprot.readStructBegin()
16571 
    while True:
16572 
      (fname, ftype, fid) = iprot.readFieldBegin()
16573 
      if ftype == TType.STOP:
16574 
        break
16575 
      if fid == 0:
16576 
        if ftype == TType.MAP:
16577 
          self.success = {}
7438 amit.gupta 16578 
          (_ktype315, _vtype316, _size314 ) = iprot.readMapBegin()
16579 
          for _i318 in xrange(_size314):
16580 
            _key319 = iprot.readString();
16581 
            _val320 = BrandInfo()
16582 
            _val320.read(iprot)
16583 
            self.success[_key319] = _val320
7272 amit.gupta 16584 
          iprot.readMapEnd()
16585 
        else:
16586 
          iprot.skip(ftype)
16587 
      else:
16588 
        iprot.skip(ftype)
16589 
      iprot.readFieldEnd()
16590 
    iprot.readStructEnd()
16591 
 
16592 
  def write(self, oprot):
16593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16595 
      return
16596 
    oprot.writeStructBegin('getBrandInfo_result')
16597 
    if self.success is not None:
16598 
      oprot.writeFieldBegin('success', TType.MAP, 0)
16599 
      oprot.writeMapBegin(TType.STRING, TType.STRUCT, len(self.success))
7438 amit.gupta 16600 
      for kiter321,viter322 in self.success.items():
16601 
        oprot.writeString(kiter321)
16602 
        viter322.write(oprot)
7272 amit.gupta 16603 
      oprot.writeMapEnd()
16604 
      oprot.writeFieldEnd()
16605 
    oprot.writeFieldStop()
16606 
    oprot.writeStructEnd()
16607 
 
16608 
  def validate(self):
16609 
    return
16610 
 
16611 
 
16612 
  def __repr__(self):
16613 
    L = ['%s=%r' % (key, value)
16614 
      for key, value in self.__dict__.iteritems()]
16615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16616 
 
16617 
  def __eq__(self, other):
16618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16619 
 
16620 
  def __ne__(self, other):
16621 
    return not (self == other)
16622 
 
7256 rajveer 16623 
class getStorePricing_args:
16624 
  """
16625 
  Attributes:
16626 
   - itemId
16627 
  """
16628 
 
16629 
  thrift_spec = (
16630 
    None, # 0
16631 
    (1, TType.I64, 'itemId', None, None, ), # 1
16632 
  )
16633 
 
16634 
  def __init__(self, itemId=None,):
16635 
    self.itemId = itemId
16636 
 
16637 
  def read(self, iprot):
16638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16640 
      return
16641 
    iprot.readStructBegin()
16642 
    while True:
16643 
      (fname, ftype, fid) = iprot.readFieldBegin()
16644 
      if ftype == TType.STOP:
16645 
        break
16646 
      if fid == 1:
16647 
        if ftype == TType.I64:
16648 
          self.itemId = iprot.readI64();
16649 
        else:
16650 
          iprot.skip(ftype)
16651 
      else:
16652 
        iprot.skip(ftype)
16653 
      iprot.readFieldEnd()
16654 
    iprot.readStructEnd()
16655 
 
16656 
  def write(self, oprot):
16657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16659 
      return
16660 
    oprot.writeStructBegin('getStorePricing_args')
16661 
    if self.itemId is not None:
16662 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
16663 
      oprot.writeI64(self.itemId)
16664 
      oprot.writeFieldEnd()
16665 
    oprot.writeFieldStop()
16666 
    oprot.writeStructEnd()
16667 
 
16668 
  def validate(self):
16669 
    return
16670 
 
16671 
 
16672 
  def __repr__(self):
16673 
    L = ['%s=%r' % (key, value)
16674 
      for key, value in self.__dict__.iteritems()]
16675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16676 
 
16677 
  def __eq__(self, other):
16678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16679 
 
16680 
  def __ne__(self, other):
16681 
    return not (self == other)
16682 
 
16683 
class getStorePricing_result:
16684 
  """
16685 
  Attributes:
16686 
   - success
16687 
  """
16688 
 
16689 
  thrift_spec = (
16690 
    (0, TType.STRUCT, 'success', (StorePricing, StorePricing.thrift_spec), None, ), # 0
16691 
  )
16692 
 
16693 
  def __init__(self, success=None,):
16694 
    self.success = success
16695 
 
16696 
  def read(self, iprot):
16697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16699 
      return
16700 
    iprot.readStructBegin()
16701 
    while True:
16702 
      (fname, ftype, fid) = iprot.readFieldBegin()
16703 
      if ftype == TType.STOP:
16704 
        break
16705 
      if fid == 0:
16706 
        if ftype == TType.STRUCT:
16707 
          self.success = StorePricing()
16708 
          self.success.read(iprot)
16709 
        else:
16710 
          iprot.skip(ftype)
16711 
      else:
16712 
        iprot.skip(ftype)
16713 
      iprot.readFieldEnd()
16714 
    iprot.readStructEnd()
16715 
 
16716 
  def write(self, oprot):
16717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16719 
      return
16720 
    oprot.writeStructBegin('getStorePricing_result')
16721 
    if self.success is not None:
16722 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
16723 
      self.success.write(oprot)
16724 
      oprot.writeFieldEnd()
16725 
    oprot.writeFieldStop()
16726 
    oprot.writeStructEnd()
16727 
 
16728 
  def validate(self):
16729 
    return
16730 
 
16731 
 
16732 
  def __repr__(self):
16733 
    L = ['%s=%r' % (key, value)
16734 
      for key, value in self.__dict__.iteritems()]
16735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16736 
 
16737 
  def __eq__(self, other):
16738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16739 
 
16740 
  def __ne__(self, other):
16741 
    return not (self == other)
7265 rajveer 16742 
 
7306 rajveer 16743 
class getStorePricings_args:
16744 
  """
16745 
  Attributes:
16746 
   - itemIds
16747 
  """
16748 
 
16749 
  thrift_spec = (
16750 
    None, # 0
16751 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
16752 
  )
16753 
 
16754 
  def __init__(self, itemIds=None,):
16755 
    self.itemIds = itemIds
16756 
 
16757 
  def read(self, iprot):
16758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16760 
      return
16761 
    iprot.readStructBegin()
16762 
    while True:
16763 
      (fname, ftype, fid) = iprot.readFieldBegin()
16764 
      if ftype == TType.STOP:
16765 
        break
16766 
      if fid == 1:
16767 
        if ftype == TType.LIST:
16768 
          self.itemIds = []
7438 amit.gupta 16769 
          (_etype326, _size323) = iprot.readListBegin()
16770 
          for _i327 in xrange(_size323):
16771 
            _elem328 = iprot.readI64();
16772 
            self.itemIds.append(_elem328)
7306 rajveer 16773 
          iprot.readListEnd()
16774 
        else:
16775 
          iprot.skip(ftype)
16776 
      else:
16777 
        iprot.skip(ftype)
16778 
      iprot.readFieldEnd()
16779 
    iprot.readStructEnd()
16780 
 
16781 
  def write(self, oprot):
16782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16784 
      return
16785 
    oprot.writeStructBegin('getStorePricings_args')
16786 
    if self.itemIds is not None:
16787 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
16788 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
7438 amit.gupta 16789 
      for iter329 in self.itemIds:
16790 
        oprot.writeI64(iter329)
7306 rajveer 16791 
      oprot.writeListEnd()
16792 
      oprot.writeFieldEnd()
16793 
    oprot.writeFieldStop()
16794 
    oprot.writeStructEnd()
16795 
 
16796 
  def validate(self):
16797 
    return
16798 
 
16799 
 
16800 
  def __repr__(self):
16801 
    L = ['%s=%r' % (key, value)
16802 
      for key, value in self.__dict__.iteritems()]
16803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16804 
 
16805 
  def __eq__(self, other):
16806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16807 
 
16808 
  def __ne__(self, other):
16809 
    return not (self == other)
16810 
 
16811 
class getStorePricings_result:
16812 
  """
16813 
  Attributes:
16814 
   - success
16815 
  """
16816 
 
16817 
  thrift_spec = (
16818 
    (0, TType.LIST, 'success', (TType.STRUCT,(StorePricing, StorePricing.thrift_spec)), None, ), # 0
16819 
  )
16820 
 
16821 
  def __init__(self, success=None,):
16822 
    self.success = success
16823 
 
16824 
  def read(self, iprot):
16825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16827 
      return
16828 
    iprot.readStructBegin()
16829 
    while True:
16830 
      (fname, ftype, fid) = iprot.readFieldBegin()
16831 
      if ftype == TType.STOP:
16832 
        break
16833 
      if fid == 0:
16834 
        if ftype == TType.LIST:
16835 
          self.success = []
7438 amit.gupta 16836 
          (_etype333, _size330) = iprot.readListBegin()
16837 
          for _i334 in xrange(_size330):
16838 
            _elem335 = StorePricing()
16839 
            _elem335.read(iprot)
16840 
            self.success.append(_elem335)
7306 rajveer 16841 
          iprot.readListEnd()
16842 
        else:
16843 
          iprot.skip(ftype)
16844 
      else:
16845 
        iprot.skip(ftype)
16846 
      iprot.readFieldEnd()
16847 
    iprot.readStructEnd()
16848 
 
16849 
  def write(self, oprot):
16850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16852 
      return
16853 
    oprot.writeStructBegin('getStorePricings_result')
16854 
    if self.success is not None:
16855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 16857 
      for iter336 in self.success:
16858 
        iter336.write(oprot)
7306 rajveer 16859 
      oprot.writeListEnd()
16860 
      oprot.writeFieldEnd()
16861 
    oprot.writeFieldStop()
16862 
    oprot.writeStructEnd()
16863 
 
16864 
  def validate(self):
16865 
    return
16866 
 
16867 
 
16868 
  def __repr__(self):
16869 
    L = ['%s=%r' % (key, value)
16870 
      for key, value in self.__dict__.iteritems()]
16871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16872 
 
16873 
  def __eq__(self, other):
16874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16875 
 
16876 
  def __ne__(self, other):
16877 
    return not (self == other)
16878 
 
7265 rajveer 16879 
class updateStorePricing_args:
16880 
  """
16881 
  Attributes:
16882 
   - sp
7382 rajveer 16883 
   - allColors
7265 rajveer 16884 
  """
16885 
 
16886 
  thrift_spec = (
16887 
    None, # 0
16888 
    (1, TType.STRUCT, 'sp', (StorePricing, StorePricing.thrift_spec), None, ), # 1
7382 rajveer 16889 
    (2, TType.BOOL, 'allColors', None, None, ), # 2
7265 rajveer 16890 
  )
16891 
 
7382 rajveer 16892 
  def __init__(self, sp=None, allColors=None,):
7265 rajveer 16893 
    self.sp = sp
7382 rajveer 16894 
    self.allColors = allColors
7265 rajveer 16895 
 
16896 
  def read(self, iprot):
16897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16899 
      return
16900 
    iprot.readStructBegin()
16901 
    while True:
16902 
      (fname, ftype, fid) = iprot.readFieldBegin()
16903 
      if ftype == TType.STOP:
16904 
        break
16905 
      if fid == 1:
16906 
        if ftype == TType.STRUCT:
16907 
          self.sp = StorePricing()
16908 
          self.sp.read(iprot)
16909 
        else:
16910 
          iprot.skip(ftype)
7382 rajveer 16911 
      elif fid == 2:
16912 
        if ftype == TType.BOOL:
16913 
          self.allColors = iprot.readBool();
16914 
        else:
16915 
          iprot.skip(ftype)
7265 rajveer 16916 
      else:
16917 
        iprot.skip(ftype)
16918 
      iprot.readFieldEnd()
16919 
    iprot.readStructEnd()
16920 
 
16921 
  def write(self, oprot):
16922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16924 
      return
16925 
    oprot.writeStructBegin('updateStorePricing_args')
16926 
    if self.sp is not None:
16927 
      oprot.writeFieldBegin('sp', TType.STRUCT, 1)
16928 
      self.sp.write(oprot)
16929 
      oprot.writeFieldEnd()
7382 rajveer 16930 
    if self.allColors is not None:
16931 
      oprot.writeFieldBegin('allColors', TType.BOOL, 2)
16932 
      oprot.writeBool(self.allColors)
16933 
      oprot.writeFieldEnd()
7265 rajveer 16934 
    oprot.writeFieldStop()
16935 
    oprot.writeStructEnd()
16936 
 
16937 
  def validate(self):
16938 
    return
16939 
 
16940 
 
16941 
  def __repr__(self):
16942 
    L = ['%s=%r' % (key, value)
16943 
      for key, value in self.__dict__.iteritems()]
16944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16945 
 
16946 
  def __eq__(self, other):
16947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16948 
 
16949 
  def __ne__(self, other):
16950 
    return not (self == other)
16951 
 
16952 
class updateStorePricing_result:
16953 
 
16954 
  thrift_spec = (
16955 
  )
16956 
 
16957 
  def read(self, iprot):
16958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16960 
      return
16961 
    iprot.readStructBegin()
16962 
    while True:
16963 
      (fname, ftype, fid) = iprot.readFieldBegin()
16964 
      if ftype == TType.STOP:
16965 
        break
16966 
      else:
16967 
        iprot.skip(ftype)
16968 
      iprot.readFieldEnd()
16969 
    iprot.readStructEnd()
16970 
 
16971 
  def write(self, oprot):
16972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16974 
      return
16975 
    oprot.writeStructBegin('updateStorePricing_result')
16976 
    oprot.writeFieldStop()
16977 
    oprot.writeStructEnd()
16978 
 
16979 
  def validate(self):
16980 
    return
16981 
 
16982 
 
16983 
  def __repr__(self):
16984 
    L = ['%s=%r' % (key, value)
16985 
      for key, value in self.__dict__.iteritems()]
16986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16987 
 
16988 
  def __eq__(self, other):
16989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16990 
 
16991 
  def __ne__(self, other):
16992 
    return not (self == other)
7281 kshitij.so 16993 
 
16994 
class getAllAmazonListedItems_args:
16995 
 
16996 
  thrift_spec = (
16997 
  )
16998 
 
16999 
  def read(self, iprot):
17000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17002 
      return
17003 
    iprot.readStructBegin()
17004 
    while True:
17005 
      (fname, ftype, fid) = iprot.readFieldBegin()
17006 
      if ftype == TType.STOP:
17007 
        break
17008 
      else:
17009 
        iprot.skip(ftype)
17010 
      iprot.readFieldEnd()
17011 
    iprot.readStructEnd()
17012 
 
17013 
  def write(self, oprot):
17014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17016 
      return
17017 
    oprot.writeStructBegin('getAllAmazonListedItems_args')
17018 
    oprot.writeFieldStop()
17019 
    oprot.writeStructEnd()
17020 
 
17021 
  def validate(self):
17022 
    return
17023 
 
17024 
 
17025 
  def __repr__(self):
17026 
    L = ['%s=%r' % (key, value)
17027 
      for key, value in self.__dict__.iteritems()]
17028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17029 
 
17030 
  def __eq__(self, other):
17031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17032 
 
17033 
  def __ne__(self, other):
17034 
    return not (self == other)
17035 
 
17036 
class getAllAmazonListedItems_result:
17037 
  """
17038 
  Attributes:
17039 
   - success
17040 
  """
17041 
 
17042 
  thrift_spec = (
17043 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17044 
  )
17045 
 
17046 
  def __init__(self, success=None,):
17047 
    self.success = success
17048 
 
17049 
  def read(self, iprot):
17050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17052 
      return
17053 
    iprot.readStructBegin()
17054 
    while True:
17055 
      (fname, ftype, fid) = iprot.readFieldBegin()
17056 
      if ftype == TType.STOP:
17057 
        break
17058 
      if fid == 0:
17059 
        if ftype == TType.LIST:
17060 
          self.success = []
7438 amit.gupta 17061 
          (_etype340, _size337) = iprot.readListBegin()
17062 
          for _i341 in xrange(_size337):
17063 
            _elem342 = Amazonlisted()
17064 
            _elem342.read(iprot)
17065 
            self.success.append(_elem342)
7281 kshitij.so 17066 
          iprot.readListEnd()
17067 
        else:
17068 
          iprot.skip(ftype)
17069 
      else:
17070 
        iprot.skip(ftype)
17071 
      iprot.readFieldEnd()
17072 
    iprot.readStructEnd()
17073 
 
17074 
  def write(self, oprot):
17075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17077 
      return
17078 
    oprot.writeStructBegin('getAllAmazonListedItems_result')
17079 
    if self.success is not None:
17080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17081 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17082 
      for iter343 in self.success:
17083 
        iter343.write(oprot)
7281 kshitij.so 17084 
      oprot.writeListEnd()
17085 
      oprot.writeFieldEnd()
17086 
    oprot.writeFieldStop()
17087 
    oprot.writeStructEnd()
17088 
 
17089 
  def validate(self):
17090 
    return
17091 
 
17092 
 
17093 
  def __repr__(self):
17094 
    L = ['%s=%r' % (key, value)
17095 
      for key, value in self.__dict__.iteritems()]
17096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17097 
 
17098 
  def __eq__(self, other):
17099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17100 
 
17101 
  def __ne__(self, other):
17102 
    return not (self == other)
17103 
 
17104 
class getAmazonItemDetails_args:
17105 
  """
17106 
  Attributes:
17107 
   - itemId
17108 
  """
17109 
 
17110 
  thrift_spec = (
17111 
    None, # 0
17112 
    (1, TType.I64, 'itemId', None, None, ), # 1
17113 
  )
17114 
 
17115 
  def __init__(self, itemId=None,):
17116 
    self.itemId = itemId
17117 
 
17118 
  def read(self, iprot):
17119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17121 
      return
17122 
    iprot.readStructBegin()
17123 
    while True:
17124 
      (fname, ftype, fid) = iprot.readFieldBegin()
17125 
      if ftype == TType.STOP:
17126 
        break
17127 
      if fid == 1:
17128 
        if ftype == TType.I64:
17129 
          self.itemId = iprot.readI64();
17130 
        else:
17131 
          iprot.skip(ftype)
17132 
      else:
17133 
        iprot.skip(ftype)
17134 
      iprot.readFieldEnd()
17135 
    iprot.readStructEnd()
17136 
 
17137 
  def write(self, oprot):
17138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17140 
      return
17141 
    oprot.writeStructBegin('getAmazonItemDetails_args')
17142 
    if self.itemId is not None:
17143 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17144 
      oprot.writeI64(self.itemId)
17145 
      oprot.writeFieldEnd()
17146 
    oprot.writeFieldStop()
17147 
    oprot.writeStructEnd()
17148 
 
17149 
  def validate(self):
17150 
    return
17151 
 
17152 
 
17153 
  def __repr__(self):
17154 
    L = ['%s=%r' % (key, value)
17155 
      for key, value in self.__dict__.iteritems()]
17156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17157 
 
17158 
  def __eq__(self, other):
17159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17160 
 
17161 
  def __ne__(self, other):
17162 
    return not (self == other)
17163 
 
17164 
class getAmazonItemDetails_result:
17165 
  """
17166 
  Attributes:
17167 
   - success
17168 
  """
17169 
 
17170 
  thrift_spec = (
17171 
    (0, TType.STRUCT, 'success', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 0
17172 
  )
17173 
 
17174 
  def __init__(self, success=None,):
17175 
    self.success = success
17176 
 
17177 
  def read(self, iprot):
17178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17180 
      return
17181 
    iprot.readStructBegin()
17182 
    while True:
17183 
      (fname, ftype, fid) = iprot.readFieldBegin()
17184 
      if ftype == TType.STOP:
17185 
        break
17186 
      if fid == 0:
17187 
        if ftype == TType.STRUCT:
17188 
          self.success = Amazonlisted()
17189 
          self.success.read(iprot)
17190 
        else:
17191 
          iprot.skip(ftype)
17192 
      else:
17193 
        iprot.skip(ftype)
17194 
      iprot.readFieldEnd()
17195 
    iprot.readStructEnd()
17196 
 
17197 
  def write(self, oprot):
17198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17200 
      return
17201 
    oprot.writeStructBegin('getAmazonItemDetails_result')
17202 
    if self.success is not None:
17203 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
17204 
      self.success.write(oprot)
17205 
      oprot.writeFieldEnd()
17206 
    oprot.writeFieldStop()
17207 
    oprot.writeStructEnd()
17208 
 
17209 
  def validate(self):
17210 
    return
17211 
 
17212 
 
17213 
  def __repr__(self):
17214 
    L = ['%s=%r' % (key, value)
17215 
      for key, value in self.__dict__.iteritems()]
17216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17217 
 
17218 
  def __eq__(self, other):
17219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17220 
 
17221 
  def __ne__(self, other):
17222 
    return not (self == other)
17223 
 
17224 
class updateAmazonItemDetails_args:
17225 
  """
17226 
  Attributes:
17227 
   - itemId
17228 
   - fbaPrice
17229 
   - sellingPrice
17230 
   - isFba
17231 
   - isNonFba
17232 
   - isInventoryOverride
7367 kshitij.so 17233 
   - handlingTime
17234 
   - isCustomTime
7281 kshitij.so 17235 
  """
17236 
 
17237 
  thrift_spec = (
17238 
    None, # 0
17239 
    (1, TType.I64, 'itemId', None, None, ), # 1
17240 
    (2, TType.DOUBLE, 'fbaPrice', None, None, ), # 2
17241 
    (3, TType.DOUBLE, 'sellingPrice', None, None, ), # 3
17242 
    (4, TType.BOOL, 'isFba', None, None, ), # 4
17243 
    (5, TType.BOOL, 'isNonFba', None, None, ), # 5
17244 
    (6, TType.BOOL, 'isInventoryOverride', None, None, ), # 6
7367 kshitij.so 17245 
    (7, TType.I64, 'handlingTime', None, None, ), # 7
17246 
    (8, TType.BOOL, 'isCustomTime', None, None, ), # 8
7281 kshitij.so 17247 
  )
17248 
 
7367 kshitij.so 17249 
  def __init__(self, itemId=None, fbaPrice=None, sellingPrice=None, isFba=None, isNonFba=None, isInventoryOverride=None, handlingTime=None, isCustomTime=None,):
7281 kshitij.so 17250 
    self.itemId = itemId
17251 
    self.fbaPrice = fbaPrice
17252 
    self.sellingPrice = sellingPrice
17253 
    self.isFba = isFba
17254 
    self.isNonFba = isNonFba
17255 
    self.isInventoryOverride = isInventoryOverride
7367 kshitij.so 17256 
    self.handlingTime = handlingTime
17257 
    self.isCustomTime = isCustomTime
7281 kshitij.so 17258 
 
17259 
  def read(self, iprot):
17260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17262 
      return
17263 
    iprot.readStructBegin()
17264 
    while True:
17265 
      (fname, ftype, fid) = iprot.readFieldBegin()
17266 
      if ftype == TType.STOP:
17267 
        break
17268 
      if fid == 1:
17269 
        if ftype == TType.I64:
17270 
          self.itemId = iprot.readI64();
17271 
        else:
17272 
          iprot.skip(ftype)
17273 
      elif fid == 2:
17274 
        if ftype == TType.DOUBLE:
17275 
          self.fbaPrice = iprot.readDouble();
17276 
        else:
17277 
          iprot.skip(ftype)
17278 
      elif fid == 3:
17279 
        if ftype == TType.DOUBLE:
17280 
          self.sellingPrice = iprot.readDouble();
17281 
        else:
17282 
          iprot.skip(ftype)
17283 
      elif fid == 4:
17284 
        if ftype == TType.BOOL:
17285 
          self.isFba = iprot.readBool();
17286 
        else:
17287 
          iprot.skip(ftype)
17288 
      elif fid == 5:
17289 
        if ftype == TType.BOOL:
17290 
          self.isNonFba = iprot.readBool();
17291 
        else:
17292 
          iprot.skip(ftype)
17293 
      elif fid == 6:
17294 
        if ftype == TType.BOOL:
17295 
          self.isInventoryOverride = iprot.readBool();
17296 
        else:
17297 
          iprot.skip(ftype)
7367 kshitij.so 17298 
      elif fid == 7:
17299 
        if ftype == TType.I64:
17300 
          self.handlingTime = iprot.readI64();
17301 
        else:
17302 
          iprot.skip(ftype)
17303 
      elif fid == 8:
17304 
        if ftype == TType.BOOL:
17305 
          self.isCustomTime = iprot.readBool();
17306 
        else:
17307 
          iprot.skip(ftype)
7281 kshitij.so 17308 
      else:
17309 
        iprot.skip(ftype)
17310 
      iprot.readFieldEnd()
17311 
    iprot.readStructEnd()
17312 
 
17313 
  def write(self, oprot):
17314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17316 
      return
17317 
    oprot.writeStructBegin('updateAmazonItemDetails_args')
17318 
    if self.itemId is not None:
17319 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17320 
      oprot.writeI64(self.itemId)
17321 
      oprot.writeFieldEnd()
17322 
    if self.fbaPrice is not None:
17323 
      oprot.writeFieldBegin('fbaPrice', TType.DOUBLE, 2)
17324 
      oprot.writeDouble(self.fbaPrice)
17325 
      oprot.writeFieldEnd()
17326 
    if self.sellingPrice is not None:
17327 
      oprot.writeFieldBegin('sellingPrice', TType.DOUBLE, 3)
17328 
      oprot.writeDouble(self.sellingPrice)
17329 
      oprot.writeFieldEnd()
17330 
    if self.isFba is not None:
17331 
      oprot.writeFieldBegin('isFba', TType.BOOL, 4)
17332 
      oprot.writeBool(self.isFba)
17333 
      oprot.writeFieldEnd()
17334 
    if self.isNonFba is not None:
17335 
      oprot.writeFieldBegin('isNonFba', TType.BOOL, 5)
17336 
      oprot.writeBool(self.isNonFba)
17337 
      oprot.writeFieldEnd()
17338 
    if self.isInventoryOverride is not None:
17339 
      oprot.writeFieldBegin('isInventoryOverride', TType.BOOL, 6)
17340 
      oprot.writeBool(self.isInventoryOverride)
17341 
      oprot.writeFieldEnd()
7367 kshitij.so 17342 
    if self.handlingTime is not None:
17343 
      oprot.writeFieldBegin('handlingTime', TType.I64, 7)
17344 
      oprot.writeI64(self.handlingTime)
17345 
      oprot.writeFieldEnd()
17346 
    if self.isCustomTime is not None:
17347 
      oprot.writeFieldBegin('isCustomTime', TType.BOOL, 8)
17348 
      oprot.writeBool(self.isCustomTime)
17349 
      oprot.writeFieldEnd()
7281 kshitij.so 17350 
    oprot.writeFieldStop()
17351 
    oprot.writeStructEnd()
17352 
 
17353 
  def validate(self):
17354 
    return
17355 
 
17356 
 
17357 
  def __repr__(self):
17358 
    L = ['%s=%r' % (key, value)
17359 
      for key, value in self.__dict__.iteritems()]
17360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17361 
 
17362 
  def __eq__(self, other):
17363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17364 
 
17365 
  def __ne__(self, other):
17366 
    return not (self == other)
17367 
 
17368 
class updateAmazonItemDetails_result:
17369 
 
17370 
  thrift_spec = (
17371 
  )
17372 
 
17373 
  def read(self, iprot):
17374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17376 
      return
17377 
    iprot.readStructBegin()
17378 
    while True:
17379 
      (fname, ftype, fid) = iprot.readFieldBegin()
17380 
      if ftype == TType.STOP:
17381 
        break
17382 
      else:
17383 
        iprot.skip(ftype)
17384 
      iprot.readFieldEnd()
17385 
    iprot.readStructEnd()
17386 
 
17387 
  def write(self, oprot):
17388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17390 
      return
17391 
    oprot.writeStructBegin('updateAmazonItemDetails_result')
17392 
    oprot.writeFieldStop()
17393 
    oprot.writeStructEnd()
17394 
 
17395 
  def validate(self):
17396 
    return
17397 
 
17398 
 
17399 
  def __repr__(self):
17400 
    L = ['%s=%r' % (key, value)
17401 
      for key, value in self.__dict__.iteritems()]
17402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17403 
 
17404 
  def __eq__(self, other):
17405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17406 
 
17407 
  def __ne__(self, other):
17408 
    return not (self == other)
17409 
 
17410 
class addAmazonItem_args:
17411 
  """
17412 
  Attributes:
17413 
   - amazonlisted
17414 
  """
17415 
 
17416 
  thrift_spec = (
17417 
    None, # 0
17418 
    (1, TType.STRUCT, 'amazonlisted', (Amazonlisted, Amazonlisted.thrift_spec), None, ), # 1
17419 
  )
17420 
 
17421 
  def __init__(self, amazonlisted=None,):
17422 
    self.amazonlisted = amazonlisted
17423 
 
17424 
  def read(self, iprot):
17425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17427 
      return
17428 
    iprot.readStructBegin()
17429 
    while True:
17430 
      (fname, ftype, fid) = iprot.readFieldBegin()
17431 
      if ftype == TType.STOP:
17432 
        break
17433 
      if fid == 1:
17434 
        if ftype == TType.STRUCT:
17435 
          self.amazonlisted = Amazonlisted()
17436 
          self.amazonlisted.read(iprot)
17437 
        else:
17438 
          iprot.skip(ftype)
17439 
      else:
17440 
        iprot.skip(ftype)
17441 
      iprot.readFieldEnd()
17442 
    iprot.readStructEnd()
17443 
 
17444 
  def write(self, oprot):
17445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17447 
      return
17448 
    oprot.writeStructBegin('addAmazonItem_args')
17449 
    if self.amazonlisted is not None:
17450 
      oprot.writeFieldBegin('amazonlisted', TType.STRUCT, 1)
17451 
      self.amazonlisted.write(oprot)
17452 
      oprot.writeFieldEnd()
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 addAmazonItem_result:
17472 
 
17473 
  thrift_spec = (
17474 
  )
17475 
 
17476 
  def read(self, iprot):
17477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17479 
      return
17480 
    iprot.readStructBegin()
17481 
    while True:
17482 
      (fname, ftype, fid) = iprot.readFieldBegin()
17483 
      if ftype == TType.STOP:
17484 
        break
17485 
      else:
17486 
        iprot.skip(ftype)
17487 
      iprot.readFieldEnd()
17488 
    iprot.readStructEnd()
17489 
 
17490 
  def write(self, oprot):
17491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17493 
      return
17494 
    oprot.writeStructBegin('addAmazonItem_result')
17495 
    oprot.writeFieldStop()
17496 
    oprot.writeStructEnd()
17497 
 
17498 
  def validate(self):
17499 
    return
17500 
 
17501 
 
17502 
  def __repr__(self):
17503 
    L = ['%s=%r' % (key, value)
17504 
      for key, value in self.__dict__.iteritems()]
17505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17506 
 
17507 
  def __eq__(self, other):
17508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17509 
 
17510 
  def __ne__(self, other):
17511 
    return not (self == other)
7291 vikram.rag 17512 
 
17513 
class getAsinItems_args:
17514 
 
17515 
  thrift_spec = (
17516 
  )
17517 
 
17518 
  def read(self, iprot):
17519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17521 
      return
17522 
    iprot.readStructBegin()
17523 
    while True:
17524 
      (fname, ftype, fid) = iprot.readFieldBegin()
17525 
      if ftype == TType.STOP:
17526 
        break
17527 
      else:
17528 
        iprot.skip(ftype)
17529 
      iprot.readFieldEnd()
17530 
    iprot.readStructEnd()
17531 
 
17532 
  def write(self, oprot):
17533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17535 
      return
17536 
    oprot.writeStructBegin('getAsinItems_args')
17537 
    oprot.writeFieldStop()
17538 
    oprot.writeStructEnd()
17539 
 
17540 
  def validate(self):
17541 
    return
17542 
 
17543 
 
17544 
  def __repr__(self):
17545 
    L = ['%s=%r' % (key, value)
17546 
      for key, value in self.__dict__.iteritems()]
17547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17548 
 
17549 
  def __eq__(self, other):
17550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17551 
 
17552 
  def __ne__(self, other):
17553 
    return not (self == other)
17554 
 
17555 
class getAsinItems_result:
17556 
  """
17557 
  Attributes:
17558 
   - success
17559 
  """
17560 
 
17561 
  thrift_spec = (
17562 
    (0, TType.LIST, 'success', (TType.STRUCT,(Item, Item.thrift_spec)), None, ), # 0
17563 
  )
17564 
 
17565 
  def __init__(self, success=None,):
17566 
    self.success = success
17567 
 
17568 
  def read(self, iprot):
17569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17571 
      return
17572 
    iprot.readStructBegin()
17573 
    while True:
17574 
      (fname, ftype, fid) = iprot.readFieldBegin()
17575 
      if ftype == TType.STOP:
17576 
        break
17577 
      if fid == 0:
17578 
        if ftype == TType.LIST:
17579 
          self.success = []
7438 amit.gupta 17580 
          (_etype347, _size344) = iprot.readListBegin()
17581 
          for _i348 in xrange(_size344):
17582 
            _elem349 = Item()
17583 
            _elem349.read(iprot)
17584 
            self.success.append(_elem349)
7291 vikram.rag 17585 
          iprot.readListEnd()
17586 
        else:
17587 
          iprot.skip(ftype)
17588 
      else:
17589 
        iprot.skip(ftype)
17590 
      iprot.readFieldEnd()
17591 
    iprot.readStructEnd()
17592 
 
17593 
  def write(self, oprot):
17594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17596 
      return
17597 
    oprot.writeStructBegin('getAsinItems_result')
17598 
    if self.success is not None:
17599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17600 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17601 
      for iter350 in self.success:
17602 
        iter350.write(oprot)
7291 vikram.rag 17603 
      oprot.writeListEnd()
17604 
      oprot.writeFieldEnd()
17605 
    oprot.writeFieldStop()
17606 
    oprot.writeStructEnd()
17607 
 
17608 
  def validate(self):
17609 
    return
17610 
 
17611 
 
17612 
  def __repr__(self):
17613 
    L = ['%s=%r' % (key, value)
17614 
      for key, value in self.__dict__.iteritems()]
17615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17616 
 
17617 
  def __eq__(self, other):
17618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17619 
 
17620 
  def __ne__(self, other):
17621 
    return not (self == other)
17622 
 
17623 
class getAllFbaListedItems_args:
17624 
 
17625 
  thrift_spec = (
17626 
  )
17627 
 
17628 
  def read(self, iprot):
17629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17631 
      return
17632 
    iprot.readStructBegin()
17633 
    while True:
17634 
      (fname, ftype, fid) = iprot.readFieldBegin()
17635 
      if ftype == TType.STOP:
17636 
        break
17637 
      else:
17638 
        iprot.skip(ftype)
17639 
      iprot.readFieldEnd()
17640 
    iprot.readStructEnd()
17641 
 
17642 
  def write(self, oprot):
17643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17645 
      return
17646 
    oprot.writeStructBegin('getAllFbaListedItems_args')
17647 
    oprot.writeFieldStop()
17648 
    oprot.writeStructEnd()
17649 
 
17650 
  def validate(self):
17651 
    return
17652 
 
17653 
 
17654 
  def __repr__(self):
17655 
    L = ['%s=%r' % (key, value)
17656 
      for key, value in self.__dict__.iteritems()]
17657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17658 
 
17659 
  def __eq__(self, other):
17660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17661 
 
17662 
  def __ne__(self, other):
17663 
    return not (self == other)
17664 
 
17665 
class getAllFbaListedItems_result:
17666 
  """
17667 
  Attributes:
17668 
   - success
17669 
  """
17670 
 
17671 
  thrift_spec = (
17672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17673 
  )
17674 
 
17675 
  def __init__(self, success=None,):
17676 
    self.success = success
17677 
 
17678 
  def read(self, iprot):
17679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17681 
      return
17682 
    iprot.readStructBegin()
17683 
    while True:
17684 
      (fname, ftype, fid) = iprot.readFieldBegin()
17685 
      if ftype == TType.STOP:
17686 
        break
17687 
      if fid == 0:
17688 
        if ftype == TType.LIST:
17689 
          self.success = []
7438 amit.gupta 17690 
          (_etype354, _size351) = iprot.readListBegin()
17691 
          for _i355 in xrange(_size351):
17692 
            _elem356 = Amazonlisted()
17693 
            _elem356.read(iprot)
17694 
            self.success.append(_elem356)
7291 vikram.rag 17695 
          iprot.readListEnd()
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      else:
17699 
        iprot.skip(ftype)
17700 
      iprot.readFieldEnd()
17701 
    iprot.readStructEnd()
17702 
 
17703 
  def write(self, oprot):
17704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17706 
      return
17707 
    oprot.writeStructBegin('getAllFbaListedItems_result')
17708 
    if self.success is not None:
17709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17711 
      for iter357 in self.success:
17712 
        iter357.write(oprot)
7291 vikram.rag 17713 
      oprot.writeListEnd()
17714 
      oprot.writeFieldEnd()
17715 
    oprot.writeFieldStop()
17716 
    oprot.writeStructEnd()
17717 
 
17718 
  def validate(self):
17719 
    return
17720 
 
17721 
 
17722 
  def __repr__(self):
17723 
    L = ['%s=%r' % (key, value)
17724 
      for key, value in self.__dict__.iteritems()]
17725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17726 
 
17727 
  def __eq__(self, other):
17728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17729 
 
17730 
  def __ne__(self, other):
17731 
    return not (self == other)
17732 
 
17733 
class getAllNonFbaListedItems_args:
17734 
 
17735 
  thrift_spec = (
17736 
  )
17737 
 
17738 
  def read(self, iprot):
17739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17741 
      return
17742 
    iprot.readStructBegin()
17743 
    while True:
17744 
      (fname, ftype, fid) = iprot.readFieldBegin()
17745 
      if ftype == TType.STOP:
17746 
        break
17747 
      else:
17748 
        iprot.skip(ftype)
17749 
      iprot.readFieldEnd()
17750 
    iprot.readStructEnd()
17751 
 
17752 
  def write(self, oprot):
17753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17755 
      return
17756 
    oprot.writeStructBegin('getAllNonFbaListedItems_args')
17757 
    oprot.writeFieldStop()
17758 
    oprot.writeStructEnd()
17759 
 
17760 
  def validate(self):
17761 
    return
17762 
 
17763 
 
17764 
  def __repr__(self):
17765 
    L = ['%s=%r' % (key, value)
17766 
      for key, value in self.__dict__.iteritems()]
17767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17768 
 
17769 
  def __eq__(self, other):
17770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17771 
 
17772 
  def __ne__(self, other):
17773 
    return not (self == other)
17774 
 
17775 
class getAllNonFbaListedItems_result:
17776 
  """
17777 
  Attributes:
17778 
   - success
17779 
  """
17780 
 
17781 
  thrift_spec = (
17782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Amazonlisted, Amazonlisted.thrift_spec)), None, ), # 0
17783 
  )
17784 
 
17785 
  def __init__(self, success=None,):
17786 
    self.success = success
17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 0:
17798 
        if ftype == TType.LIST:
17799 
          self.success = []
7438 amit.gupta 17800 
          (_etype361, _size358) = iprot.readListBegin()
17801 
          for _i362 in xrange(_size358):
17802 
            _elem363 = Amazonlisted()
17803 
            _elem363.read(iprot)
17804 
            self.success.append(_elem363)
7291 vikram.rag 17805 
          iprot.readListEnd()
17806 
        else:
17807 
          iprot.skip(ftype)
17808 
      else:
17809 
        iprot.skip(ftype)
17810 
      iprot.readFieldEnd()
17811 
    iprot.readStructEnd()
17812 
 
17813 
  def write(self, oprot):
17814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17816 
      return
17817 
    oprot.writeStructBegin('getAllNonFbaListedItems_result')
17818 
    if self.success is not None:
17819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17820 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7438 amit.gupta 17821 
      for iter364 in self.success:
17822 
        iter364.write(oprot)
7291 vikram.rag 17823 
      oprot.writeListEnd()
17824 
      oprot.writeFieldEnd()
17825 
    oprot.writeFieldStop()
17826 
    oprot.writeStructEnd()
17827 
 
17828 
  def validate(self):
17829 
    return
17830 
 
17831 
 
17832 
  def __repr__(self):
17833 
    L = ['%s=%r' % (key, value)
17834 
      for key, value in self.__dict__.iteritems()]
17835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17836 
 
17837 
  def __eq__(self, other):
17838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17839 
 
17840 
  def __ne__(self, other):
17841 
    return not (self == other)
7460 kshitij.so 17842 
 
17843 
class updateItemInventory_args:
17844 
  """
17845 
  Attributes:
17846 
   - itemId
17847 
   - holdInventory
17848 
   - defaultInventory
17849 
  """
17850 
 
17851 
  thrift_spec = (
17852 
    None, # 0
17853 
    (1, TType.I64, 'itemId', None, None, ), # 1
17854 
    (2, TType.I64, 'holdInventory', None, None, ), # 2
17855 
    (3, TType.I64, 'defaultInventory', None, None, ), # 3
17856 
  )
17857 
 
17858 
  def __init__(self, itemId=None, holdInventory=None, defaultInventory=None,):
17859 
    self.itemId = itemId
17860 
    self.holdInventory = holdInventory
17861 
    self.defaultInventory = defaultInventory
17862 
 
17863 
  def read(self, iprot):
17864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17866 
      return
17867 
    iprot.readStructBegin()
17868 
    while True:
17869 
      (fname, ftype, fid) = iprot.readFieldBegin()
17870 
      if ftype == TType.STOP:
17871 
        break
17872 
      if fid == 1:
17873 
        if ftype == TType.I64:
17874 
          self.itemId = iprot.readI64();
17875 
        else:
17876 
          iprot.skip(ftype)
17877 
      elif fid == 2:
17878 
        if ftype == TType.I64:
17879 
          self.holdInventory = iprot.readI64();
17880 
        else:
17881 
          iprot.skip(ftype)
17882 
      elif fid == 3:
17883 
        if ftype == TType.I64:
17884 
          self.defaultInventory = iprot.readI64();
17885 
        else:
17886 
          iprot.skip(ftype)
17887 
      else:
17888 
        iprot.skip(ftype)
17889 
      iprot.readFieldEnd()
17890 
    iprot.readStructEnd()
17891 
 
17892 
  def write(self, oprot):
17893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17895 
      return
17896 
    oprot.writeStructBegin('updateItemInventory_args')
17897 
    if self.itemId is not None:
17898 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
17899 
      oprot.writeI64(self.itemId)
17900 
      oprot.writeFieldEnd()
17901 
    if self.holdInventory is not None:
17902 
      oprot.writeFieldBegin('holdInventory', TType.I64, 2)
17903 
      oprot.writeI64(self.holdInventory)
17904 
      oprot.writeFieldEnd()
17905 
    if self.defaultInventory is not None:
17906 
      oprot.writeFieldBegin('defaultInventory', TType.I64, 3)
17907 
      oprot.writeI64(self.defaultInventory)
17908 
      oprot.writeFieldEnd()
17909 
    oprot.writeFieldStop()
17910 
    oprot.writeStructEnd()
17911 
 
17912 
  def validate(self):
17913 
    return
17914 
 
17915 
 
17916 
  def __repr__(self):
17917 
    L = ['%s=%r' % (key, value)
17918 
      for key, value in self.__dict__.iteritems()]
17919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17920 
 
17921 
  def __eq__(self, other):
17922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17923 
 
17924 
  def __ne__(self, other):
17925 
    return not (self == other)
17926 
 
17927 
class updateItemInventory_result:
17928 
  """
17929 
  Attributes:
17930 
   - success
17931 
  """
17932 
 
17933 
  thrift_spec = (
17934 
    (0, TType.BOOL, 'success', None, None, ), # 0
17935 
  )
17936 
 
17937 
  def __init__(self, success=None,):
17938 
    self.success = success
17939 
 
17940 
  def read(self, iprot):
17941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17943 
      return
17944 
    iprot.readStructBegin()
17945 
    while True:
17946 
      (fname, ftype, fid) = iprot.readFieldBegin()
17947 
      if ftype == TType.STOP:
17948 
        break
17949 
      if fid == 0:
17950 
        if ftype == TType.BOOL:
17951 
          self.success = iprot.readBool();
17952 
        else:
17953 
          iprot.skip(ftype)
17954 
      else:
17955 
        iprot.skip(ftype)
17956 
      iprot.readFieldEnd()
17957 
    iprot.readStructEnd()
17958 
 
17959 
  def write(self, oprot):
17960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17962 
      return
17963 
    oprot.writeStructBegin('updateItemInventory_result')
17964 
    if self.success is not None:
17965 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17966 
      oprot.writeBool(self.success)
17967 
      oprot.writeFieldEnd()
17968 
    oprot.writeFieldStop()
17969 
    oprot.writeStructEnd()
17970 
 
17971 
  def validate(self):
17972 
    return
17973 
 
17974 
 
17975 
  def __repr__(self):
17976 
    L = ['%s=%r' % (key, value)
17977 
      for key, value in self.__dict__.iteritems()]
17978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17979 
 
17980 
  def __eq__(self, other):
17981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17982 
 
17983 
  def __ne__(self, other):
17984 
    return not (self == other)