Subversion Repositories SmartDukaan

Rev

Rev 7972 | Rev 8282 | 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 addWarehouse(self, warehouse):
21 
    """
22 
    Parameters:
23 
     - warehouse
24 
    """
25 
    pass
26 
 
27 
  def addVendor(self, vendor):
28 
    """
29 
    add a new vendor
30 
 
31 
    Parameters:
32 
     - vendor
33 
    """
34 
    pass
35 
 
36 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
37 
    """
38 
    Stores the incremental warehouse updates of items.
39 
 
40 
    Parameters:
41 
     - warehouse_id
42 
     - timestamp
43 
     - availability
44 
    """
45 
    pass
46 
 
47 
  def updateInventory(self, warehouse_id, timestamp, availability):
48 
    """
49 
    Stores the final inventory stocks of items.
50 
 
51 
    Parameters:
52 
     - warehouse_id
53 
     - timestamp
54 
     - availability
55 
    """
56 
    pass
57 
 
58 
  def addInventory(self, itemId, warehouseId, quantity):
59 
    """
60 
    Add the inventory to existing stock.
61 
 
62 
    Parameters:
63 
     - itemId
64 
     - warehouseId
65 
     - quantity
66 
    """
67 
    pass
68 
 
69 
  def retireWarehouse(self, warehouse_id):
70 
    """
71 
    Parameters:
72 
     - warehouse_id
73 
    """
74 
    pass
75 
 
76 
  def getItemInventoryByItemId(self, item_id):
77 
    """
78 
    Parameters:
79 
     - item_id
80 
    """
81 
    pass
82 
 
83 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
84 
    """
85 
    Parameters:
86 
     - warehouse_id
87 
     - item_id
88 
    """
89 
    pass
90 
 
5978 rajveer 91 
  def getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 92 
    """
93 
    Determines the warehouse that should be used to fulfil an order for the given item.
94 
    It first checks all the warehouses which are in the logistics location given by the
95 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
96 
    preferred warehouse for the item is used.
97 
 
98 
    Returns an ordered list of size 4 with following elements in the given order:
99 
    1. Id of the fulfillment warehouse which was finally picked up.
100 
    2. Expected delay added by the category manager.
101 
    3. Id of the billing warehouse which was finally picked up.
102 
 
103 
    Parameters:
104 
     - itemId
5978 rajveer 105 
     - sourceId
5944 mandeep.dh 106 
    """
107 
    pass
108 
 
109 
  def getAllWarehouses(self, isActive):
110 
    """
111 
    Parameters:
112 
     - isActive
113 
    """
114 
    pass
115 
 
116 
  def getWarehouse(self, warehouse_id):
117 
    """
118 
    Returns the warehouse with the given id.
119 
 
120 
    Parameters:
121 
     - warehouse_id
122 
    """
123 
    pass
124 
 
125 
  def getAllItemsForWarehouse(self, warehouse_id):
126 
    """
127 
    Parameters:
128 
     - warehouse_id
129 
    """
130 
    pass
131 
 
5966 rajveer 132 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 133 
    """
5966 rajveer 134 
    Depending on reservation in the table, verify if we can bill this order or not.
135 
 
136 
    Parameters:
137 
     - itemId
138 
     - warehouseId
139 
     - sourceId
140 
     - orderId
141 
    """
142 
    pass
143 
 
144 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
145 
    """
5944 mandeep.dh 146 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
147 
 
148 
    Parameters:
149 
     - itemId
150 
     - warehouseId
5966 rajveer 151 
     - sourceId
152 
     - orderId
153 
     - createdTimestamp
154 
     - promisedShippingTimestamp
5944 mandeep.dh 155 
     - quantity
156 
    """
157 
    pass
158 
 
7968 amar.kumar 159 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
160 
    """
161 
    Updates the reservation for Order
162 
 
163 
    Parameters:
164 
     - itemId
165 
     - warehouseId
166 
     - sourceId
167 
     - orderId
168 
     - createdTimestamp
169 
     - promisedShippingTimestamp
170 
     - quantity
171 
    """
172 
    pass
173 
 
5966 rajveer 174 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 175 
    """
176 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
177 
 
178 
    Parameters:
179 
     - itemId
180 
     - warehouseId
5966 rajveer 181 
     - sourceId
182 
     - orderId
5944 mandeep.dh 183 
     - quantity
184 
    """
185 
    pass
186 
 
187 
  def getItemPricing(self, itemId, vendorId):
188 
    """
189 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
190 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
191 
 
192 
    Parameters:
193 
     - itemId
194 
     - vendorId
195 
    """
196 
    pass
197 
 
198 
  def getAllItemPricing(self, itemId):
199 
    """
200 
    Returns the list of vendor pricing information of an item.
201 
    Raises an exception if item not found corresponding to itemId
202 
 
203 
    Parameters:
204 
     - itemId
205 
    """
206 
    pass
207 
 
208 
  def addVendorItemPricing(self, vendorItemPricing):
209 
    """
210 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
211 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
212 
 
213 
    Parameters:
214 
     - vendorItemPricing
215 
    """
216 
    pass
217 
 
218 
  def getVendor(self, vendorId):
219 
    """
220 
    Returns a vendor given its id
221 
 
222 
    Parameters:
223 
     - vendorId
224 
    """
225 
    pass
226 
 
227 
  def getAllVendors(self, ):
228 
    """
229 
    Return list of all vendors
230 
    """
231 
    pass
232 
 
233 
  def addVendorItemMapping(self, key, vendorItemMapping):
234 
    """
235 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
236 
 
237 
    Parameters:
238 
     - key
239 
     - vendorItemMapping
240 
    """
241 
    pass
242 
 
243 
  def getVendorItemMappings(self, itemId):
244 
    """
245 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
246 
    Raises an exception if item not found corresponding to itemId
247 
 
248 
    Parameters:
249 
     - itemId
250 
    """
251 
    pass
252 
 
253 
  def getPendingOrdersInventory(self, vendorid):
254 
    """
255 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
256 
 
257 
    Parameters:
258 
     - vendorid
259 
    """
260 
    pass
261 
 
262 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
263 
    """
264 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
265 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 1 for billing warehouse 7 and shipping warehouse 7
266 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
267 
       getWarehouses(null, null, 3, 7, 7) would return all type warehouses with all type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
268 
       getWarehouses(null, null, 0, 0, 7) would return all type warehouses with all type inventory for all vendors for all billing warehouses at shipping warehouse 7
269 
 
270 
    Parameters:
271 
     - warehouseType
272 
     - inventoryType
273 
     - vendorId
274 
     - billingWarehouseId
275 
     - shippingWarehouseId
276 
    """
277 
    pass
278 
 
279 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
280 
    """
281 
    Resets availability of an item to the quantity mentioned in a warehouse.
282 
 
283 
    Parameters:
284 
     - itemKey
285 
     - vendorId
286 
     - quantity
287 
     - warehouseId
288 
    """
289 
    pass
290 
 
291 
  def resetAvailabilityForWarehouse(self, warehouseId):
292 
    """
293 
    Resets availability of a warehouse to zero.
294 
 
295 
    Parameters:
296 
     - warehouseId
297 
    """
298 
    pass
299 
 
300 
  def getItemKeysToBeProcessed(self, warehouseId):
301 
    """
302 
    Returns the list of item keys which need to be processed for a given warehouse.
303 
    This is currently used by Support application to send item keys whose inventory needs
304 
    to be updated from PLB
305 
 
306 
    Parameters:
307 
     - warehouseId
308 
    """
309 
    pass
310 
 
311 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
312 
    """
313 
    Marks/Deletes missed inventory updates for a given key and warehouse.
314 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
315 
 
316 
    Parameters:
317 
     - itemKey
318 
     - warehouseId
319 
    """
320 
    pass
321 
 
322 
  def getIgnoredItemKeys(self, ):
323 
    """
324 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
325 
    and the timestamp from where alert was raised.
326 
    """
327 
    pass
328 
 
329 
  def addBadInventory(self, itemId, warehouseId, quantity):
330 
    """
331 
    Add the BAD type inventory to existing stock.
332 
 
333 
    Parameters:
334 
     - itemId
335 
     - warehouseId
336 
     - quantity
337 
    """
338 
    pass
339 
 
340 
  def getShippingLocations(self, ):
341 
    """
342 
    Returns all shipping locations
343 
    """
344 
    pass
345 
 
346 
  def getAllVendorItemMappings(self, ):
347 
    """
348 
    Fetches all the vendor item mappings present.
349 
    """
350 
    pass
351 
 
352 
  def getInventorySnapshot(self, warehouseId):
353 
    """
354 
    Gets items' inventory for a warehouse
355 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
356 
 
357 
    Parameters:
358 
     - warehouseId
359 
    """
360 
    pass
361 
 
362 
  def clearItemAvailabilityCache(self, ):
363 
    """
364 
    Clear item availability cache.
365 
    """
366 
    pass
367 
 
368 
  def updateVendorString(self, warehouseId, vendorString):
369 
    """
370 
    Parameters:
371 
     - warehouseId
372 
     - vendorString
373 
    """
374 
    pass
375 
 
6096 amit.gupta 376 
  def clearItemAvailabilityCacheForItem(self, item_id):
377 
    """
378 
    Parameters:
379 
     - item_id
380 
    """
381 
    pass
5944 mandeep.dh 382 
 
7718 amar.kumar 383 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 384 
    """
385 
    Parameters:
386 
     - vendorId
7718 amar.kumar 387 
     - billingWarehouseId
6467 amar.kumar 388 
    """
389 
    pass
6096 amit.gupta 390 
 
6484 amar.kumar 391 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
392 
    """
393 
    Parameters:
394 
     - item_ids
395 
    """
396 
    pass
6467 amar.kumar 397 
 
6531 vikram.rag 398 
  def getMonitoredWarehouseForVendors(self, vendorIds):
399 
    """
400 
    Parameters:
401 
     - vendorIds
402 
    """
403 
    pass
6484 amar.kumar 404 
 
6531 vikram.rag 405 
  def getIgnoredWarehouseidsAndItemids(self, ):
406 
    pass
407 
 
408 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
409 
    """
410 
    Parameters:
411 
     - item_id
412 
     - warehouse_id
413 
    """
414 
    pass
415 
 
416 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
417 
    """
418 
    Parameters:
419 
     - item_id
420 
     - warehouse_id
421 
    """
422 
    pass
423 
 
424 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
425 
    pass
426 
 
427 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
428 
    """
429 
    Parameters:
430 
     - offset
431 
     - limit
432 
    """
433 
    pass
434 
 
6821 amar.kumar 435 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
436 
    """
437 
    Parameters:
438 
     - item_id
439 
     - numOfDaysStock
440 
     - minStockLevel
441 
    """
442 
    pass
6531 vikram.rag 443 
 
6821 amar.kumar 444 
  def getItemStockPurchaseParams(self, itemId):
445 
    """
446 
    Parameters:
447 
     - itemId
448 
    """
449 
    pass
450 
 
451 
  def addOosStatusForItem(self, oosStatusMap, date):
452 
    """
453 
    Parameters:
454 
     - oosStatusMap
455 
     - date
456 
    """
457 
    pass
458 
 
6832 amar.kumar 459 
  def getOosStatusesForXDaysForItem(self, itemId, days):
460 
    """
461 
    Parameters:
462 
     - itemId
463 
     - days
464 
    """
465 
    pass
6821 amar.kumar 466 
 
6857 amar.kumar 467 
  def getNonZeroItemStockPurchaseParams(self, ):
468 
    pass
6832 amar.kumar 469 
 
7149 amar.kumar 470 
  def getBillableInventoryAndPendingOrders(self, ):
471 
    """
472 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
473 
    """
474 
    pass
6857 amar.kumar 475 
 
7281 kshitij.so 476 
  def getWarehouseName(self, warehouse_id):
477 
    """
478 
    Parameters:
479 
     - warehouse_id
480 
    """
481 
    pass
7149 amar.kumar 482 
 
7281 kshitij.so 483 
  def getAmazonInventoryForItem(self, item_id):
484 
    """
485 
    Parameters:
486 
     - item_id
487 
    """
488 
    pass
489 
 
490 
  def getAllAmazonInventory(self, ):
491 
    pass
492 
 
493 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot):
494 
    """
495 
    Parameters:
496 
     - amazonInventorySnapshot
497 
    """
498 
    pass
499 
 
7972 amar.kumar 500 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
501 
    """
502 
    Parameters:
503 
     - itemId
504 
     - numberOfDays
505 
    """
506 
    pass
7281 kshitij.so 507 
 
8182 amar.kumar 508 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
509 
    """
510 
    Parameters:
511 
     - itemId
512 
     - warehouseId
513 
     - holdQuantity
514 
     - source
515 
    """
516 
    pass
7972 amar.kumar 517 
 
8182 amar.kumar 518 
 
5944 mandeep.dh 519 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
520 
  def __init__(self, iprot, oprot=None):
521 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
522 
 
523 
  def addWarehouse(self, warehouse):
524 
    """
525 
    Parameters:
526 
     - warehouse
527 
    """
528 
    self.send_addWarehouse(warehouse)
529 
    return self.recv_addWarehouse()
530 
 
531 
  def send_addWarehouse(self, warehouse):
532 
    self._oprot.writeMessageBegin('addWarehouse', TMessageType.CALL, self._seqid)
533 
    args = addWarehouse_args()
534 
    args.warehouse = warehouse
535 
    args.write(self._oprot)
536 
    self._oprot.writeMessageEnd()
537 
    self._oprot.trans.flush()
538 
 
539 
  def recv_addWarehouse(self, ):
540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
541 
    if mtype == TMessageType.EXCEPTION:
542 
      x = TApplicationException()
543 
      x.read(self._iprot)
544 
      self._iprot.readMessageEnd()
545 
      raise x
546 
    result = addWarehouse_result()
547 
    result.read(self._iprot)
548 
    self._iprot.readMessageEnd()
549 
    if result.success is not None:
550 
      return result.success
551 
    if result.cex is not None:
552 
      raise result.cex
553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addWarehouse failed: unknown result");
554 
 
555 
  def addVendor(self, vendor):
556 
    """
557 
    add a new vendor
558 
 
559 
    Parameters:
560 
     - vendor
561 
    """
562 
    self.send_addVendor(vendor)
563 
    return self.recv_addVendor()
564 
 
565 
  def send_addVendor(self, vendor):
566 
    self._oprot.writeMessageBegin('addVendor', TMessageType.CALL, self._seqid)
567 
    args = addVendor_args()
568 
    args.vendor = vendor
569 
    args.write(self._oprot)
570 
    self._oprot.writeMessageEnd()
571 
    self._oprot.trans.flush()
572 
 
573 
  def recv_addVendor(self, ):
574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
575 
    if mtype == TMessageType.EXCEPTION:
576 
      x = TApplicationException()
577 
      x.read(self._iprot)
578 
      self._iprot.readMessageEnd()
579 
      raise x
580 
    result = addVendor_result()
581 
    result.read(self._iprot)
582 
    self._iprot.readMessageEnd()
583 
    if result.success is not None:
584 
      return result.success
585 
    if result.cex is not None:
586 
      raise result.cex
587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addVendor failed: unknown result");
588 
 
589 
  def updateInventoryHistory(self, warehouse_id, timestamp, availability):
590 
    """
591 
    Stores the incremental warehouse updates of items.
592 
 
593 
    Parameters:
594 
     - warehouse_id
595 
     - timestamp
596 
     - availability
597 
    """
598 
    self.send_updateInventoryHistory(warehouse_id, timestamp, availability)
599 
    self.recv_updateInventoryHistory()
600 
 
601 
  def send_updateInventoryHistory(self, warehouse_id, timestamp, availability):
602 
    self._oprot.writeMessageBegin('updateInventoryHistory', TMessageType.CALL, self._seqid)
603 
    args = updateInventoryHistory_args()
604 
    args.warehouse_id = warehouse_id
605 
    args.timestamp = timestamp
606 
    args.availability = availability
607 
    args.write(self._oprot)
608 
    self._oprot.writeMessageEnd()
609 
    self._oprot.trans.flush()
610 
 
611 
  def recv_updateInventoryHistory(self, ):
612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
613 
    if mtype == TMessageType.EXCEPTION:
614 
      x = TApplicationException()
615 
      x.read(self._iprot)
616 
      self._iprot.readMessageEnd()
617 
      raise x
618 
    result = updateInventoryHistory_result()
619 
    result.read(self._iprot)
620 
    self._iprot.readMessageEnd()
621 
    if result.cex is not None:
622 
      raise result.cex
623 
    return
624 
 
625 
  def updateInventory(self, warehouse_id, timestamp, availability):
626 
    """
627 
    Stores the final inventory stocks of items.
628 
 
629 
    Parameters:
630 
     - warehouse_id
631 
     - timestamp
632 
     - availability
633 
    """
634 
    self.send_updateInventory(warehouse_id, timestamp, availability)
635 
    self.recv_updateInventory()
636 
 
637 
  def send_updateInventory(self, warehouse_id, timestamp, availability):
638 
    self._oprot.writeMessageBegin('updateInventory', TMessageType.CALL, self._seqid)
639 
    args = updateInventory_args()
640 
    args.warehouse_id = warehouse_id
641 
    args.timestamp = timestamp
642 
    args.availability = availability
643 
    args.write(self._oprot)
644 
    self._oprot.writeMessageEnd()
645 
    self._oprot.trans.flush()
646 
 
647 
  def recv_updateInventory(self, ):
648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
649 
    if mtype == TMessageType.EXCEPTION:
650 
      x = TApplicationException()
651 
      x.read(self._iprot)
652 
      self._iprot.readMessageEnd()
653 
      raise x
654 
    result = updateInventory_result()
655 
    result.read(self._iprot)
656 
    self._iprot.readMessageEnd()
657 
    if result.cex is not None:
658 
      raise result.cex
659 
    return
660 
 
661 
  def addInventory(self, itemId, warehouseId, quantity):
662 
    """
663 
    Add the inventory to existing stock.
664 
 
665 
    Parameters:
666 
     - itemId
667 
     - warehouseId
668 
     - quantity
669 
    """
670 
    self.send_addInventory(itemId, warehouseId, quantity)
671 
    self.recv_addInventory()
672 
 
673 
  def send_addInventory(self, itemId, warehouseId, quantity):
674 
    self._oprot.writeMessageBegin('addInventory', TMessageType.CALL, self._seqid)
675 
    args = addInventory_args()
676 
    args.itemId = itemId
677 
    args.warehouseId = warehouseId
678 
    args.quantity = quantity
679 
    args.write(self._oprot)
680 
    self._oprot.writeMessageEnd()
681 
    self._oprot.trans.flush()
682 
 
683 
  def recv_addInventory(self, ):
684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
685 
    if mtype == TMessageType.EXCEPTION:
686 
      x = TApplicationException()
687 
      x.read(self._iprot)
688 
      self._iprot.readMessageEnd()
689 
      raise x
690 
    result = addInventory_result()
691 
    result.read(self._iprot)
692 
    self._iprot.readMessageEnd()
693 
    if result.cex is not None:
694 
      raise result.cex
695 
    return
696 
 
697 
  def retireWarehouse(self, warehouse_id):
698 
    """
699 
    Parameters:
700 
     - warehouse_id
701 
    """
702 
    self.send_retireWarehouse(warehouse_id)
703 
    self.recv_retireWarehouse()
704 
 
705 
  def send_retireWarehouse(self, warehouse_id):
706 
    self._oprot.writeMessageBegin('retireWarehouse', TMessageType.CALL, self._seqid)
707 
    args = retireWarehouse_args()
708 
    args.warehouse_id = warehouse_id
709 
    args.write(self._oprot)
710 
    self._oprot.writeMessageEnd()
711 
    self._oprot.trans.flush()
712 
 
713 
  def recv_retireWarehouse(self, ):
714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
715 
    if mtype == TMessageType.EXCEPTION:
716 
      x = TApplicationException()
717 
      x.read(self._iprot)
718 
      self._iprot.readMessageEnd()
719 
      raise x
720 
    result = retireWarehouse_result()
721 
    result.read(self._iprot)
722 
    self._iprot.readMessageEnd()
723 
    if result.cex is not None:
724 
      raise result.cex
725 
    return
726 
 
727 
  def getItemInventoryByItemId(self, item_id):
728 
    """
729 
    Parameters:
730 
     - item_id
731 
    """
732 
    self.send_getItemInventoryByItemId(item_id)
733 
    return self.recv_getItemInventoryByItemId()
734 
 
735 
  def send_getItemInventoryByItemId(self, item_id):
736 
    self._oprot.writeMessageBegin('getItemInventoryByItemId', TMessageType.CALL, self._seqid)
737 
    args = getItemInventoryByItemId_args()
738 
    args.item_id = item_id
739 
    args.write(self._oprot)
740 
    self._oprot.writeMessageEnd()
741 
    self._oprot.trans.flush()
742 
 
743 
  def recv_getItemInventoryByItemId(self, ):
744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
745 
    if mtype == TMessageType.EXCEPTION:
746 
      x = TApplicationException()
747 
      x.read(self._iprot)
748 
      self._iprot.readMessageEnd()
749 
      raise x
750 
    result = getItemInventoryByItemId_result()
751 
    result.read(self._iprot)
752 
    self._iprot.readMessageEnd()
753 
    if result.success is not None:
754 
      return result.success
755 
    if result.cex is not None:
756 
      raise result.cex
757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemInventoryByItemId failed: unknown result");
758 
 
759 
  def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
760 
    """
761 
    Parameters:
762 
     - warehouse_id
763 
     - item_id
764 
    """
765 
    self.send_getItemAvailibilityAtWarehouse(warehouse_id, item_id)
766 
    return self.recv_getItemAvailibilityAtWarehouse()
767 
 
768 
  def send_getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
769 
    self._oprot.writeMessageBegin('getItemAvailibilityAtWarehouse', TMessageType.CALL, self._seqid)
770 
    args = getItemAvailibilityAtWarehouse_args()
771 
    args.warehouse_id = warehouse_id
772 
    args.item_id = item_id
773 
    args.write(self._oprot)
774 
    self._oprot.writeMessageEnd()
775 
    self._oprot.trans.flush()
776 
 
777 
  def recv_getItemAvailibilityAtWarehouse(self, ):
778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
779 
    if mtype == TMessageType.EXCEPTION:
780 
      x = TApplicationException()
781 
      x.read(self._iprot)
782 
      self._iprot.readMessageEnd()
783 
      raise x
784 
    result = getItemAvailibilityAtWarehouse_result()
785 
    result.read(self._iprot)
786 
    self._iprot.readMessageEnd()
787 
    if result.success is not None:
788 
      return result.success
789 
    if result.cex is not None:
790 
      raise result.cex
791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailibilityAtWarehouse failed: unknown result");
792 
 
5978 rajveer 793 
  def getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 794 
    """
795 
    Determines the warehouse that should be used to fulfil an order for the given item.
796 
    It first checks all the warehouses which are in the logistics location given by the
797 
    warehouse_loc parameter. If none of the warehouses there have any inventory, then the
798 
    preferred warehouse for the item is used.
799 
 
800 
    Returns an ordered list of size 4 with following elements in the given order:
801 
    1. Id of the fulfillment warehouse which was finally picked up.
802 
    2. Expected delay added by the category manager.
803 
    3. Id of the billing warehouse which was finally picked up.
804 
 
805 
    Parameters:
806 
     - itemId
5978 rajveer 807 
     - sourceId
5944 mandeep.dh 808 
    """
5978 rajveer 809 
    self.send_getItemAvailabilityAtLocation(itemId, sourceId)
5944 mandeep.dh 810 
    return self.recv_getItemAvailabilityAtLocation()
811 
 
5978 rajveer 812 
  def send_getItemAvailabilityAtLocation(self, itemId, sourceId):
5944 mandeep.dh 813 
    self._oprot.writeMessageBegin('getItemAvailabilityAtLocation', TMessageType.CALL, self._seqid)
814 
    args = getItemAvailabilityAtLocation_args()
815 
    args.itemId = itemId
5978 rajveer 816 
    args.sourceId = sourceId
5944 mandeep.dh 817 
    args.write(self._oprot)
818 
    self._oprot.writeMessageEnd()
819 
    self._oprot.trans.flush()
820 
 
821 
  def recv_getItemAvailabilityAtLocation(self, ):
822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
823 
    if mtype == TMessageType.EXCEPTION:
824 
      x = TApplicationException()
825 
      x.read(self._iprot)
826 
      self._iprot.readMessageEnd()
827 
      raise x
828 
    result = getItemAvailabilityAtLocation_result()
829 
    result.read(self._iprot)
830 
    self._iprot.readMessageEnd()
831 
    if result.success is not None:
832 
      return result.success
833 
    if result.isex is not None:
834 
      raise result.isex
835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilityAtLocation failed: unknown result");
836 
 
837 
  def getAllWarehouses(self, isActive):
838 
    """
839 
    Parameters:
840 
     - isActive
841 
    """
842 
    self.send_getAllWarehouses(isActive)
843 
    return self.recv_getAllWarehouses()
844 
 
845 
  def send_getAllWarehouses(self, isActive):
846 
    self._oprot.writeMessageBegin('getAllWarehouses', TMessageType.CALL, self._seqid)
847 
    args = getAllWarehouses_args()
848 
    args.isActive = isActive
849 
    args.write(self._oprot)
850 
    self._oprot.writeMessageEnd()
851 
    self._oprot.trans.flush()
852 
 
853 
  def recv_getAllWarehouses(self, ):
854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
855 
    if mtype == TMessageType.EXCEPTION:
856 
      x = TApplicationException()
857 
      x.read(self._iprot)
858 
      self._iprot.readMessageEnd()
859 
      raise x
860 
    result = getAllWarehouses_result()
861 
    result.read(self._iprot)
862 
    self._iprot.readMessageEnd()
863 
    if result.success is not None:
864 
      return result.success
865 
    if result.cex is not None:
866 
      raise result.cex
867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllWarehouses failed: unknown result");
868 
 
869 
  def getWarehouse(self, warehouse_id):
870 
    """
871 
    Returns the warehouse with the given id.
872 
 
873 
    Parameters:
874 
     - warehouse_id
875 
    """
876 
    self.send_getWarehouse(warehouse_id)
877 
    return self.recv_getWarehouse()
878 
 
879 
  def send_getWarehouse(self, warehouse_id):
880 
    self._oprot.writeMessageBegin('getWarehouse', TMessageType.CALL, self._seqid)
881 
    args = getWarehouse_args()
882 
    args.warehouse_id = warehouse_id
883 
    args.write(self._oprot)
884 
    self._oprot.writeMessageEnd()
885 
    self._oprot.trans.flush()
886 
 
887 
  def recv_getWarehouse(self, ):
888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
889 
    if mtype == TMessageType.EXCEPTION:
890 
      x = TApplicationException()
891 
      x.read(self._iprot)
892 
      self._iprot.readMessageEnd()
893 
      raise x
894 
    result = getWarehouse_result()
895 
    result.read(self._iprot)
896 
    self._iprot.readMessageEnd()
897 
    if result.success is not None:
898 
      return result.success
899 
    if result.cex is not None:
900 
      raise result.cex
901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouse failed: unknown result");
902 
 
903 
  def getAllItemsForWarehouse(self, warehouse_id):
904 
    """
905 
    Parameters:
906 
     - warehouse_id
907 
    """
908 
    self.send_getAllItemsForWarehouse(warehouse_id)
909 
    return self.recv_getAllItemsForWarehouse()
910 
 
911 
  def send_getAllItemsForWarehouse(self, warehouse_id):
912 
    self._oprot.writeMessageBegin('getAllItemsForWarehouse', TMessageType.CALL, self._seqid)
913 
    args = getAllItemsForWarehouse_args()
914 
    args.warehouse_id = warehouse_id
915 
    args.write(self._oprot)
916 
    self._oprot.writeMessageEnd()
917 
    self._oprot.trans.flush()
918 
 
919 
  def recv_getAllItemsForWarehouse(self, ):
920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
921 
    if mtype == TMessageType.EXCEPTION:
922 
      x = TApplicationException()
923 
      x.read(self._iprot)
924 
      self._iprot.readMessageEnd()
925 
      raise x
926 
    result = getAllItemsForWarehouse_result()
927 
    result.read(self._iprot)
928 
    self._iprot.readMessageEnd()
929 
    if result.success is not None:
930 
      return result.success
931 
    if result.cex is not None:
932 
      raise result.cex
933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemsForWarehouse failed: unknown result");
934 
 
5966 rajveer 935 
  def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
5944 mandeep.dh 936 
    """
5978 rajveer 937 
    Depending on reservation in the table, verify if we can bill this order or not.
5966 rajveer 938 
 
939 
    Parameters:
940 
     - itemId
941 
     - warehouseId
942 
     - sourceId
943 
     - orderId
944 
    """
945 
    self.send_isOrderBillable(itemId, warehouseId, sourceId, orderId)
946 
    return self.recv_isOrderBillable()
947 
 
948 
  def send_isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
949 
    self._oprot.writeMessageBegin('isOrderBillable', TMessageType.CALL, self._seqid)
950 
    args = isOrderBillable_args()
951 
    args.itemId = itemId
952 
    args.warehouseId = warehouseId
953 
    args.sourceId = sourceId
954 
    args.orderId = orderId
955 
    args.write(self._oprot)
956 
    self._oprot.writeMessageEnd()
957 
    self._oprot.trans.flush()
958 
 
959 
  def recv_isOrderBillable(self, ):
960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
961 
    if mtype == TMessageType.EXCEPTION:
962 
      x = TApplicationException()
963 
      x.read(self._iprot)
964 
      self._iprot.readMessageEnd()
965 
      raise x
966 
    result = isOrderBillable_result()
967 
    result.read(self._iprot)
968 
    self._iprot.readMessageEnd()
969 
    if result.success is not None:
970 
      return result.success
971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isOrderBillable failed: unknown result");
972 
 
973 
  def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
974 
    """
5944 mandeep.dh 975 
    Increases the reservation count for an item in a warehouse. Should always succeed normally.
976 
 
977 
    Parameters:
978 
     - itemId
979 
     - warehouseId
5966 rajveer 980 
     - sourceId
981 
     - orderId
982 
     - createdTimestamp
983 
     - promisedShippingTimestamp
5944 mandeep.dh 984 
     - quantity
985 
    """
5966 rajveer 986 
    self.send_reserveItemInWarehouse(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
5944 mandeep.dh 987 
    return self.recv_reserveItemInWarehouse()
988 
 
5966 rajveer 989 
  def send_reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
5944 mandeep.dh 990 
    self._oprot.writeMessageBegin('reserveItemInWarehouse', TMessageType.CALL, self._seqid)
991 
    args = reserveItemInWarehouse_args()
992 
    args.itemId = itemId
993 
    args.warehouseId = warehouseId
5966 rajveer 994 
    args.sourceId = sourceId
995 
    args.orderId = orderId
996 
    args.createdTimestamp = createdTimestamp
997 
    args.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 998 
    args.quantity = quantity
999 
    args.write(self._oprot)
1000 
    self._oprot.writeMessageEnd()
1001 
    self._oprot.trans.flush()
1002 
 
1003 
  def recv_reserveItemInWarehouse(self, ):
1004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1005 
    if mtype == TMessageType.EXCEPTION:
1006 
      x = TApplicationException()
1007 
      x.read(self._iprot)
1008 
      self._iprot.readMessageEnd()
1009 
      raise x
1010 
    result = reserveItemInWarehouse_result()
1011 
    result.read(self._iprot)
1012 
    self._iprot.readMessageEnd()
1013 
    if result.success is not None:
1014 
      return result.success
1015 
    if result.cex is not None:
1016 
      raise result.cex
1017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reserveItemInWarehouse failed: unknown result");
1018 
 
7968 amar.kumar 1019 
  def updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1020 
    """
1021 
    Updates the reservation for Order
1022 
 
1023 
    Parameters:
1024 
     - itemId
1025 
     - warehouseId
1026 
     - sourceId
1027 
     - orderId
1028 
     - createdTimestamp
1029 
     - promisedShippingTimestamp
1030 
     - quantity
1031 
    """
1032 
    self.send_updateReservationForOrder(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
1033 
    return self.recv_updateReservationForOrder()
1034 
 
1035 
  def send_updateReservationForOrder(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
1036 
    self._oprot.writeMessageBegin('updateReservationForOrder', TMessageType.CALL, self._seqid)
1037 
    args = updateReservationForOrder_args()
1038 
    args.itemId = itemId
1039 
    args.warehouseId = warehouseId
1040 
    args.sourceId = sourceId
1041 
    args.orderId = orderId
1042 
    args.createdTimestamp = createdTimestamp
1043 
    args.promisedShippingTimestamp = promisedShippingTimestamp
1044 
    args.quantity = quantity
1045 
    args.write(self._oprot)
1046 
    self._oprot.writeMessageEnd()
1047 
    self._oprot.trans.flush()
1048 
 
1049 
  def recv_updateReservationForOrder(self, ):
1050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1051 
    if mtype == TMessageType.EXCEPTION:
1052 
      x = TApplicationException()
1053 
      x.read(self._iprot)
1054 
      self._iprot.readMessageEnd()
1055 
      raise x
1056 
    result = updateReservationForOrder_result()
1057 
    result.read(self._iprot)
1058 
    self._iprot.readMessageEnd()
1059 
    if result.success is not None:
1060 
      return result.success
1061 
    if result.cex is not None:
1062 
      raise result.cex
1063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateReservationForOrder failed: unknown result");
1064 
 
5966 rajveer 1065 
  def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1066 
    """
1067 
    Decreases the reservation count for an item in a warehouse. Should always succeed normally.
1068 
 
1069 
    Parameters:
1070 
     - itemId
1071 
     - warehouseId
5966 rajveer 1072 
     - sourceId
1073 
     - orderId
5944 mandeep.dh 1074 
     - quantity
1075 
    """
5966 rajveer 1076 
    self.send_reduceReservationCount(itemId, warehouseId, sourceId, orderId, quantity)
5944 mandeep.dh 1077 
    return self.recv_reduceReservationCount()
1078 
 
5966 rajveer 1079 
  def send_reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
5944 mandeep.dh 1080 
    self._oprot.writeMessageBegin('reduceReservationCount', TMessageType.CALL, self._seqid)
1081 
    args = reduceReservationCount_args()
1082 
    args.itemId = itemId
1083 
    args.warehouseId = warehouseId
5966 rajveer 1084 
    args.sourceId = sourceId
1085 
    args.orderId = orderId
5944 mandeep.dh 1086 
    args.quantity = quantity
1087 
    args.write(self._oprot)
1088 
    self._oprot.writeMessageEnd()
1089 
    self._oprot.trans.flush()
1090 
 
1091 
  def recv_reduceReservationCount(self, ):
1092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1093 
    if mtype == TMessageType.EXCEPTION:
1094 
      x = TApplicationException()
1095 
      x.read(self._iprot)
1096 
      self._iprot.readMessageEnd()
1097 
      raise x
1098 
    result = reduceReservationCount_result()
1099 
    result.read(self._iprot)
1100 
    self._iprot.readMessageEnd()
1101 
    if result.success is not None:
1102 
      return result.success
1103 
    if result.cex is not None:
1104 
      raise result.cex
1105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reduceReservationCount failed: unknown result");
1106 
 
1107 
  def getItemPricing(self, itemId, vendorId):
1108 
    """
1109 
    Returns the pricing information of an item associated with the vendor of the given warehouse.
1110 
    Raises an exception if either the item, vendor or the associated pricing information can't be found.
1111 
 
1112 
    Parameters:
1113 
     - itemId
1114 
     - vendorId
1115 
    """
1116 
    self.send_getItemPricing(itemId, vendorId)
1117 
    return self.recv_getItemPricing()
1118 
 
1119 
  def send_getItemPricing(self, itemId, vendorId):
1120 
    self._oprot.writeMessageBegin('getItemPricing', TMessageType.CALL, self._seqid)
1121 
    args = getItemPricing_args()
1122 
    args.itemId = itemId
1123 
    args.vendorId = vendorId
1124 
    args.write(self._oprot)
1125 
    self._oprot.writeMessageEnd()
1126 
    self._oprot.trans.flush()
1127 
 
1128 
  def recv_getItemPricing(self, ):
1129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1130 
    if mtype == TMessageType.EXCEPTION:
1131 
      x = TApplicationException()
1132 
      x.read(self._iprot)
1133 
      self._iprot.readMessageEnd()
1134 
      raise x
1135 
    result = getItemPricing_result()
1136 
    result.read(self._iprot)
1137 
    self._iprot.readMessageEnd()
1138 
    if result.success is not None:
1139 
      return result.success
1140 
    if result.cex is not None:
1141 
      raise result.cex
1142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemPricing failed: unknown result");
1143 
 
1144 
  def getAllItemPricing(self, itemId):
1145 
    """
1146 
    Returns the list of vendor pricing information of an item.
1147 
    Raises an exception if item not found corresponding to itemId
1148 
 
1149 
    Parameters:
1150 
     - itemId
1151 
    """
1152 
    self.send_getAllItemPricing(itemId)
1153 
    return self.recv_getAllItemPricing()
1154 
 
1155 
  def send_getAllItemPricing(self, itemId):
1156 
    self._oprot.writeMessageBegin('getAllItemPricing', TMessageType.CALL, self._seqid)
1157 
    args = getAllItemPricing_args()
1158 
    args.itemId = itemId
1159 
    args.write(self._oprot)
1160 
    self._oprot.writeMessageEnd()
1161 
    self._oprot.trans.flush()
1162 
 
1163 
  def recv_getAllItemPricing(self, ):
1164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1165 
    if mtype == TMessageType.EXCEPTION:
1166 
      x = TApplicationException()
1167 
      x.read(self._iprot)
1168 
      self._iprot.readMessageEnd()
1169 
      raise x
1170 
    result = getAllItemPricing_result()
1171 
    result.read(self._iprot)
1172 
    self._iprot.readMessageEnd()
1173 
    if result.success is not None:
1174 
      return result.success
1175 
    if result.cex is not None:
1176 
      raise result.cex
1177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllItemPricing failed: unknown result");
1178 
 
1179 
  def addVendorItemPricing(self, vendorItemPricing):
1180 
    """
1181 
    Adds vendor prices corresponding to the item. If pricing already exists then updates the prices.
1182 
    Raises an exception if either the item or vendor can't be found corresponding to their ids.
1183 
 
1184 
    Parameters:
1185 
     - vendorItemPricing
1186 
    """
1187 
    self.send_addVendorItemPricing(vendorItemPricing)
1188 
    self.recv_addVendorItemPricing()
1189 
 
1190 
  def send_addVendorItemPricing(self, vendorItemPricing):
1191 
    self._oprot.writeMessageBegin('addVendorItemPricing', TMessageType.CALL, self._seqid)
1192 
    args = addVendorItemPricing_args()
1193 
    args.vendorItemPricing = vendorItemPricing
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_addVendorItemPricing(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = addVendorItemPricing_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.cex is not None:
1209 
      raise result.cex
1210 
    return
1211 
 
1212 
  def getVendor(self, vendorId):
1213 
    """
1214 
    Returns a vendor given its id
1215 
 
1216 
    Parameters:
1217 
     - vendorId
1218 
    """
1219 
    self.send_getVendor(vendorId)
1220 
    return self.recv_getVendor()
1221 
 
1222 
  def send_getVendor(self, vendorId):
1223 
    self._oprot.writeMessageBegin('getVendor', TMessageType.CALL, self._seqid)
1224 
    args = getVendor_args()
1225 
    args.vendorId = vendorId
1226 
    args.write(self._oprot)
1227 
    self._oprot.writeMessageEnd()
1228 
    self._oprot.trans.flush()
1229 
 
1230 
  def recv_getVendor(self, ):
1231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1232 
    if mtype == TMessageType.EXCEPTION:
1233 
      x = TApplicationException()
1234 
      x.read(self._iprot)
1235 
      self._iprot.readMessageEnd()
1236 
      raise x
1237 
    result = getVendor_result()
1238 
    result.read(self._iprot)
1239 
    self._iprot.readMessageEnd()
1240 
    if result.success is not None:
1241 
      return result.success
1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendor failed: unknown result");
1243 
 
1244 
  def getAllVendors(self, ):
1245 
    """
1246 
    Return list of all vendors
1247 
    """
1248 
    self.send_getAllVendors()
1249 
    return self.recv_getAllVendors()
1250 
 
1251 
  def send_getAllVendors(self, ):
1252 
    self._oprot.writeMessageBegin('getAllVendors', TMessageType.CALL, self._seqid)
1253 
    args = getAllVendors_args()
1254 
    args.write(self._oprot)
1255 
    self._oprot.writeMessageEnd()
1256 
    self._oprot.trans.flush()
1257 
 
1258 
  def recv_getAllVendors(self, ):
1259 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1260 
    if mtype == TMessageType.EXCEPTION:
1261 
      x = TApplicationException()
1262 
      x.read(self._iprot)
1263 
      self._iprot.readMessageEnd()
1264 
      raise x
1265 
    result = getAllVendors_result()
1266 
    result.read(self._iprot)
1267 
    self._iprot.readMessageEnd()
1268 
    if result.success is not None:
1269 
      return result.success
1270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendors failed: unknown result");
1271 
 
1272 
  def addVendorItemMapping(self, key, vendorItemMapping):
1273 
    """
1274 
    Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
1275 
 
1276 
    Parameters:
1277 
     - key
1278 
     - vendorItemMapping
1279 
    """
1280 
    self.send_addVendorItemMapping(key, vendorItemMapping)
1281 
    self.recv_addVendorItemMapping()
1282 
 
1283 
  def send_addVendorItemMapping(self, key, vendorItemMapping):
1284 
    self._oprot.writeMessageBegin('addVendorItemMapping', TMessageType.CALL, self._seqid)
1285 
    args = addVendorItemMapping_args()
1286 
    args.key = key
1287 
    args.vendorItemMapping = vendorItemMapping
1288 
    args.write(self._oprot)
1289 
    self._oprot.writeMessageEnd()
1290 
    self._oprot.trans.flush()
1291 
 
1292 
  def recv_addVendorItemMapping(self, ):
1293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1294 
    if mtype == TMessageType.EXCEPTION:
1295 
      x = TApplicationException()
1296 
      x.read(self._iprot)
1297 
      self._iprot.readMessageEnd()
1298 
      raise x
1299 
    result = addVendorItemMapping_result()
1300 
    result.read(self._iprot)
1301 
    self._iprot.readMessageEnd()
1302 
    if result.cex is not None:
1303 
      raise result.cex
1304 
    return
1305 
 
1306 
  def getVendorItemMappings(self, itemId):
1307 
    """
1308 
    Returns the list of vendor item mapping corresponding to itemId passed as parameter.
1309 
    Raises an exception if item not found corresponding to itemId
1310 
 
1311 
    Parameters:
1312 
     - itemId
1313 
    """
1314 
    self.send_getVendorItemMappings(itemId)
1315 
    return self.recv_getVendorItemMappings()
1316 
 
1317 
  def send_getVendorItemMappings(self, itemId):
1318 
    self._oprot.writeMessageBegin('getVendorItemMappings', TMessageType.CALL, self._seqid)
1319 
    args = getVendorItemMappings_args()
1320 
    args.itemId = itemId
1321 
    args.write(self._oprot)
1322 
    self._oprot.writeMessageEnd()
1323 
    self._oprot.trans.flush()
1324 
 
1325 
  def recv_getVendorItemMappings(self, ):
1326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1327 
    if mtype == TMessageType.EXCEPTION:
1328 
      x = TApplicationException()
1329 
      x.read(self._iprot)
1330 
      self._iprot.readMessageEnd()
1331 
      raise x
1332 
    result = getVendorItemMappings_result()
1333 
    result.read(self._iprot)
1334 
    self._iprot.readMessageEnd()
1335 
    if result.success is not None:
1336 
      return result.success
1337 
    if result.cex is not None:
1338 
      raise result.cex
1339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getVendorItemMappings failed: unknown result");
1340 
 
1341 
  def getPendingOrdersInventory(self, vendorid):
1342 
    """
1343 
    Returns a list of inventory stock for items for which there are pending orders for the given vendor.
1344 
 
1345 
    Parameters:
1346 
     - vendorid
1347 
    """
1348 
    self.send_getPendingOrdersInventory(vendorid)
1349 
    return self.recv_getPendingOrdersInventory()
1350 
 
1351 
  def send_getPendingOrdersInventory(self, vendorid):
1352 
    self._oprot.writeMessageBegin('getPendingOrdersInventory', TMessageType.CALL, self._seqid)
1353 
    args = getPendingOrdersInventory_args()
1354 
    args.vendorid = vendorid
1355 
    args.write(self._oprot)
1356 
    self._oprot.writeMessageEnd()
1357 
    self._oprot.trans.flush()
1358 
 
1359 
  def recv_getPendingOrdersInventory(self, ):
1360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1361 
    if mtype == TMessageType.EXCEPTION:
1362 
      x = TApplicationException()
1363 
      x.read(self._iprot)
1364 
      self._iprot.readMessageEnd()
1365 
      raise x
1366 
    result = getPendingOrdersInventory_result()
1367 
    result.read(self._iprot)
1368 
    self._iprot.readMessageEnd()
1369 
    if result.success is not None:
1370 
      return result.success
1371 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPendingOrdersInventory failed: unknown result");
1372 
 
1373 
  def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1374 
    """
1375 
    This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
1376 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 1 for billing warehouse 7 and shipping warehouse 7
1377 
    getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
1378 
       getWarehouses(null, null, 3, 7, 7) would return all type warehouses with all type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
1379 
       getWarehouses(null, null, 0, 0, 7) would return all type warehouses with all type inventory for all vendors for all billing warehouses at shipping warehouse 7
1380 
 
1381 
    Parameters:
1382 
     - warehouseType
1383 
     - inventoryType
1384 
     - vendorId
1385 
     - billingWarehouseId
1386 
     - shippingWarehouseId
1387 
    """
1388 
    self.send_getWarehouses(warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId)
1389 
    return self.recv_getWarehouses()
1390 
 
1391 
  def send_getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
1392 
    self._oprot.writeMessageBegin('getWarehouses', TMessageType.CALL, self._seqid)
1393 
    args = getWarehouses_args()
1394 
    args.warehouseType = warehouseType
1395 
    args.inventoryType = inventoryType
1396 
    args.vendorId = vendorId
1397 
    args.billingWarehouseId = billingWarehouseId
1398 
    args.shippingWarehouseId = shippingWarehouseId
1399 
    args.write(self._oprot)
1400 
    self._oprot.writeMessageEnd()
1401 
    self._oprot.trans.flush()
1402 
 
1403 
  def recv_getWarehouses(self, ):
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1405 
    if mtype == TMessageType.EXCEPTION:
1406 
      x = TApplicationException()
1407 
      x.read(self._iprot)
1408 
      self._iprot.readMessageEnd()
1409 
      raise x
1410 
    result = getWarehouses_result()
1411 
    result.read(self._iprot)
1412 
    self._iprot.readMessageEnd()
1413 
    if result.success is not None:
1414 
      return result.success
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouses failed: unknown result");
1416 
 
1417 
  def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1418 
    """
1419 
    Resets availability of an item to the quantity mentioned in a warehouse.
1420 
 
1421 
    Parameters:
1422 
     - itemKey
1423 
     - vendorId
1424 
     - quantity
1425 
     - warehouseId
1426 
    """
1427 
    self.send_resetAvailability(itemKey, vendorId, quantity, warehouseId)
1428 
    self.recv_resetAvailability()
1429 
 
1430 
  def send_resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
1431 
    self._oprot.writeMessageBegin('resetAvailability', TMessageType.CALL, self._seqid)
1432 
    args = resetAvailability_args()
1433 
    args.itemKey = itemKey
1434 
    args.vendorId = vendorId
1435 
    args.quantity = quantity
1436 
    args.warehouseId = warehouseId
1437 
    args.write(self._oprot)
1438 
    self._oprot.writeMessageEnd()
1439 
    self._oprot.trans.flush()
1440 
 
1441 
  def recv_resetAvailability(self, ):
1442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1443 
    if mtype == TMessageType.EXCEPTION:
1444 
      x = TApplicationException()
1445 
      x.read(self._iprot)
1446 
      self._iprot.readMessageEnd()
1447 
      raise x
1448 
    result = resetAvailability_result()
1449 
    result.read(self._iprot)
1450 
    self._iprot.readMessageEnd()
1451 
    if result.cex is not None:
1452 
      raise result.cex
1453 
    return
1454 
 
1455 
  def resetAvailabilityForWarehouse(self, warehouseId):
1456 
    """
1457 
    Resets availability of a warehouse to zero.
1458 
 
1459 
    Parameters:
1460 
     - warehouseId
1461 
    """
1462 
    self.send_resetAvailabilityForWarehouse(warehouseId)
1463 
    self.recv_resetAvailabilityForWarehouse()
1464 
 
1465 
  def send_resetAvailabilityForWarehouse(self, warehouseId):
1466 
    self._oprot.writeMessageBegin('resetAvailabilityForWarehouse', TMessageType.CALL, self._seqid)
1467 
    args = resetAvailabilityForWarehouse_args()
1468 
    args.warehouseId = warehouseId
1469 
    args.write(self._oprot)
1470 
    self._oprot.writeMessageEnd()
1471 
    self._oprot.trans.flush()
1472 
 
1473 
  def recv_resetAvailabilityForWarehouse(self, ):
1474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1475 
    if mtype == TMessageType.EXCEPTION:
1476 
      x = TApplicationException()
1477 
      x.read(self._iprot)
1478 
      self._iprot.readMessageEnd()
1479 
      raise x
1480 
    result = resetAvailabilityForWarehouse_result()
1481 
    result.read(self._iprot)
1482 
    self._iprot.readMessageEnd()
1483 
    if result.cex is not None:
1484 
      raise result.cex
1485 
    return
1486 
 
1487 
  def getItemKeysToBeProcessed(self, warehouseId):
1488 
    """
1489 
    Returns the list of item keys which need to be processed for a given warehouse.
1490 
    This is currently used by Support application to send item keys whose inventory needs
1491 
    to be updated from PLB
1492 
 
1493 
    Parameters:
1494 
     - warehouseId
1495 
    """
1496 
    self.send_getItemKeysToBeProcessed(warehouseId)
1497 
    return self.recv_getItemKeysToBeProcessed()
1498 
 
1499 
  def send_getItemKeysToBeProcessed(self, warehouseId):
1500 
    self._oprot.writeMessageBegin('getItemKeysToBeProcessed', TMessageType.CALL, self._seqid)
1501 
    args = getItemKeysToBeProcessed_args()
1502 
    args.warehouseId = warehouseId
1503 
    args.write(self._oprot)
1504 
    self._oprot.writeMessageEnd()
1505 
    self._oprot.trans.flush()
1506 
 
1507 
  def recv_getItemKeysToBeProcessed(self, ):
1508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1509 
    if mtype == TMessageType.EXCEPTION:
1510 
      x = TApplicationException()
1511 
      x.read(self._iprot)
1512 
      self._iprot.readMessageEnd()
1513 
      raise x
1514 
    result = getItemKeysToBeProcessed_result()
1515 
    result.read(self._iprot)
1516 
    self._iprot.readMessageEnd()
1517 
    if result.success is not None:
1518 
      return result.success
1519 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemKeysToBeProcessed failed: unknown result");
1520 
 
1521 
  def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1522 
    """
1523 
    Marks/Deletes missed inventory updates for a given key and warehouse.
1524 
    This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item
1525 
 
1526 
    Parameters:
1527 
     - itemKey
1528 
     - warehouseId
1529 
    """
1530 
    self.send_markMissedInventoryUpdatesAsProcessed(itemKey, warehouseId)
1531 
    self.recv_markMissedInventoryUpdatesAsProcessed()
1532 
 
1533 
  def send_markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
1534 
    self._oprot.writeMessageBegin('markMissedInventoryUpdatesAsProcessed', TMessageType.CALL, self._seqid)
1535 
    args = markMissedInventoryUpdatesAsProcessed_args()
1536 
    args.itemKey = itemKey
1537 
    args.warehouseId = warehouseId
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_markMissedInventoryUpdatesAsProcessed(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = markMissedInventoryUpdatesAsProcessed_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
1552 
    return
1553 
 
1554 
  def getIgnoredItemKeys(self, ):
1555 
    """
1556 
    Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
1557 
    and the timestamp from where alert was raised.
1558 
    """
1559 
    self.send_getIgnoredItemKeys()
1560 
    return self.recv_getIgnoredItemKeys()
1561 
 
1562 
  def send_getIgnoredItemKeys(self, ):
1563 
    self._oprot.writeMessageBegin('getIgnoredItemKeys', TMessageType.CALL, self._seqid)
1564 
    args = getIgnoredItemKeys_args()
1565 
    args.write(self._oprot)
1566 
    self._oprot.writeMessageEnd()
1567 
    self._oprot.trans.flush()
1568 
 
1569 
  def recv_getIgnoredItemKeys(self, ):
1570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1571 
    if mtype == TMessageType.EXCEPTION:
1572 
      x = TApplicationException()
1573 
      x.read(self._iprot)
1574 
      self._iprot.readMessageEnd()
1575 
      raise x
1576 
    result = getIgnoredItemKeys_result()
1577 
    result.read(self._iprot)
1578 
    self._iprot.readMessageEnd()
1579 
    if result.success is not None:
1580 
      return result.success
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredItemKeys failed: unknown result");
1582 
 
1583 
  def addBadInventory(self, itemId, warehouseId, quantity):
1584 
    """
1585 
    Add the BAD type inventory to existing stock.
1586 
 
1587 
    Parameters:
1588 
     - itemId
1589 
     - warehouseId
1590 
     - quantity
1591 
    """
1592 
    self.send_addBadInventory(itemId, warehouseId, quantity)
1593 
    self.recv_addBadInventory()
1594 
 
1595 
  def send_addBadInventory(self, itemId, warehouseId, quantity):
1596 
    self._oprot.writeMessageBegin('addBadInventory', TMessageType.CALL, self._seqid)
1597 
    args = addBadInventory_args()
1598 
    args.itemId = itemId
1599 
    args.warehouseId = warehouseId
1600 
    args.quantity = quantity
1601 
    args.write(self._oprot)
1602 
    self._oprot.writeMessageEnd()
1603 
    self._oprot.trans.flush()
1604 
 
1605 
  def recv_addBadInventory(self, ):
1606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1607 
    if mtype == TMessageType.EXCEPTION:
1608 
      x = TApplicationException()
1609 
      x.read(self._iprot)
1610 
      self._iprot.readMessageEnd()
1611 
      raise x
1612 
    result = addBadInventory_result()
1613 
    result.read(self._iprot)
1614 
    self._iprot.readMessageEnd()
1615 
    if result.cex is not None:
1616 
      raise result.cex
1617 
    return
1618 
 
1619 
  def getShippingLocations(self, ):
1620 
    """
1621 
    Returns all shipping locations
1622 
    """
1623 
    self.send_getShippingLocations()
1624 
    return self.recv_getShippingLocations()
1625 
 
1626 
  def send_getShippingLocations(self, ):
1627 
    self._oprot.writeMessageBegin('getShippingLocations', TMessageType.CALL, self._seqid)
1628 
    args = getShippingLocations_args()
1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_getShippingLocations(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = getShippingLocations_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
1643 
    if result.success is not None:
1644 
      return result.success
1645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getShippingLocations failed: unknown result");
1646 
 
1647 
  def getAllVendorItemMappings(self, ):
1648 
    """
1649 
    Fetches all the vendor item mappings present.
1650 
    """
1651 
    self.send_getAllVendorItemMappings()
1652 
    return self.recv_getAllVendorItemMappings()
1653 
 
1654 
  def send_getAllVendorItemMappings(self, ):
1655 
    self._oprot.writeMessageBegin('getAllVendorItemMappings', TMessageType.CALL, self._seqid)
1656 
    args = getAllVendorItemMappings_args()
1657 
    args.write(self._oprot)
1658 
    self._oprot.writeMessageEnd()
1659 
    self._oprot.trans.flush()
1660 
 
1661 
  def recv_getAllVendorItemMappings(self, ):
1662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1663 
    if mtype == TMessageType.EXCEPTION:
1664 
      x = TApplicationException()
1665 
      x.read(self._iprot)
1666 
      self._iprot.readMessageEnd()
1667 
      raise x
1668 
    result = getAllVendorItemMappings_result()
1669 
    result.read(self._iprot)
1670 
    self._iprot.readMessageEnd()
1671 
    if result.success is not None:
1672 
      return result.success
1673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVendorItemMappings failed: unknown result");
1674 
 
1675 
  def getInventorySnapshot(self, warehouseId):
1676 
    """
1677 
    Gets items' inventory for a warehouse
1678 
    If warehouse is passed as zero, items' inventory across all warehouses is sent
1679 
 
1680 
    Parameters:
1681 
     - warehouseId
1682 
    """
1683 
    self.send_getInventorySnapshot(warehouseId)
1684 
    return self.recv_getInventorySnapshot()
1685 
 
1686 
  def send_getInventorySnapshot(self, warehouseId):
1687 
    self._oprot.writeMessageBegin('getInventorySnapshot', TMessageType.CALL, self._seqid)
1688 
    args = getInventorySnapshot_args()
1689 
    args.warehouseId = warehouseId
1690 
    args.write(self._oprot)
1691 
    self._oprot.writeMessageEnd()
1692 
    self._oprot.trans.flush()
1693 
 
1694 
  def recv_getInventorySnapshot(self, ):
1695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1696 
    if mtype == TMessageType.EXCEPTION:
1697 
      x = TApplicationException()
1698 
      x.read(self._iprot)
1699 
      self._iprot.readMessageEnd()
1700 
      raise x
1701 
    result = getInventorySnapshot_result()
1702 
    result.read(self._iprot)
1703 
    self._iprot.readMessageEnd()
1704 
    if result.success is not None:
1705 
      return result.success
1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventorySnapshot failed: unknown result");
1707 
 
1708 
  def clearItemAvailabilityCache(self, ):
1709 
    """
1710 
    Clear item availability cache.
1711 
    """
1712 
    self.send_clearItemAvailabilityCache()
1713 
    self.recv_clearItemAvailabilityCache()
1714 
 
1715 
  def send_clearItemAvailabilityCache(self, ):
1716 
    self._oprot.writeMessageBegin('clearItemAvailabilityCache', TMessageType.CALL, self._seqid)
1717 
    args = clearItemAvailabilityCache_args()
1718 
    args.write(self._oprot)
1719 
    self._oprot.writeMessageEnd()
1720 
    self._oprot.trans.flush()
1721 
 
1722 
  def recv_clearItemAvailabilityCache(self, ):
1723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1724 
    if mtype == TMessageType.EXCEPTION:
1725 
      x = TApplicationException()
1726 
      x.read(self._iprot)
1727 
      self._iprot.readMessageEnd()
1728 
      raise x
1729 
    result = clearItemAvailabilityCache_result()
1730 
    result.read(self._iprot)
1731 
    self._iprot.readMessageEnd()
1732 
    return
1733 
 
1734 
  def updateVendorString(self, warehouseId, vendorString):
1735 
    """
1736 
    Parameters:
1737 
     - warehouseId
1738 
     - vendorString
1739 
    """
1740 
    self.send_updateVendorString(warehouseId, vendorString)
1741 
    self.recv_updateVendorString()
1742 
 
1743 
  def send_updateVendorString(self, warehouseId, vendorString):
1744 
    self._oprot.writeMessageBegin('updateVendorString', TMessageType.CALL, self._seqid)
1745 
    args = updateVendorString_args()
1746 
    args.warehouseId = warehouseId
1747 
    args.vendorString = vendorString
1748 
    args.write(self._oprot)
1749 
    self._oprot.writeMessageEnd()
1750 
    self._oprot.trans.flush()
1751 
 
1752 
  def recv_updateVendorString(self, ):
1753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1754 
    if mtype == TMessageType.EXCEPTION:
1755 
      x = TApplicationException()
1756 
      x.read(self._iprot)
1757 
      self._iprot.readMessageEnd()
1758 
      raise x
1759 
    result = updateVendorString_result()
1760 
    result.read(self._iprot)
1761 
    self._iprot.readMessageEnd()
1762 
    return
1763 
 
6096 amit.gupta 1764 
  def clearItemAvailabilityCacheForItem(self, item_id):
1765 
    """
1766 
    Parameters:
1767 
     - item_id
1768 
    """
1769 
    self.send_clearItemAvailabilityCacheForItem(item_id)
1770 
    self.recv_clearItemAvailabilityCacheForItem()
5944 mandeep.dh 1771 
 
6096 amit.gupta 1772 
  def send_clearItemAvailabilityCacheForItem(self, item_id):
1773 
    self._oprot.writeMessageBegin('clearItemAvailabilityCacheForItem', TMessageType.CALL, self._seqid)
1774 
    args = clearItemAvailabilityCacheForItem_args()
1775 
    args.item_id = item_id
1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_clearItemAvailabilityCacheForItem(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = clearItemAvailabilityCacheForItem_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
1790 
    return
1791 
 
7718 amar.kumar 1792 
  def getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 1793 
    """
1794 
    Parameters:
1795 
     - vendorId
7718 amar.kumar 1796 
     - billingWarehouseId
6467 amar.kumar 1797 
    """
7718 amar.kumar 1798 
    self.send_getOurWarehouseIdForVendor(vendorId, billingWarehouseId)
6467 amar.kumar 1799 
    return self.recv_getOurWarehouseIdForVendor()
6096 amit.gupta 1800 
 
7718 amar.kumar 1801 
  def send_getOurWarehouseIdForVendor(self, vendorId, billingWarehouseId):
6467 amar.kumar 1802 
    self._oprot.writeMessageBegin('getOurWarehouseIdForVendor', TMessageType.CALL, self._seqid)
1803 
    args = getOurWarehouseIdForVendor_args()
1804 
    args.vendorId = vendorId
7718 amar.kumar 1805 
    args.billingWarehouseId = billingWarehouseId
6467 amar.kumar 1806 
    args.write(self._oprot)
1807 
    self._oprot.writeMessageEnd()
1808 
    self._oprot.trans.flush()
1809 
 
1810 
  def recv_getOurWarehouseIdForVendor(self, ):
1811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1812 
    if mtype == TMessageType.EXCEPTION:
1813 
      x = TApplicationException()
1814 
      x.read(self._iprot)
1815 
      self._iprot.readMessageEnd()
1816 
      raise x
1817 
    result = getOurWarehouseIdForVendor_result()
1818 
    result.read(self._iprot)
1819 
    self._iprot.readMessageEnd()
1820 
    if result.success is not None:
1821 
      return result.success
1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurWarehouseIdForVendor failed: unknown result");
1823 
 
6484 amar.kumar 1824 
  def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
1825 
    """
1826 
    Parameters:
1827 
     - item_ids
1828 
    """
1829 
    self.send_getItemAvailabilitiesAtOurWarehouses(item_ids)
1830 
    return self.recv_getItemAvailabilitiesAtOurWarehouses()
6467 amar.kumar 1831 
 
6484 amar.kumar 1832 
  def send_getItemAvailabilitiesAtOurWarehouses(self, item_ids):
1833 
    self._oprot.writeMessageBegin('getItemAvailabilitiesAtOurWarehouses', TMessageType.CALL, self._seqid)
1834 
    args = getItemAvailabilitiesAtOurWarehouses_args()
1835 
    args.item_ids = item_ids
1836 
    args.write(self._oprot)
1837 
    self._oprot.writeMessageEnd()
1838 
    self._oprot.trans.flush()
1839 
 
1840 
  def recv_getItemAvailabilitiesAtOurWarehouses(self, ):
1841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1842 
    if mtype == TMessageType.EXCEPTION:
1843 
      x = TApplicationException()
1844 
      x.read(self._iprot)
1845 
      self._iprot.readMessageEnd()
1846 
      raise x
1847 
    result = getItemAvailabilitiesAtOurWarehouses_result()
1848 
    result.read(self._iprot)
1849 
    self._iprot.readMessageEnd()
1850 
    if result.success is not None:
1851 
      return result.success
1852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemAvailabilitiesAtOurWarehouses failed: unknown result");
1853 
 
6531 vikram.rag 1854 
  def getMonitoredWarehouseForVendors(self, vendorIds):
1855 
    """
1856 
    Parameters:
1857 
     - vendorIds
1858 
    """
1859 
    self.send_getMonitoredWarehouseForVendors(vendorIds)
1860 
    return self.recv_getMonitoredWarehouseForVendors()
6484 amar.kumar 1861 
 
6531 vikram.rag 1862 
  def send_getMonitoredWarehouseForVendors(self, vendorIds):
1863 
    self._oprot.writeMessageBegin('getMonitoredWarehouseForVendors', TMessageType.CALL, self._seqid)
1864 
    args = getMonitoredWarehouseForVendors_args()
1865 
    args.vendorIds = vendorIds
1866 
    args.write(self._oprot)
1867 
    self._oprot.writeMessageEnd()
1868 
    self._oprot.trans.flush()
1869 
 
1870 
  def recv_getMonitoredWarehouseForVendors(self, ):
1871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1872 
    if mtype == TMessageType.EXCEPTION:
1873 
      x = TApplicationException()
1874 
      x.read(self._iprot)
1875 
      self._iprot.readMessageEnd()
1876 
      raise x
1877 
    result = getMonitoredWarehouseForVendors_result()
1878 
    result.read(self._iprot)
1879 
    self._iprot.readMessageEnd()
1880 
    if result.success is not None:
1881 
      return result.success
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMonitoredWarehouseForVendors failed: unknown result");
1883 
 
1884 
  def getIgnoredWarehouseidsAndItemids(self, ):
1885 
    self.send_getIgnoredWarehouseidsAndItemids()
1886 
    return self.recv_getIgnoredWarehouseidsAndItemids()
1887 
 
1888 
  def send_getIgnoredWarehouseidsAndItemids(self, ):
1889 
    self._oprot.writeMessageBegin('getIgnoredWarehouseidsAndItemids', TMessageType.CALL, self._seqid)
1890 
    args = getIgnoredWarehouseidsAndItemids_args()
1891 
    args.write(self._oprot)
1892 
    self._oprot.writeMessageEnd()
1893 
    self._oprot.trans.flush()
1894 
 
1895 
  def recv_getIgnoredWarehouseidsAndItemids(self, ):
1896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1897 
    if mtype == TMessageType.EXCEPTION:
1898 
      x = TApplicationException()
1899 
      x.read(self._iprot)
1900 
      self._iprot.readMessageEnd()
1901 
      raise x
1902 
    result = getIgnoredWarehouseidsAndItemids_result()
1903 
    result.read(self._iprot)
1904 
    self._iprot.readMessageEnd()
1905 
    if result.success is not None:
1906 
      return result.success
1907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredWarehouseidsAndItemids failed: unknown result");
1908 
 
1909 
  def insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
1910 
    """
1911 
    Parameters:
1912 
     - item_id
1913 
     - warehouse_id
1914 
    """
1915 
    self.send_insertItemtoIgnoreInventoryUpdatelist(item_id, warehouse_id)
1916 
    return self.recv_insertItemtoIgnoreInventoryUpdatelist()
1917 
 
1918 
  def send_insertItemtoIgnoreInventoryUpdatelist(self, item_id, warehouse_id):
1919 
    self._oprot.writeMessageBegin('insertItemtoIgnoreInventoryUpdatelist', TMessageType.CALL, self._seqid)
1920 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
1921 
    args.item_id = item_id
1922 
    args.warehouse_id = warehouse_id
1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1927 
  def recv_insertItemtoIgnoreInventoryUpdatelist(self, ):
1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1934 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
1937 
    if result.success is not None:
1938 
      return result.success
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "insertItemtoIgnoreInventoryUpdatelist failed: unknown result");
1940 
 
1941 
  def deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
1942 
    """
1943 
    Parameters:
1944 
     - item_id
1945 
     - warehouse_id
1946 
    """
1947 
    self.send_deleteItemFromIgnoredInventoryUpdateList(item_id, warehouse_id)
1948 
    return self.recv_deleteItemFromIgnoredInventoryUpdateList()
1949 
 
1950 
  def send_deleteItemFromIgnoredInventoryUpdateList(self, item_id, warehouse_id):
1951 
    self._oprot.writeMessageBegin('deleteItemFromIgnoredInventoryUpdateList', TMessageType.CALL, self._seqid)
1952 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
1953 
    args.item_id = item_id
1954 
    args.warehouse_id = warehouse_id
1955 
    args.write(self._oprot)
1956 
    self._oprot.writeMessageEnd()
1957 
    self._oprot.trans.flush()
1958 
 
1959 
  def recv_deleteItemFromIgnoredInventoryUpdateList(self, ):
1960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1961 
    if mtype == TMessageType.EXCEPTION:
1962 
      x = TApplicationException()
1963 
      x.read(self._iprot)
1964 
      self._iprot.readMessageEnd()
1965 
      raise x
1966 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
1967 
    result.read(self._iprot)
1968 
    self._iprot.readMessageEnd()
1969 
    if result.success is not None:
1970 
      return result.success
1971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteItemFromIgnoredInventoryUpdateList failed: unknown result");
1972 
 
1973 
  def getAllIgnoredInventoryupdateItemsCount(self, ):
1974 
    self.send_getAllIgnoredInventoryupdateItemsCount()
1975 
    return self.recv_getAllIgnoredInventoryupdateItemsCount()
1976 
 
1977 
  def send_getAllIgnoredInventoryupdateItemsCount(self, ):
1978 
    self._oprot.writeMessageBegin('getAllIgnoredInventoryupdateItemsCount', TMessageType.CALL, self._seqid)
1979 
    args = getAllIgnoredInventoryupdateItemsCount_args()
1980 
    args.write(self._oprot)
1981 
    self._oprot.writeMessageEnd()
1982 
    self._oprot.trans.flush()
1983 
 
1984 
  def recv_getAllIgnoredInventoryupdateItemsCount(self, ):
1985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1986 
    if mtype == TMessageType.EXCEPTION:
1987 
      x = TApplicationException()
1988 
      x.read(self._iprot)
1989 
      self._iprot.readMessageEnd()
1990 
      raise x
1991 
    result = getAllIgnoredInventoryupdateItemsCount_result()
1992 
    result.read(self._iprot)
1993 
    self._iprot.readMessageEnd()
1994 
    if result.success is not None:
1995 
      return result.success
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllIgnoredInventoryupdateItemsCount failed: unknown result");
1997 
 
1998 
  def getIgnoredInventoryUpdateItemids(self, offset, limit):
1999 
    """
2000 
    Parameters:
2001 
     - offset
2002 
     - limit
2003 
    """
2004 
    self.send_getIgnoredInventoryUpdateItemids(offset, limit)
2005 
    return self.recv_getIgnoredInventoryUpdateItemids()
2006 
 
2007 
  def send_getIgnoredInventoryUpdateItemids(self, offset, limit):
2008 
    self._oprot.writeMessageBegin('getIgnoredInventoryUpdateItemids', TMessageType.CALL, self._seqid)
2009 
    args = getIgnoredInventoryUpdateItemids_args()
2010 
    args.offset = offset
2011 
    args.limit = limit
2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
2016 
  def recv_getIgnoredInventoryUpdateItemids(self, ):
2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
2023 
    result = getIgnoredInventoryUpdateItemids_result()
2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
2026 
    if result.success is not None:
2027 
      return result.success
2028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getIgnoredInventoryUpdateItemids failed: unknown result");
2029 
 
6821 amar.kumar 2030 
  def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2031 
    """
2032 
    Parameters:
2033 
     - item_id
2034 
     - numOfDaysStock
2035 
     - minStockLevel
2036 
    """
2037 
    self.send_updateItemStockPurchaseParams(item_id, numOfDaysStock, minStockLevel)
2038 
    self.recv_updateItemStockPurchaseParams()
6531 vikram.rag 2039 
 
6821 amar.kumar 2040 
  def send_updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
2041 
    self._oprot.writeMessageBegin('updateItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2042 
    args = updateItemStockPurchaseParams_args()
2043 
    args.item_id = item_id
2044 
    args.numOfDaysStock = numOfDaysStock
2045 
    args.minStockLevel = minStockLevel
2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
2050 
  def recv_updateItemStockPurchaseParams(self, ):
2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
2057 
    result = updateItemStockPurchaseParams_result()
2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
2060 
    return
2061 
 
2062 
  def getItemStockPurchaseParams(self, itemId):
2063 
    """
2064 
    Parameters:
2065 
     - itemId
2066 
    """
2067 
    self.send_getItemStockPurchaseParams(itemId)
2068 
    return self.recv_getItemStockPurchaseParams()
2069 
 
2070 
  def send_getItemStockPurchaseParams(self, itemId):
2071 
    self._oprot.writeMessageBegin('getItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2072 
    args = getItemStockPurchaseParams_args()
2073 
    args.itemId = itemId
2074 
    args.write(self._oprot)
2075 
    self._oprot.writeMessageEnd()
2076 
    self._oprot.trans.flush()
2077 
 
2078 
  def recv_getItemStockPurchaseParams(self, ):
2079 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2080 
    if mtype == TMessageType.EXCEPTION:
2081 
      x = TApplicationException()
2082 
      x.read(self._iprot)
2083 
      self._iprot.readMessageEnd()
2084 
      raise x
2085 
    result = getItemStockPurchaseParams_result()
2086 
    result.read(self._iprot)
2087 
    self._iprot.readMessageEnd()
2088 
    if result.success is not None:
2089 
      return result.success
2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemStockPurchaseParams failed: unknown result");
2091 
 
2092 
  def addOosStatusForItem(self, oosStatusMap, date):
2093 
    """
2094 
    Parameters:
2095 
     - oosStatusMap
2096 
     - date
2097 
    """
2098 
    self.send_addOosStatusForItem(oosStatusMap, date)
2099 
    self.recv_addOosStatusForItem()
2100 
 
2101 
  def send_addOosStatusForItem(self, oosStatusMap, date):
2102 
    self._oprot.writeMessageBegin('addOosStatusForItem', TMessageType.CALL, self._seqid)
2103 
    args = addOosStatusForItem_args()
2104 
    args.oosStatusMap = oosStatusMap
2105 
    args.date = date
2106 
    args.write(self._oprot)
2107 
    self._oprot.writeMessageEnd()
2108 
    self._oprot.trans.flush()
2109 
 
2110 
  def recv_addOosStatusForItem(self, ):
2111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2112 
    if mtype == TMessageType.EXCEPTION:
2113 
      x = TApplicationException()
2114 
      x.read(self._iprot)
2115 
      self._iprot.readMessageEnd()
2116 
      raise x
2117 
    result = addOosStatusForItem_result()
2118 
    result.read(self._iprot)
2119 
    self._iprot.readMessageEnd()
2120 
    return
2121 
 
6832 amar.kumar 2122 
  def getOosStatusesForXDaysForItem(self, itemId, days):
2123 
    """
2124 
    Parameters:
2125 
     - itemId
2126 
     - days
2127 
    """
2128 
    self.send_getOosStatusesForXDaysForItem(itemId, days)
2129 
    return self.recv_getOosStatusesForXDaysForItem()
6821 amar.kumar 2130 
 
6832 amar.kumar 2131 
  def send_getOosStatusesForXDaysForItem(self, itemId, days):
2132 
    self._oprot.writeMessageBegin('getOosStatusesForXDaysForItem', TMessageType.CALL, self._seqid)
2133 
    args = getOosStatusesForXDaysForItem_args()
2134 
    args.itemId = itemId
2135 
    args.days = days
2136 
    args.write(self._oprot)
2137 
    self._oprot.writeMessageEnd()
2138 
    self._oprot.trans.flush()
2139 
 
2140 
  def recv_getOosStatusesForXDaysForItem(self, ):
2141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2142 
    if mtype == TMessageType.EXCEPTION:
2143 
      x = TApplicationException()
2144 
      x.read(self._iprot)
2145 
      self._iprot.readMessageEnd()
2146 
      raise x
2147 
    result = getOosStatusesForXDaysForItem_result()
2148 
    result.read(self._iprot)
2149 
    self._iprot.readMessageEnd()
2150 
    if result.success is not None:
2151 
      return result.success
2152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOosStatusesForXDaysForItem failed: unknown result");
2153 
 
6857 amar.kumar 2154 
  def getNonZeroItemStockPurchaseParams(self, ):
2155 
    self.send_getNonZeroItemStockPurchaseParams()
2156 
    return self.recv_getNonZeroItemStockPurchaseParams()
6832 amar.kumar 2157 
 
6857 amar.kumar 2158 
  def send_getNonZeroItemStockPurchaseParams(self, ):
2159 
    self._oprot.writeMessageBegin('getNonZeroItemStockPurchaseParams', TMessageType.CALL, self._seqid)
2160 
    args = getNonZeroItemStockPurchaseParams_args()
2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
2165 
  def recv_getNonZeroItemStockPurchaseParams(self, ):
2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
2172 
    result = getNonZeroItemStockPurchaseParams_result()
2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
2175 
    if result.success is not None:
2176 
      return result.success
2177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonZeroItemStockPurchaseParams failed: unknown result");
2178 
 
7149 amar.kumar 2179 
  def getBillableInventoryAndPendingOrders(self, ):
2180 
    """
2181 
    Returns a list of inventory stock for items for which there are pending orders or have billable inventory.
2182 
    """
2183 
    self.send_getBillableInventoryAndPendingOrders()
2184 
    return self.recv_getBillableInventoryAndPendingOrders()
6857 amar.kumar 2185 
 
7149 amar.kumar 2186 
  def send_getBillableInventoryAndPendingOrders(self, ):
2187 
    self._oprot.writeMessageBegin('getBillableInventoryAndPendingOrders', TMessageType.CALL, self._seqid)
2188 
    args = getBillableInventoryAndPendingOrders_args()
2189 
    args.write(self._oprot)
2190 
    self._oprot.writeMessageEnd()
2191 
    self._oprot.trans.flush()
2192 
 
2193 
  def recv_getBillableInventoryAndPendingOrders(self, ):
2194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2195 
    if mtype == TMessageType.EXCEPTION:
2196 
      x = TApplicationException()
2197 
      x.read(self._iprot)
2198 
      self._iprot.readMessageEnd()
2199 
      raise x
2200 
    result = getBillableInventoryAndPendingOrders_result()
2201 
    result.read(self._iprot)
2202 
    self._iprot.readMessageEnd()
2203 
    if result.success is not None:
2204 
      return result.success
2205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBillableInventoryAndPendingOrders failed: unknown result");
2206 
 
7281 kshitij.so 2207 
  def getWarehouseName(self, warehouse_id):
2208 
    """
2209 
    Parameters:
2210 
     - warehouse_id
2211 
    """
2212 
    self.send_getWarehouseName(warehouse_id)
2213 
    return self.recv_getWarehouseName()
7149 amar.kumar 2214 
 
7281 kshitij.so 2215 
  def send_getWarehouseName(self, warehouse_id):
2216 
    self._oprot.writeMessageBegin('getWarehouseName', TMessageType.CALL, self._seqid)
2217 
    args = getWarehouseName_args()
2218 
    args.warehouse_id = warehouse_id
2219 
    args.write(self._oprot)
2220 
    self._oprot.writeMessageEnd()
2221 
    self._oprot.trans.flush()
2222 
 
2223 
  def recv_getWarehouseName(self, ):
2224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2225 
    if mtype == TMessageType.EXCEPTION:
2226 
      x = TApplicationException()
2227 
      x.read(self._iprot)
2228 
      self._iprot.readMessageEnd()
2229 
      raise x
2230 
    result = getWarehouseName_result()
2231 
    result.read(self._iprot)
2232 
    self._iprot.readMessageEnd()
2233 
    if result.success is not None:
2234 
      return result.success
2235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getWarehouseName failed: unknown result");
2236 
 
2237 
  def getAmazonInventoryForItem(self, item_id):
2238 
    """
2239 
    Parameters:
2240 
     - item_id
2241 
    """
2242 
    self.send_getAmazonInventoryForItem(item_id)
2243 
    return self.recv_getAmazonInventoryForItem()
2244 
 
2245 
  def send_getAmazonInventoryForItem(self, item_id):
2246 
    self._oprot.writeMessageBegin('getAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2247 
    args = getAmazonInventoryForItem_args()
2248 
    args.item_id = item_id
2249 
    args.write(self._oprot)
2250 
    self._oprot.writeMessageEnd()
2251 
    self._oprot.trans.flush()
2252 
 
2253 
  def recv_getAmazonInventoryForItem(self, ):
2254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2255 
    if mtype == TMessageType.EXCEPTION:
2256 
      x = TApplicationException()
2257 
      x.read(self._iprot)
2258 
      self._iprot.readMessageEnd()
2259 
      raise x
2260 
    result = getAmazonInventoryForItem_result()
2261 
    result.read(self._iprot)
2262 
    self._iprot.readMessageEnd()
2263 
    if result.success is not None:
2264 
      return result.success
2265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonInventoryForItem failed: unknown result");
2266 
 
2267 
  def getAllAmazonInventory(self, ):
2268 
    self.send_getAllAmazonInventory()
2269 
    return self.recv_getAllAmazonInventory()
2270 
 
2271 
  def send_getAllAmazonInventory(self, ):
2272 
    self._oprot.writeMessageBegin('getAllAmazonInventory', TMessageType.CALL, self._seqid)
2273 
    args = getAllAmazonInventory_args()
2274 
    args.write(self._oprot)
2275 
    self._oprot.writeMessageEnd()
2276 
    self._oprot.trans.flush()
2277 
 
2278 
  def recv_getAllAmazonInventory(self, ):
2279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2280 
    if mtype == TMessageType.EXCEPTION:
2281 
      x = TApplicationException()
2282 
      x.read(self._iprot)
2283 
      self._iprot.readMessageEnd()
2284 
      raise x
2285 
    result = getAllAmazonInventory_result()
2286 
    result.read(self._iprot)
2287 
    self._iprot.readMessageEnd()
2288 
    if result.success is not None:
2289 
      return result.success
2290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAmazonInventory failed: unknown result");
2291 
 
2292 
  def addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot):
2293 
    """
2294 
    Parameters:
2295 
     - amazonInventorySnapshot
2296 
    """
2297 
    self.send_addOrUpdateAmazonInventoryForItem(amazonInventorySnapshot)
2298 
    self.recv_addOrUpdateAmazonInventoryForItem()
2299 
 
2300 
  def send_addOrUpdateAmazonInventoryForItem(self, amazonInventorySnapshot):
2301 
    self._oprot.writeMessageBegin('addOrUpdateAmazonInventoryForItem', TMessageType.CALL, self._seqid)
2302 
    args = addOrUpdateAmazonInventoryForItem_args()
2303 
    args.amazonInventorySnapshot = amazonInventorySnapshot
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_addOrUpdateAmazonInventoryForItem(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = addOrUpdateAmazonInventoryForItem_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    return
2319 
 
7972 amar.kumar 2320 
  def getLastNdaySaleForItem(self, itemId, numberOfDays):
2321 
    """
2322 
    Parameters:
2323 
     - itemId
2324 
     - numberOfDays
2325 
    """
2326 
    self.send_getLastNdaySaleForItem(itemId, numberOfDays)
2327 
    return self.recv_getLastNdaySaleForItem()
7281 kshitij.so 2328 
 
7972 amar.kumar 2329 
  def send_getLastNdaySaleForItem(self, itemId, numberOfDays):
2330 
    self._oprot.writeMessageBegin('getLastNdaySaleForItem', TMessageType.CALL, self._seqid)
2331 
    args = getLastNdaySaleForItem_args()
2332 
    args.itemId = itemId
2333 
    args.numberOfDays = numberOfDays
2334 
    args.write(self._oprot)
2335 
    self._oprot.writeMessageEnd()
2336 
    self._oprot.trans.flush()
2337 
 
2338 
  def recv_getLastNdaySaleForItem(self, ):
2339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2340 
    if mtype == TMessageType.EXCEPTION:
2341 
      x = TApplicationException()
2342 
      x.read(self._iprot)
2343 
      self._iprot.readMessageEnd()
2344 
      raise x
2345 
    result = getLastNdaySaleForItem_result()
2346 
    result.read(self._iprot)
2347 
    self._iprot.readMessageEnd()
2348 
    if result.success is not None:
2349 
      return result.success
2350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLastNdaySaleForItem failed: unknown result");
2351 
 
8182 amar.kumar 2352 
  def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2353 
    """
2354 
    Parameters:
2355 
     - itemId
2356 
     - warehouseId
2357 
     - holdQuantity
2358 
     - source
2359 
    """
2360 
    self.send_addUpdateHoldInventory(itemId, warehouseId, holdQuantity, source)
2361 
    self.recv_addUpdateHoldInventory()
7972 amar.kumar 2362 
 
8182 amar.kumar 2363 
  def send_addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
2364 
    self._oprot.writeMessageBegin('addUpdateHoldInventory', TMessageType.CALL, self._seqid)
2365 
    args = addUpdateHoldInventory_args()
2366 
    args.itemId = itemId
2367 
    args.warehouseId = warehouseId
2368 
    args.holdQuantity = holdQuantity
2369 
    args.source = source
2370 
    args.write(self._oprot)
2371 
    self._oprot.writeMessageEnd()
2372 
    self._oprot.trans.flush()
2373 
 
2374 
  def recv_addUpdateHoldInventory(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 = addUpdateHoldInventory_result()
2382 
    result.read(self._iprot)
2383 
    self._iprot.readMessageEnd()
2384 
    return
2385 
 
2386 
 
5944 mandeep.dh 2387 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
2388 
  def __init__(self, handler):
2389 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
2390 
    self._processMap["addWarehouse"] = Processor.process_addWarehouse
2391 
    self._processMap["addVendor"] = Processor.process_addVendor
2392 
    self._processMap["updateInventoryHistory"] = Processor.process_updateInventoryHistory
2393 
    self._processMap["updateInventory"] = Processor.process_updateInventory
2394 
    self._processMap["addInventory"] = Processor.process_addInventory
2395 
    self._processMap["retireWarehouse"] = Processor.process_retireWarehouse
2396 
    self._processMap["getItemInventoryByItemId"] = Processor.process_getItemInventoryByItemId
2397 
    self._processMap["getItemAvailibilityAtWarehouse"] = Processor.process_getItemAvailibilityAtWarehouse
2398 
    self._processMap["getItemAvailabilityAtLocation"] = Processor.process_getItemAvailabilityAtLocation
2399 
    self._processMap["getAllWarehouses"] = Processor.process_getAllWarehouses
2400 
    self._processMap["getWarehouse"] = Processor.process_getWarehouse
2401 
    self._processMap["getAllItemsForWarehouse"] = Processor.process_getAllItemsForWarehouse
5966 rajveer 2402 
    self._processMap["isOrderBillable"] = Processor.process_isOrderBillable
5944 mandeep.dh 2403 
    self._processMap["reserveItemInWarehouse"] = Processor.process_reserveItemInWarehouse
7968 amar.kumar 2404 
    self._processMap["updateReservationForOrder"] = Processor.process_updateReservationForOrder
5944 mandeep.dh 2405 
    self._processMap["reduceReservationCount"] = Processor.process_reduceReservationCount
2406 
    self._processMap["getItemPricing"] = Processor.process_getItemPricing
2407 
    self._processMap["getAllItemPricing"] = Processor.process_getAllItemPricing
2408 
    self._processMap["addVendorItemPricing"] = Processor.process_addVendorItemPricing
2409 
    self._processMap["getVendor"] = Processor.process_getVendor
2410 
    self._processMap["getAllVendors"] = Processor.process_getAllVendors
2411 
    self._processMap["addVendorItemMapping"] = Processor.process_addVendorItemMapping
2412 
    self._processMap["getVendorItemMappings"] = Processor.process_getVendorItemMappings
2413 
    self._processMap["getPendingOrdersInventory"] = Processor.process_getPendingOrdersInventory
2414 
    self._processMap["getWarehouses"] = Processor.process_getWarehouses
2415 
    self._processMap["resetAvailability"] = Processor.process_resetAvailability
2416 
    self._processMap["resetAvailabilityForWarehouse"] = Processor.process_resetAvailabilityForWarehouse
2417 
    self._processMap["getItemKeysToBeProcessed"] = Processor.process_getItemKeysToBeProcessed
2418 
    self._processMap["markMissedInventoryUpdatesAsProcessed"] = Processor.process_markMissedInventoryUpdatesAsProcessed
2419 
    self._processMap["getIgnoredItemKeys"] = Processor.process_getIgnoredItemKeys
2420 
    self._processMap["addBadInventory"] = Processor.process_addBadInventory
2421 
    self._processMap["getShippingLocations"] = Processor.process_getShippingLocations
2422 
    self._processMap["getAllVendorItemMappings"] = Processor.process_getAllVendorItemMappings
2423 
    self._processMap["getInventorySnapshot"] = Processor.process_getInventorySnapshot
2424 
    self._processMap["clearItemAvailabilityCache"] = Processor.process_clearItemAvailabilityCache
2425 
    self._processMap["updateVendorString"] = Processor.process_updateVendorString
6096 amit.gupta 2426 
    self._processMap["clearItemAvailabilityCacheForItem"] = Processor.process_clearItemAvailabilityCacheForItem
6467 amar.kumar 2427 
    self._processMap["getOurWarehouseIdForVendor"] = Processor.process_getOurWarehouseIdForVendor
6484 amar.kumar 2428 
    self._processMap["getItemAvailabilitiesAtOurWarehouses"] = Processor.process_getItemAvailabilitiesAtOurWarehouses
6531 vikram.rag 2429 
    self._processMap["getMonitoredWarehouseForVendors"] = Processor.process_getMonitoredWarehouseForVendors
2430 
    self._processMap["getIgnoredWarehouseidsAndItemids"] = Processor.process_getIgnoredWarehouseidsAndItemids
2431 
    self._processMap["insertItemtoIgnoreInventoryUpdatelist"] = Processor.process_insertItemtoIgnoreInventoryUpdatelist
2432 
    self._processMap["deleteItemFromIgnoredInventoryUpdateList"] = Processor.process_deleteItemFromIgnoredInventoryUpdateList
2433 
    self._processMap["getAllIgnoredInventoryupdateItemsCount"] = Processor.process_getAllIgnoredInventoryupdateItemsCount
2434 
    self._processMap["getIgnoredInventoryUpdateItemids"] = Processor.process_getIgnoredInventoryUpdateItemids
6821 amar.kumar 2435 
    self._processMap["updateItemStockPurchaseParams"] = Processor.process_updateItemStockPurchaseParams
2436 
    self._processMap["getItemStockPurchaseParams"] = Processor.process_getItemStockPurchaseParams
2437 
    self._processMap["addOosStatusForItem"] = Processor.process_addOosStatusForItem
6832 amar.kumar 2438 
    self._processMap["getOosStatusesForXDaysForItem"] = Processor.process_getOosStatusesForXDaysForItem
6857 amar.kumar 2439 
    self._processMap["getNonZeroItemStockPurchaseParams"] = Processor.process_getNonZeroItemStockPurchaseParams
7149 amar.kumar 2440 
    self._processMap["getBillableInventoryAndPendingOrders"] = Processor.process_getBillableInventoryAndPendingOrders
7281 kshitij.so 2441 
    self._processMap["getWarehouseName"] = Processor.process_getWarehouseName
2442 
    self._processMap["getAmazonInventoryForItem"] = Processor.process_getAmazonInventoryForItem
2443 
    self._processMap["getAllAmazonInventory"] = Processor.process_getAllAmazonInventory
2444 
    self._processMap["addOrUpdateAmazonInventoryForItem"] = Processor.process_addOrUpdateAmazonInventoryForItem
7972 amar.kumar 2445 
    self._processMap["getLastNdaySaleForItem"] = Processor.process_getLastNdaySaleForItem
8182 amar.kumar 2446 
    self._processMap["addUpdateHoldInventory"] = Processor.process_addUpdateHoldInventory
5944 mandeep.dh 2447 
 
2448 
  def process(self, iprot, oprot):
2449 
    (name, type, seqid) = iprot.readMessageBegin()
2450 
    if name not in self._processMap:
2451 
      iprot.skip(TType.STRUCT)
2452 
      iprot.readMessageEnd()
2453 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2454 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2455 
      x.write(oprot)
2456 
      oprot.writeMessageEnd()
2457 
      oprot.trans.flush()
2458 
      return
2459 
    else:
2460 
      self._processMap[name](self, seqid, iprot, oprot)
2461 
    return True
2462 
 
2463 
  def process_addWarehouse(self, seqid, iprot, oprot):
2464 
    args = addWarehouse_args()
2465 
    args.read(iprot)
2466 
    iprot.readMessageEnd()
2467 
    result = addWarehouse_result()
2468 
    try:
2469 
      result.success = self._handler.addWarehouse(args.warehouse)
2470 
    except InventoryServiceException, cex:
2471 
      result.cex = cex
2472 
    oprot.writeMessageBegin("addWarehouse", TMessageType.REPLY, seqid)
2473 
    result.write(oprot)
2474 
    oprot.writeMessageEnd()
2475 
    oprot.trans.flush()
2476 
 
2477 
  def process_addVendor(self, seqid, iprot, oprot):
2478 
    args = addVendor_args()
2479 
    args.read(iprot)
2480 
    iprot.readMessageEnd()
2481 
    result = addVendor_result()
2482 
    try:
2483 
      result.success = self._handler.addVendor(args.vendor)
2484 
    except InventoryServiceException, cex:
2485 
      result.cex = cex
2486 
    oprot.writeMessageBegin("addVendor", TMessageType.REPLY, seqid)
2487 
    result.write(oprot)
2488 
    oprot.writeMessageEnd()
2489 
    oprot.trans.flush()
2490 
 
2491 
  def process_updateInventoryHistory(self, seqid, iprot, oprot):
2492 
    args = updateInventoryHistory_args()
2493 
    args.read(iprot)
2494 
    iprot.readMessageEnd()
2495 
    result = updateInventoryHistory_result()
2496 
    try:
2497 
      self._handler.updateInventoryHistory(args.warehouse_id, args.timestamp, args.availability)
2498 
    except InventoryServiceException, cex:
2499 
      result.cex = cex
2500 
    oprot.writeMessageBegin("updateInventoryHistory", TMessageType.REPLY, seqid)
2501 
    result.write(oprot)
2502 
    oprot.writeMessageEnd()
2503 
    oprot.trans.flush()
2504 
 
2505 
  def process_updateInventory(self, seqid, iprot, oprot):
2506 
    args = updateInventory_args()
2507 
    args.read(iprot)
2508 
    iprot.readMessageEnd()
2509 
    result = updateInventory_result()
2510 
    try:
2511 
      self._handler.updateInventory(args.warehouse_id, args.timestamp, args.availability)
2512 
    except InventoryServiceException, cex:
2513 
      result.cex = cex
2514 
    oprot.writeMessageBegin("updateInventory", TMessageType.REPLY, seqid)
2515 
    result.write(oprot)
2516 
    oprot.writeMessageEnd()
2517 
    oprot.trans.flush()
2518 
 
2519 
  def process_addInventory(self, seqid, iprot, oprot):
2520 
    args = addInventory_args()
2521 
    args.read(iprot)
2522 
    iprot.readMessageEnd()
2523 
    result = addInventory_result()
2524 
    try:
2525 
      self._handler.addInventory(args.itemId, args.warehouseId, args.quantity)
2526 
    except InventoryServiceException, cex:
2527 
      result.cex = cex
2528 
    oprot.writeMessageBegin("addInventory", TMessageType.REPLY, seqid)
2529 
    result.write(oprot)
2530 
    oprot.writeMessageEnd()
2531 
    oprot.trans.flush()
2532 
 
2533 
  def process_retireWarehouse(self, seqid, iprot, oprot):
2534 
    args = retireWarehouse_args()
2535 
    args.read(iprot)
2536 
    iprot.readMessageEnd()
2537 
    result = retireWarehouse_result()
2538 
    try:
2539 
      self._handler.retireWarehouse(args.warehouse_id)
2540 
    except InventoryServiceException, cex:
2541 
      result.cex = cex
2542 
    oprot.writeMessageBegin("retireWarehouse", TMessageType.REPLY, seqid)
2543 
    result.write(oprot)
2544 
    oprot.writeMessageEnd()
2545 
    oprot.trans.flush()
2546 
 
2547 
  def process_getItemInventoryByItemId(self, seqid, iprot, oprot):
2548 
    args = getItemInventoryByItemId_args()
2549 
    args.read(iprot)
2550 
    iprot.readMessageEnd()
2551 
    result = getItemInventoryByItemId_result()
2552 
    try:
2553 
      result.success = self._handler.getItemInventoryByItemId(args.item_id)
2554 
    except InventoryServiceException, cex:
2555 
      result.cex = cex
2556 
    oprot.writeMessageBegin("getItemInventoryByItemId", TMessageType.REPLY, seqid)
2557 
    result.write(oprot)
2558 
    oprot.writeMessageEnd()
2559 
    oprot.trans.flush()
2560 
 
2561 
  def process_getItemAvailibilityAtWarehouse(self, seqid, iprot, oprot):
2562 
    args = getItemAvailibilityAtWarehouse_args()
2563 
    args.read(iprot)
2564 
    iprot.readMessageEnd()
2565 
    result = getItemAvailibilityAtWarehouse_result()
2566 
    try:
2567 
      result.success = self._handler.getItemAvailibilityAtWarehouse(args.warehouse_id, args.item_id)
2568 
    except InventoryServiceException, cex:
2569 
      result.cex = cex
2570 
    oprot.writeMessageBegin("getItemAvailibilityAtWarehouse", TMessageType.REPLY, seqid)
2571 
    result.write(oprot)
2572 
    oprot.writeMessageEnd()
2573 
    oprot.trans.flush()
2574 
 
2575 
  def process_getItemAvailabilityAtLocation(self, seqid, iprot, oprot):
2576 
    args = getItemAvailabilityAtLocation_args()
2577 
    args.read(iprot)
2578 
    iprot.readMessageEnd()
2579 
    result = getItemAvailabilityAtLocation_result()
2580 
    try:
5978 rajveer 2581 
      result.success = self._handler.getItemAvailabilityAtLocation(args.itemId, args.sourceId)
5944 mandeep.dh 2582 
    except InventoryServiceException, isex:
2583 
      result.isex = isex
2584 
    oprot.writeMessageBegin("getItemAvailabilityAtLocation", TMessageType.REPLY, seqid)
2585 
    result.write(oprot)
2586 
    oprot.writeMessageEnd()
2587 
    oprot.trans.flush()
2588 
 
2589 
  def process_getAllWarehouses(self, seqid, iprot, oprot):
2590 
    args = getAllWarehouses_args()
2591 
    args.read(iprot)
2592 
    iprot.readMessageEnd()
2593 
    result = getAllWarehouses_result()
2594 
    try:
2595 
      result.success = self._handler.getAllWarehouses(args.isActive)
2596 
    except InventoryServiceException, cex:
2597 
      result.cex = cex
2598 
    oprot.writeMessageBegin("getAllWarehouses", TMessageType.REPLY, seqid)
2599 
    result.write(oprot)
2600 
    oprot.writeMessageEnd()
2601 
    oprot.trans.flush()
2602 
 
2603 
  def process_getWarehouse(self, seqid, iprot, oprot):
2604 
    args = getWarehouse_args()
2605 
    args.read(iprot)
2606 
    iprot.readMessageEnd()
2607 
    result = getWarehouse_result()
2608 
    try:
2609 
      result.success = self._handler.getWarehouse(args.warehouse_id)
2610 
    except InventoryServiceException, cex:
2611 
      result.cex = cex
2612 
    oprot.writeMessageBegin("getWarehouse", TMessageType.REPLY, seqid)
2613 
    result.write(oprot)
2614 
    oprot.writeMessageEnd()
2615 
    oprot.trans.flush()
2616 
 
2617 
  def process_getAllItemsForWarehouse(self, seqid, iprot, oprot):
2618 
    args = getAllItemsForWarehouse_args()
2619 
    args.read(iprot)
2620 
    iprot.readMessageEnd()
2621 
    result = getAllItemsForWarehouse_result()
2622 
    try:
2623 
      result.success = self._handler.getAllItemsForWarehouse(args.warehouse_id)
2624 
    except InventoryServiceException, cex:
2625 
      result.cex = cex
2626 
    oprot.writeMessageBegin("getAllItemsForWarehouse", TMessageType.REPLY, seqid)
2627 
    result.write(oprot)
2628 
    oprot.writeMessageEnd()
2629 
    oprot.trans.flush()
2630 
 
5966 rajveer 2631 
  def process_isOrderBillable(self, seqid, iprot, oprot):
2632 
    args = isOrderBillable_args()
2633 
    args.read(iprot)
2634 
    iprot.readMessageEnd()
2635 
    result = isOrderBillable_result()
2636 
    result.success = self._handler.isOrderBillable(args.itemId, args.warehouseId, args.sourceId, args.orderId)
2637 
    oprot.writeMessageBegin("isOrderBillable", TMessageType.REPLY, seqid)
2638 
    result.write(oprot)
2639 
    oprot.writeMessageEnd()
2640 
    oprot.trans.flush()
2641 
 
5944 mandeep.dh 2642 
  def process_reserveItemInWarehouse(self, seqid, iprot, oprot):
2643 
    args = reserveItemInWarehouse_args()
2644 
    args.read(iprot)
2645 
    iprot.readMessageEnd()
2646 
    result = reserveItemInWarehouse_result()
2647 
    try:
5966 rajveer 2648 
      result.success = self._handler.reserveItemInWarehouse(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
5944 mandeep.dh 2649 
    except InventoryServiceException, cex:
2650 
      result.cex = cex
2651 
    oprot.writeMessageBegin("reserveItemInWarehouse", TMessageType.REPLY, seqid)
2652 
    result.write(oprot)
2653 
    oprot.writeMessageEnd()
2654 
    oprot.trans.flush()
2655 
 
7968 amar.kumar 2656 
  def process_updateReservationForOrder(self, seqid, iprot, oprot):
2657 
    args = updateReservationForOrder_args()
2658 
    args.read(iprot)
2659 
    iprot.readMessageEnd()
2660 
    result = updateReservationForOrder_result()
2661 
    try:
2662 
      result.success = self._handler.updateReservationForOrder(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.createdTimestamp, args.promisedShippingTimestamp, args.quantity)
2663 
    except InventoryServiceException, cex:
2664 
      result.cex = cex
2665 
    oprot.writeMessageBegin("updateReservationForOrder", TMessageType.REPLY, seqid)
2666 
    result.write(oprot)
2667 
    oprot.writeMessageEnd()
2668 
    oprot.trans.flush()
2669 
 
5944 mandeep.dh 2670 
  def process_reduceReservationCount(self, seqid, iprot, oprot):
2671 
    args = reduceReservationCount_args()
2672 
    args.read(iprot)
2673 
    iprot.readMessageEnd()
2674 
    result = reduceReservationCount_result()
2675 
    try:
5966 rajveer 2676 
      result.success = self._handler.reduceReservationCount(args.itemId, args.warehouseId, args.sourceId, args.orderId, args.quantity)
5944 mandeep.dh 2677 
    except InventoryServiceException, cex:
2678 
      result.cex = cex
2679 
    oprot.writeMessageBegin("reduceReservationCount", TMessageType.REPLY, seqid)
2680 
    result.write(oprot)
2681 
    oprot.writeMessageEnd()
2682 
    oprot.trans.flush()
2683 
 
2684 
  def process_getItemPricing(self, seqid, iprot, oprot):
2685 
    args = getItemPricing_args()
2686 
    args.read(iprot)
2687 
    iprot.readMessageEnd()
2688 
    result = getItemPricing_result()
2689 
    try:
2690 
      result.success = self._handler.getItemPricing(args.itemId, args.vendorId)
2691 
    except InventoryServiceException, cex:
2692 
      result.cex = cex
2693 
    oprot.writeMessageBegin("getItemPricing", TMessageType.REPLY, seqid)
2694 
    result.write(oprot)
2695 
    oprot.writeMessageEnd()
2696 
    oprot.trans.flush()
2697 
 
2698 
  def process_getAllItemPricing(self, seqid, iprot, oprot):
2699 
    args = getAllItemPricing_args()
2700 
    args.read(iprot)
2701 
    iprot.readMessageEnd()
2702 
    result = getAllItemPricing_result()
2703 
    try:
2704 
      result.success = self._handler.getAllItemPricing(args.itemId)
2705 
    except InventoryServiceException, cex:
2706 
      result.cex = cex
2707 
    oprot.writeMessageBegin("getAllItemPricing", TMessageType.REPLY, seqid)
2708 
    result.write(oprot)
2709 
    oprot.writeMessageEnd()
2710 
    oprot.trans.flush()
2711 
 
2712 
  def process_addVendorItemPricing(self, seqid, iprot, oprot):
2713 
    args = addVendorItemPricing_args()
2714 
    args.read(iprot)
2715 
    iprot.readMessageEnd()
2716 
    result = addVendorItemPricing_result()
2717 
    try:
2718 
      self._handler.addVendorItemPricing(args.vendorItemPricing)
2719 
    except InventoryServiceException, cex:
2720 
      result.cex = cex
2721 
    oprot.writeMessageBegin("addVendorItemPricing", TMessageType.REPLY, seqid)
2722 
    result.write(oprot)
2723 
    oprot.writeMessageEnd()
2724 
    oprot.trans.flush()
2725 
 
2726 
  def process_getVendor(self, seqid, iprot, oprot):
2727 
    args = getVendor_args()
2728 
    args.read(iprot)
2729 
    iprot.readMessageEnd()
2730 
    result = getVendor_result()
2731 
    result.success = self._handler.getVendor(args.vendorId)
2732 
    oprot.writeMessageBegin("getVendor", TMessageType.REPLY, seqid)
2733 
    result.write(oprot)
2734 
    oprot.writeMessageEnd()
2735 
    oprot.trans.flush()
2736 
 
2737 
  def process_getAllVendors(self, seqid, iprot, oprot):
2738 
    args = getAllVendors_args()
2739 
    args.read(iprot)
2740 
    iprot.readMessageEnd()
2741 
    result = getAllVendors_result()
2742 
    result.success = self._handler.getAllVendors()
2743 
    oprot.writeMessageBegin("getAllVendors", TMessageType.REPLY, seqid)
2744 
    result.write(oprot)
2745 
    oprot.writeMessageEnd()
2746 
    oprot.trans.flush()
2747 
 
2748 
  def process_addVendorItemMapping(self, seqid, iprot, oprot):
2749 
    args = addVendorItemMapping_args()
2750 
    args.read(iprot)
2751 
    iprot.readMessageEnd()
2752 
    result = addVendorItemMapping_result()
2753 
    try:
2754 
      self._handler.addVendorItemMapping(args.key, args.vendorItemMapping)
2755 
    except InventoryServiceException, cex:
2756 
      result.cex = cex
2757 
    oprot.writeMessageBegin("addVendorItemMapping", TMessageType.REPLY, seqid)
2758 
    result.write(oprot)
2759 
    oprot.writeMessageEnd()
2760 
    oprot.trans.flush()
2761 
 
2762 
  def process_getVendorItemMappings(self, seqid, iprot, oprot):
2763 
    args = getVendorItemMappings_args()
2764 
    args.read(iprot)
2765 
    iprot.readMessageEnd()
2766 
    result = getVendorItemMappings_result()
2767 
    try:
2768 
      result.success = self._handler.getVendorItemMappings(args.itemId)
2769 
    except InventoryServiceException, cex:
2770 
      result.cex = cex
2771 
    oprot.writeMessageBegin("getVendorItemMappings", TMessageType.REPLY, seqid)
2772 
    result.write(oprot)
2773 
    oprot.writeMessageEnd()
2774 
    oprot.trans.flush()
2775 
 
2776 
  def process_getPendingOrdersInventory(self, seqid, iprot, oprot):
2777 
    args = getPendingOrdersInventory_args()
2778 
    args.read(iprot)
2779 
    iprot.readMessageEnd()
2780 
    result = getPendingOrdersInventory_result()
2781 
    result.success = self._handler.getPendingOrdersInventory(args.vendorid)
2782 
    oprot.writeMessageBegin("getPendingOrdersInventory", TMessageType.REPLY, seqid)
2783 
    result.write(oprot)
2784 
    oprot.writeMessageEnd()
2785 
    oprot.trans.flush()
2786 
 
2787 
  def process_getWarehouses(self, seqid, iprot, oprot):
2788 
    args = getWarehouses_args()
2789 
    args.read(iprot)
2790 
    iprot.readMessageEnd()
2791 
    result = getWarehouses_result()
2792 
    result.success = self._handler.getWarehouses(args.warehouseType, args.inventoryType, args.vendorId, args.billingWarehouseId, args.shippingWarehouseId)
2793 
    oprot.writeMessageBegin("getWarehouses", TMessageType.REPLY, seqid)
2794 
    result.write(oprot)
2795 
    oprot.writeMessageEnd()
2796 
    oprot.trans.flush()
2797 
 
2798 
  def process_resetAvailability(self, seqid, iprot, oprot):
2799 
    args = resetAvailability_args()
2800 
    args.read(iprot)
2801 
    iprot.readMessageEnd()
2802 
    result = resetAvailability_result()
2803 
    try:
2804 
      self._handler.resetAvailability(args.itemKey, args.vendorId, args.quantity, args.warehouseId)
2805 
    except InventoryServiceException, cex:
2806 
      result.cex = cex
2807 
    oprot.writeMessageBegin("resetAvailability", TMessageType.REPLY, seqid)
2808 
    result.write(oprot)
2809 
    oprot.writeMessageEnd()
2810 
    oprot.trans.flush()
2811 
 
2812 
  def process_resetAvailabilityForWarehouse(self, seqid, iprot, oprot):
2813 
    args = resetAvailabilityForWarehouse_args()
2814 
    args.read(iprot)
2815 
    iprot.readMessageEnd()
2816 
    result = resetAvailabilityForWarehouse_result()
2817 
    try:
2818 
      self._handler.resetAvailabilityForWarehouse(args.warehouseId)
2819 
    except InventoryServiceException, cex:
2820 
      result.cex = cex
2821 
    oprot.writeMessageBegin("resetAvailabilityForWarehouse", TMessageType.REPLY, seqid)
2822 
    result.write(oprot)
2823 
    oprot.writeMessageEnd()
2824 
    oprot.trans.flush()
2825 
 
2826 
  def process_getItemKeysToBeProcessed(self, seqid, iprot, oprot):
2827 
    args = getItemKeysToBeProcessed_args()
2828 
    args.read(iprot)
2829 
    iprot.readMessageEnd()
2830 
    result = getItemKeysToBeProcessed_result()
2831 
    result.success = self._handler.getItemKeysToBeProcessed(args.warehouseId)
2832 
    oprot.writeMessageBegin("getItemKeysToBeProcessed", TMessageType.REPLY, seqid)
2833 
    result.write(oprot)
2834 
    oprot.writeMessageEnd()
2835 
    oprot.trans.flush()
2836 
 
2837 
  def process_markMissedInventoryUpdatesAsProcessed(self, seqid, iprot, oprot):
2838 
    args = markMissedInventoryUpdatesAsProcessed_args()
2839 
    args.read(iprot)
2840 
    iprot.readMessageEnd()
2841 
    result = markMissedInventoryUpdatesAsProcessed_result()
2842 
    self._handler.markMissedInventoryUpdatesAsProcessed(args.itemKey, args.warehouseId)
2843 
    oprot.writeMessageBegin("markMissedInventoryUpdatesAsProcessed", TMessageType.REPLY, seqid)
2844 
    result.write(oprot)
2845 
    oprot.writeMessageEnd()
2846 
    oprot.trans.flush()
2847 
 
2848 
  def process_getIgnoredItemKeys(self, seqid, iprot, oprot):
2849 
    args = getIgnoredItemKeys_args()
2850 
    args.read(iprot)
2851 
    iprot.readMessageEnd()
2852 
    result = getIgnoredItemKeys_result()
2853 
    result.success = self._handler.getIgnoredItemKeys()
2854 
    oprot.writeMessageBegin("getIgnoredItemKeys", TMessageType.REPLY, seqid)
2855 
    result.write(oprot)
2856 
    oprot.writeMessageEnd()
2857 
    oprot.trans.flush()
2858 
 
2859 
  def process_addBadInventory(self, seqid, iprot, oprot):
2860 
    args = addBadInventory_args()
2861 
    args.read(iprot)
2862 
    iprot.readMessageEnd()
2863 
    result = addBadInventory_result()
2864 
    try:
2865 
      self._handler.addBadInventory(args.itemId, args.warehouseId, args.quantity)
2866 
    except InventoryServiceException, cex:
2867 
      result.cex = cex
2868 
    oprot.writeMessageBegin("addBadInventory", TMessageType.REPLY, seqid)
2869 
    result.write(oprot)
2870 
    oprot.writeMessageEnd()
2871 
    oprot.trans.flush()
2872 
 
2873 
  def process_getShippingLocations(self, seqid, iprot, oprot):
2874 
    args = getShippingLocations_args()
2875 
    args.read(iprot)
2876 
    iprot.readMessageEnd()
2877 
    result = getShippingLocations_result()
2878 
    result.success = self._handler.getShippingLocations()
2879 
    oprot.writeMessageBegin("getShippingLocations", TMessageType.REPLY, seqid)
2880 
    result.write(oprot)
2881 
    oprot.writeMessageEnd()
2882 
    oprot.trans.flush()
2883 
 
2884 
  def process_getAllVendorItemMappings(self, seqid, iprot, oprot):
2885 
    args = getAllVendorItemMappings_args()
2886 
    args.read(iprot)
2887 
    iprot.readMessageEnd()
2888 
    result = getAllVendorItemMappings_result()
2889 
    result.success = self._handler.getAllVendorItemMappings()
2890 
    oprot.writeMessageBegin("getAllVendorItemMappings", TMessageType.REPLY, seqid)
2891 
    result.write(oprot)
2892 
    oprot.writeMessageEnd()
2893 
    oprot.trans.flush()
2894 
 
2895 
  def process_getInventorySnapshot(self, seqid, iprot, oprot):
2896 
    args = getInventorySnapshot_args()
2897 
    args.read(iprot)
2898 
    iprot.readMessageEnd()
2899 
    result = getInventorySnapshot_result()
2900 
    result.success = self._handler.getInventorySnapshot(args.warehouseId)
2901 
    oprot.writeMessageBegin("getInventorySnapshot", TMessageType.REPLY, seqid)
2902 
    result.write(oprot)
2903 
    oprot.writeMessageEnd()
2904 
    oprot.trans.flush()
2905 
 
2906 
  def process_clearItemAvailabilityCache(self, seqid, iprot, oprot):
2907 
    args = clearItemAvailabilityCache_args()
2908 
    args.read(iprot)
2909 
    iprot.readMessageEnd()
2910 
    result = clearItemAvailabilityCache_result()
2911 
    self._handler.clearItemAvailabilityCache()
2912 
    oprot.writeMessageBegin("clearItemAvailabilityCache", TMessageType.REPLY, seqid)
2913 
    result.write(oprot)
2914 
    oprot.writeMessageEnd()
2915 
    oprot.trans.flush()
2916 
 
2917 
  def process_updateVendorString(self, seqid, iprot, oprot):
2918 
    args = updateVendorString_args()
2919 
    args.read(iprot)
2920 
    iprot.readMessageEnd()
2921 
    result = updateVendorString_result()
2922 
    self._handler.updateVendorString(args.warehouseId, args.vendorString)
2923 
    oprot.writeMessageBegin("updateVendorString", TMessageType.REPLY, seqid)
2924 
    result.write(oprot)
2925 
    oprot.writeMessageEnd()
2926 
    oprot.trans.flush()
2927 
 
6096 amit.gupta 2928 
  def process_clearItemAvailabilityCacheForItem(self, seqid, iprot, oprot):
2929 
    args = clearItemAvailabilityCacheForItem_args()
2930 
    args.read(iprot)
2931 
    iprot.readMessageEnd()
2932 
    result = clearItemAvailabilityCacheForItem_result()
2933 
    self._handler.clearItemAvailabilityCacheForItem(args.item_id)
2934 
    oprot.writeMessageBegin("clearItemAvailabilityCacheForItem", TMessageType.REPLY, seqid)
2935 
    result.write(oprot)
2936 
    oprot.writeMessageEnd()
2937 
    oprot.trans.flush()
5944 mandeep.dh 2938 
 
6467 amar.kumar 2939 
  def process_getOurWarehouseIdForVendor(self, seqid, iprot, oprot):
2940 
    args = getOurWarehouseIdForVendor_args()
2941 
    args.read(iprot)
2942 
    iprot.readMessageEnd()
2943 
    result = getOurWarehouseIdForVendor_result()
7718 amar.kumar 2944 
    result.success = self._handler.getOurWarehouseIdForVendor(args.vendorId, args.billingWarehouseId)
6467 amar.kumar 2945 
    oprot.writeMessageBegin("getOurWarehouseIdForVendor", TMessageType.REPLY, seqid)
2946 
    result.write(oprot)
2947 
    oprot.writeMessageEnd()
2948 
    oprot.trans.flush()
6096 amit.gupta 2949 
 
6484 amar.kumar 2950 
  def process_getItemAvailabilitiesAtOurWarehouses(self, seqid, iprot, oprot):
2951 
    args = getItemAvailabilitiesAtOurWarehouses_args()
2952 
    args.read(iprot)
2953 
    iprot.readMessageEnd()
2954 
    result = getItemAvailabilitiesAtOurWarehouses_result()
2955 
    result.success = self._handler.getItemAvailabilitiesAtOurWarehouses(args.item_ids)
2956 
    oprot.writeMessageBegin("getItemAvailabilitiesAtOurWarehouses", TMessageType.REPLY, seqid)
2957 
    result.write(oprot)
2958 
    oprot.writeMessageEnd()
2959 
    oprot.trans.flush()
6467 amar.kumar 2960 
 
6531 vikram.rag 2961 
  def process_getMonitoredWarehouseForVendors(self, seqid, iprot, oprot):
2962 
    args = getMonitoredWarehouseForVendors_args()
2963 
    args.read(iprot)
2964 
    iprot.readMessageEnd()
2965 
    result = getMonitoredWarehouseForVendors_result()
2966 
    result.success = self._handler.getMonitoredWarehouseForVendors(args.vendorIds)
2967 
    oprot.writeMessageBegin("getMonitoredWarehouseForVendors", TMessageType.REPLY, seqid)
2968 
    result.write(oprot)
2969 
    oprot.writeMessageEnd()
2970 
    oprot.trans.flush()
6484 amar.kumar 2971 
 
6531 vikram.rag 2972 
  def process_getIgnoredWarehouseidsAndItemids(self, seqid, iprot, oprot):
2973 
    args = getIgnoredWarehouseidsAndItemids_args()
2974 
    args.read(iprot)
2975 
    iprot.readMessageEnd()
2976 
    result = getIgnoredWarehouseidsAndItemids_result()
2977 
    result.success = self._handler.getIgnoredWarehouseidsAndItemids()
2978 
    oprot.writeMessageBegin("getIgnoredWarehouseidsAndItemids", TMessageType.REPLY, seqid)
2979 
    result.write(oprot)
2980 
    oprot.writeMessageEnd()
2981 
    oprot.trans.flush()
2982 
 
2983 
  def process_insertItemtoIgnoreInventoryUpdatelist(self, seqid, iprot, oprot):
2984 
    args = insertItemtoIgnoreInventoryUpdatelist_args()
2985 
    args.read(iprot)
2986 
    iprot.readMessageEnd()
2987 
    result = insertItemtoIgnoreInventoryUpdatelist_result()
2988 
    result.success = self._handler.insertItemtoIgnoreInventoryUpdatelist(args.item_id, args.warehouse_id)
2989 
    oprot.writeMessageBegin("insertItemtoIgnoreInventoryUpdatelist", TMessageType.REPLY, seqid)
2990 
    result.write(oprot)
2991 
    oprot.writeMessageEnd()
2992 
    oprot.trans.flush()
2993 
 
2994 
  def process_deleteItemFromIgnoredInventoryUpdateList(self, seqid, iprot, oprot):
2995 
    args = deleteItemFromIgnoredInventoryUpdateList_args()
2996 
    args.read(iprot)
2997 
    iprot.readMessageEnd()
2998 
    result = deleteItemFromIgnoredInventoryUpdateList_result()
2999 
    result.success = self._handler.deleteItemFromIgnoredInventoryUpdateList(args.item_id, args.warehouse_id)
3000 
    oprot.writeMessageBegin("deleteItemFromIgnoredInventoryUpdateList", TMessageType.REPLY, seqid)
3001 
    result.write(oprot)
3002 
    oprot.writeMessageEnd()
3003 
    oprot.trans.flush()
3004 
 
3005 
  def process_getAllIgnoredInventoryupdateItemsCount(self, seqid, iprot, oprot):
3006 
    args = getAllIgnoredInventoryupdateItemsCount_args()
3007 
    args.read(iprot)
3008 
    iprot.readMessageEnd()
3009 
    result = getAllIgnoredInventoryupdateItemsCount_result()
3010 
    result.success = self._handler.getAllIgnoredInventoryupdateItemsCount()
3011 
    oprot.writeMessageBegin("getAllIgnoredInventoryupdateItemsCount", TMessageType.REPLY, seqid)
3012 
    result.write(oprot)
3013 
    oprot.writeMessageEnd()
3014 
    oprot.trans.flush()
3015 
 
3016 
  def process_getIgnoredInventoryUpdateItemids(self, seqid, iprot, oprot):
3017 
    args = getIgnoredInventoryUpdateItemids_args()
3018 
    args.read(iprot)
3019 
    iprot.readMessageEnd()
3020 
    result = getIgnoredInventoryUpdateItemids_result()
3021 
    result.success = self._handler.getIgnoredInventoryUpdateItemids(args.offset, args.limit)
3022 
    oprot.writeMessageBegin("getIgnoredInventoryUpdateItemids", TMessageType.REPLY, seqid)
3023 
    result.write(oprot)
3024 
    oprot.writeMessageEnd()
3025 
    oprot.trans.flush()
3026 
 
6821 amar.kumar 3027 
  def process_updateItemStockPurchaseParams(self, seqid, iprot, oprot):
3028 
    args = updateItemStockPurchaseParams_args()
3029 
    args.read(iprot)
3030 
    iprot.readMessageEnd()
3031 
    result = updateItemStockPurchaseParams_result()
3032 
    self._handler.updateItemStockPurchaseParams(args.item_id, args.numOfDaysStock, args.minStockLevel)
3033 
    oprot.writeMessageBegin("updateItemStockPurchaseParams", TMessageType.REPLY, seqid)
3034 
    result.write(oprot)
3035 
    oprot.writeMessageEnd()
3036 
    oprot.trans.flush()
6531 vikram.rag 3037 
 
6821 amar.kumar 3038 
  def process_getItemStockPurchaseParams(self, seqid, iprot, oprot):
3039 
    args = getItemStockPurchaseParams_args()
3040 
    args.read(iprot)
3041 
    iprot.readMessageEnd()
3042 
    result = getItemStockPurchaseParams_result()
3043 
    result.success = self._handler.getItemStockPurchaseParams(args.itemId)
3044 
    oprot.writeMessageBegin("getItemStockPurchaseParams", TMessageType.REPLY, seqid)
3045 
    result.write(oprot)
3046 
    oprot.writeMessageEnd()
3047 
    oprot.trans.flush()
3048 
 
3049 
  def process_addOosStatusForItem(self, seqid, iprot, oprot):
3050 
    args = addOosStatusForItem_args()
3051 
    args.read(iprot)
3052 
    iprot.readMessageEnd()
3053 
    result = addOosStatusForItem_result()
3054 
    self._handler.addOosStatusForItem(args.oosStatusMap, args.date)
3055 
    oprot.writeMessageBegin("addOosStatusForItem", TMessageType.REPLY, seqid)
3056 
    result.write(oprot)
3057 
    oprot.writeMessageEnd()
3058 
    oprot.trans.flush()
3059 
 
6832 amar.kumar 3060 
  def process_getOosStatusesForXDaysForItem(self, seqid, iprot, oprot):
3061 
    args = getOosStatusesForXDaysForItem_args()
3062 
    args.read(iprot)
3063 
    iprot.readMessageEnd()
3064 
    result = getOosStatusesForXDaysForItem_result()
3065 
    result.success = self._handler.getOosStatusesForXDaysForItem(args.itemId, args.days)
3066 
    oprot.writeMessageBegin("getOosStatusesForXDaysForItem", TMessageType.REPLY, seqid)
3067 
    result.write(oprot)
3068 
    oprot.writeMessageEnd()
3069 
    oprot.trans.flush()
6821 amar.kumar 3070 
 
6857 amar.kumar 3071 
  def process_getNonZeroItemStockPurchaseParams(self, seqid, iprot, oprot):
3072 
    args = getNonZeroItemStockPurchaseParams_args()
3073 
    args.read(iprot)
3074 
    iprot.readMessageEnd()
3075 
    result = getNonZeroItemStockPurchaseParams_result()
3076 
    result.success = self._handler.getNonZeroItemStockPurchaseParams()
3077 
    oprot.writeMessageBegin("getNonZeroItemStockPurchaseParams", TMessageType.REPLY, seqid)
3078 
    result.write(oprot)
3079 
    oprot.writeMessageEnd()
3080 
    oprot.trans.flush()
6832 amar.kumar 3081 
 
7149 amar.kumar 3082 
  def process_getBillableInventoryAndPendingOrders(self, seqid, iprot, oprot):
3083 
    args = getBillableInventoryAndPendingOrders_args()
3084 
    args.read(iprot)
3085 
    iprot.readMessageEnd()
3086 
    result = getBillableInventoryAndPendingOrders_result()
3087 
    result.success = self._handler.getBillableInventoryAndPendingOrders()
3088 
    oprot.writeMessageBegin("getBillableInventoryAndPendingOrders", TMessageType.REPLY, seqid)
3089 
    result.write(oprot)
3090 
    oprot.writeMessageEnd()
3091 
    oprot.trans.flush()
6857 amar.kumar 3092 
 
7281 kshitij.so 3093 
  def process_getWarehouseName(self, seqid, iprot, oprot):
3094 
    args = getWarehouseName_args()
3095 
    args.read(iprot)
3096 
    iprot.readMessageEnd()
3097 
    result = getWarehouseName_result()
3098 
    result.success = self._handler.getWarehouseName(args.warehouse_id)
3099 
    oprot.writeMessageBegin("getWarehouseName", TMessageType.REPLY, seqid)
3100 
    result.write(oprot)
3101 
    oprot.writeMessageEnd()
3102 
    oprot.trans.flush()
7149 amar.kumar 3103 
 
7281 kshitij.so 3104 
  def process_getAmazonInventoryForItem(self, seqid, iprot, oprot):
3105 
    args = getAmazonInventoryForItem_args()
3106 
    args.read(iprot)
3107 
    iprot.readMessageEnd()
3108 
    result = getAmazonInventoryForItem_result()
3109 
    result.success = self._handler.getAmazonInventoryForItem(args.item_id)
3110 
    oprot.writeMessageBegin("getAmazonInventoryForItem", TMessageType.REPLY, seqid)
3111 
    result.write(oprot)
3112 
    oprot.writeMessageEnd()
3113 
    oprot.trans.flush()
3114 
 
3115 
  def process_getAllAmazonInventory(self, seqid, iprot, oprot):
3116 
    args = getAllAmazonInventory_args()
3117 
    args.read(iprot)
3118 
    iprot.readMessageEnd()
3119 
    result = getAllAmazonInventory_result()
3120 
    result.success = self._handler.getAllAmazonInventory()
3121 
    oprot.writeMessageBegin("getAllAmazonInventory", TMessageType.REPLY, seqid)
3122 
    result.write(oprot)
3123 
    oprot.writeMessageEnd()
3124 
    oprot.trans.flush()
3125 
 
3126 
  def process_addOrUpdateAmazonInventoryForItem(self, seqid, iprot, oprot):
3127 
    args = addOrUpdateAmazonInventoryForItem_args()
3128 
    args.read(iprot)
3129 
    iprot.readMessageEnd()
3130 
    result = addOrUpdateAmazonInventoryForItem_result()
3131 
    self._handler.addOrUpdateAmazonInventoryForItem(args.amazonInventorySnapshot)
3132 
    oprot.writeMessageBegin("addOrUpdateAmazonInventoryForItem", TMessageType.REPLY, seqid)
3133 
    result.write(oprot)
3134 
    oprot.writeMessageEnd()
3135 
    oprot.trans.flush()
3136 
 
7972 amar.kumar 3137 
  def process_getLastNdaySaleForItem(self, seqid, iprot, oprot):
3138 
    args = getLastNdaySaleForItem_args()
3139 
    args.read(iprot)
3140 
    iprot.readMessageEnd()
3141 
    result = getLastNdaySaleForItem_result()
3142 
    result.success = self._handler.getLastNdaySaleForItem(args.itemId, args.numberOfDays)
3143 
    oprot.writeMessageBegin("getLastNdaySaleForItem", TMessageType.REPLY, seqid)
3144 
    result.write(oprot)
3145 
    oprot.writeMessageEnd()
3146 
    oprot.trans.flush()
7281 kshitij.so 3147 
 
8182 amar.kumar 3148 
  def process_addUpdateHoldInventory(self, seqid, iprot, oprot):
3149 
    args = addUpdateHoldInventory_args()
3150 
    args.read(iprot)
3151 
    iprot.readMessageEnd()
3152 
    result = addUpdateHoldInventory_result()
3153 
    self._handler.addUpdateHoldInventory(args.itemId, args.warehouseId, args.holdQuantity, args.source)
3154 
    oprot.writeMessageBegin("addUpdateHoldInventory", TMessageType.REPLY, seqid)
3155 
    result.write(oprot)
3156 
    oprot.writeMessageEnd()
3157 
    oprot.trans.flush()
7972 amar.kumar 3158 
 
8182 amar.kumar 3159 
 
5944 mandeep.dh 3160 
# HELPER FUNCTIONS AND STRUCTURES
3161 
 
3162 
class addWarehouse_args:
3163 
  """
3164 
  Attributes:
3165 
   - warehouse
3166 
  """
3167 
 
3168 
  thrift_spec = (
3169 
    None, # 0
3170 
    (1, TType.STRUCT, 'warehouse', (Warehouse, Warehouse.thrift_spec), None, ), # 1
3171 
  )
3172 
 
3173 
  def __init__(self, warehouse=None,):
3174 
    self.warehouse = warehouse
3175 
 
3176 
  def read(self, iprot):
3177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3179 
      return
3180 
    iprot.readStructBegin()
3181 
    while True:
3182 
      (fname, ftype, fid) = iprot.readFieldBegin()
3183 
      if ftype == TType.STOP:
3184 
        break
3185 
      if fid == 1:
3186 
        if ftype == TType.STRUCT:
3187 
          self.warehouse = Warehouse()
3188 
          self.warehouse.read(iprot)
3189 
        else:
3190 
          iprot.skip(ftype)
3191 
      else:
3192 
        iprot.skip(ftype)
3193 
      iprot.readFieldEnd()
3194 
    iprot.readStructEnd()
3195 
 
3196 
  def write(self, oprot):
3197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3199 
      return
3200 
    oprot.writeStructBegin('addWarehouse_args')
3201 
    if self.warehouse is not None:
3202 
      oprot.writeFieldBegin('warehouse', TType.STRUCT, 1)
3203 
      self.warehouse.write(oprot)
3204 
      oprot.writeFieldEnd()
3205 
    oprot.writeFieldStop()
3206 
    oprot.writeStructEnd()
3207 
 
3208 
  def validate(self):
3209 
    return
3210 
 
3211 
 
3212 
  def __repr__(self):
3213 
    L = ['%s=%r' % (key, value)
3214 
      for key, value in self.__dict__.iteritems()]
3215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3216 
 
3217 
  def __eq__(self, other):
3218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3219 
 
3220 
  def __ne__(self, other):
3221 
    return not (self == other)
3222 
 
3223 
class addWarehouse_result:
3224 
  """
3225 
  Attributes:
3226 
   - success
3227 
   - cex
3228 
  """
3229 
 
3230 
  thrift_spec = (
3231 
    (0, TType.I64, 'success', None, None, ), # 0
3232 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3233 
  )
3234 
 
3235 
  def __init__(self, success=None, cex=None,):
3236 
    self.success = success
3237 
    self.cex = cex
3238 
 
3239 
  def read(self, iprot):
3240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3242 
      return
3243 
    iprot.readStructBegin()
3244 
    while True:
3245 
      (fname, ftype, fid) = iprot.readFieldBegin()
3246 
      if ftype == TType.STOP:
3247 
        break
3248 
      if fid == 0:
3249 
        if ftype == TType.I64:
3250 
          self.success = iprot.readI64();
3251 
        else:
3252 
          iprot.skip(ftype)
3253 
      elif fid == 1:
3254 
        if ftype == TType.STRUCT:
3255 
          self.cex = InventoryServiceException()
3256 
          self.cex.read(iprot)
3257 
        else:
3258 
          iprot.skip(ftype)
3259 
      else:
3260 
        iprot.skip(ftype)
3261 
      iprot.readFieldEnd()
3262 
    iprot.readStructEnd()
3263 
 
3264 
  def write(self, oprot):
3265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3267 
      return
3268 
    oprot.writeStructBegin('addWarehouse_result')
3269 
    if self.success is not None:
3270 
      oprot.writeFieldBegin('success', TType.I64, 0)
3271 
      oprot.writeI64(self.success)
3272 
      oprot.writeFieldEnd()
3273 
    if self.cex is not None:
3274 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3275 
      self.cex.write(oprot)
3276 
      oprot.writeFieldEnd()
3277 
    oprot.writeFieldStop()
3278 
    oprot.writeStructEnd()
3279 
 
3280 
  def validate(self):
3281 
    return
3282 
 
3283 
 
3284 
  def __repr__(self):
3285 
    L = ['%s=%r' % (key, value)
3286 
      for key, value in self.__dict__.iteritems()]
3287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3288 
 
3289 
  def __eq__(self, other):
3290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3291 
 
3292 
  def __ne__(self, other):
3293 
    return not (self == other)
3294 
 
3295 
class addVendor_args:
3296 
  """
3297 
  Attributes:
3298 
   - vendor
3299 
  """
3300 
 
3301 
  thrift_spec = (
3302 
    None, # 0
3303 
    (1, TType.STRUCT, 'vendor', (Vendor, Vendor.thrift_spec), None, ), # 1
3304 
  )
3305 
 
3306 
  def __init__(self, vendor=None,):
3307 
    self.vendor = vendor
3308 
 
3309 
  def read(self, iprot):
3310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3312 
      return
3313 
    iprot.readStructBegin()
3314 
    while True:
3315 
      (fname, ftype, fid) = iprot.readFieldBegin()
3316 
      if ftype == TType.STOP:
3317 
        break
3318 
      if fid == 1:
3319 
        if ftype == TType.STRUCT:
3320 
          self.vendor = Vendor()
3321 
          self.vendor.read(iprot)
3322 
        else:
3323 
          iprot.skip(ftype)
3324 
      else:
3325 
        iprot.skip(ftype)
3326 
      iprot.readFieldEnd()
3327 
    iprot.readStructEnd()
3328 
 
3329 
  def write(self, oprot):
3330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3332 
      return
3333 
    oprot.writeStructBegin('addVendor_args')
3334 
    if self.vendor is not None:
3335 
      oprot.writeFieldBegin('vendor', TType.STRUCT, 1)
3336 
      self.vendor.write(oprot)
3337 
      oprot.writeFieldEnd()
3338 
    oprot.writeFieldStop()
3339 
    oprot.writeStructEnd()
3340 
 
3341 
  def validate(self):
3342 
    return
3343 
 
3344 
 
3345 
  def __repr__(self):
3346 
    L = ['%s=%r' % (key, value)
3347 
      for key, value in self.__dict__.iteritems()]
3348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3349 
 
3350 
  def __eq__(self, other):
3351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3352 
 
3353 
  def __ne__(self, other):
3354 
    return not (self == other)
3355 
 
3356 
class addVendor_result:
3357 
  """
3358 
  Attributes:
3359 
   - success
3360 
   - cex
3361 
  """
3362 
 
3363 
  thrift_spec = (
3364 
    (0, TType.I64, 'success', None, None, ), # 0
3365 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3366 
  )
3367 
 
3368 
  def __init__(self, success=None, cex=None,):
3369 
    self.success = success
3370 
    self.cex = cex
3371 
 
3372 
  def read(self, iprot):
3373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3375 
      return
3376 
    iprot.readStructBegin()
3377 
    while True:
3378 
      (fname, ftype, fid) = iprot.readFieldBegin()
3379 
      if ftype == TType.STOP:
3380 
        break
3381 
      if fid == 0:
3382 
        if ftype == TType.I64:
3383 
          self.success = iprot.readI64();
3384 
        else:
3385 
          iprot.skip(ftype)
3386 
      elif fid == 1:
3387 
        if ftype == TType.STRUCT:
3388 
          self.cex = InventoryServiceException()
3389 
          self.cex.read(iprot)
3390 
        else:
3391 
          iprot.skip(ftype)
3392 
      else:
3393 
        iprot.skip(ftype)
3394 
      iprot.readFieldEnd()
3395 
    iprot.readStructEnd()
3396 
 
3397 
  def write(self, oprot):
3398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3400 
      return
3401 
    oprot.writeStructBegin('addVendor_result')
3402 
    if self.success is not None:
3403 
      oprot.writeFieldBegin('success', TType.I64, 0)
3404 
      oprot.writeI64(self.success)
3405 
      oprot.writeFieldEnd()
3406 
    if self.cex is not None:
3407 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3408 
      self.cex.write(oprot)
3409 
      oprot.writeFieldEnd()
3410 
    oprot.writeFieldStop()
3411 
    oprot.writeStructEnd()
3412 
 
3413 
  def validate(self):
3414 
    return
3415 
 
3416 
 
3417 
  def __repr__(self):
3418 
    L = ['%s=%r' % (key, value)
3419 
      for key, value in self.__dict__.iteritems()]
3420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3421 
 
3422 
  def __eq__(self, other):
3423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3424 
 
3425 
  def __ne__(self, other):
3426 
    return not (self == other)
3427 
 
3428 
class updateInventoryHistory_args:
3429 
  """
3430 
  Attributes:
3431 
   - warehouse_id
3432 
   - timestamp
3433 
   - availability
3434 
  """
3435 
 
3436 
  thrift_spec = (
3437 
    None, # 0
3438 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
3439 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
3440 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
3441 
  )
3442 
 
3443 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
3444 
    self.warehouse_id = warehouse_id
3445 
    self.timestamp = timestamp
3446 
    self.availability = availability
3447 
 
3448 
  def read(self, iprot):
3449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3451 
      return
3452 
    iprot.readStructBegin()
3453 
    while True:
3454 
      (fname, ftype, fid) = iprot.readFieldBegin()
3455 
      if ftype == TType.STOP:
3456 
        break
3457 
      if fid == 1:
3458 
        if ftype == TType.I64:
3459 
          self.warehouse_id = iprot.readI64();
3460 
        else:
3461 
          iprot.skip(ftype)
3462 
      elif fid == 2:
3463 
        if ftype == TType.STRING:
3464 
          self.timestamp = iprot.readString();
3465 
        else:
3466 
          iprot.skip(ftype)
3467 
      elif fid == 3:
3468 
        if ftype == TType.MAP:
3469 
          self.availability = {}
8182 amar.kumar 3470 
          (_ktype28, _vtype29, _size27 ) = iprot.readMapBegin()
3471 
          for _i31 in xrange(_size27):
3472 
            _key32 = iprot.readString();
3473 
            _val33 = iprot.readI64();
3474 
            self.availability[_key32] = _val33
5944 mandeep.dh 3475 
          iprot.readMapEnd()
3476 
        else:
3477 
          iprot.skip(ftype)
3478 
      else:
3479 
        iprot.skip(ftype)
3480 
      iprot.readFieldEnd()
3481 
    iprot.readStructEnd()
3482 
 
3483 
  def write(self, oprot):
3484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3486 
      return
3487 
    oprot.writeStructBegin('updateInventoryHistory_args')
3488 
    if self.warehouse_id is not None:
3489 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
3490 
      oprot.writeI64(self.warehouse_id)
3491 
      oprot.writeFieldEnd()
3492 
    if self.timestamp is not None:
3493 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
3494 
      oprot.writeString(self.timestamp)
3495 
      oprot.writeFieldEnd()
3496 
    if self.availability is not None:
3497 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
3498 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 3499 
      for kiter34,viter35 in self.availability.items():
3500 
        oprot.writeString(kiter34)
3501 
        oprot.writeI64(viter35)
5944 mandeep.dh 3502 
      oprot.writeMapEnd()
3503 
      oprot.writeFieldEnd()
3504 
    oprot.writeFieldStop()
3505 
    oprot.writeStructEnd()
3506 
 
3507 
  def validate(self):
3508 
    return
3509 
 
3510 
 
3511 
  def __repr__(self):
3512 
    L = ['%s=%r' % (key, value)
3513 
      for key, value in self.__dict__.iteritems()]
3514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3515 
 
3516 
  def __eq__(self, other):
3517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3518 
 
3519 
  def __ne__(self, other):
3520 
    return not (self == other)
3521 
 
3522 
class updateInventoryHistory_result:
3523 
  """
3524 
  Attributes:
3525 
   - cex
3526 
  """
3527 
 
3528 
  thrift_spec = (
3529 
    None, # 0
3530 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3531 
  )
3532 
 
3533 
  def __init__(self, cex=None,):
3534 
    self.cex = cex
3535 
 
3536 
  def read(self, iprot):
3537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3539 
      return
3540 
    iprot.readStructBegin()
3541 
    while True:
3542 
      (fname, ftype, fid) = iprot.readFieldBegin()
3543 
      if ftype == TType.STOP:
3544 
        break
3545 
      if fid == 1:
3546 
        if ftype == TType.STRUCT:
3547 
          self.cex = InventoryServiceException()
3548 
          self.cex.read(iprot)
3549 
        else:
3550 
          iprot.skip(ftype)
3551 
      else:
3552 
        iprot.skip(ftype)
3553 
      iprot.readFieldEnd()
3554 
    iprot.readStructEnd()
3555 
 
3556 
  def write(self, oprot):
3557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3559 
      return
3560 
    oprot.writeStructBegin('updateInventoryHistory_result')
3561 
    if self.cex is not None:
3562 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3563 
      self.cex.write(oprot)
3564 
      oprot.writeFieldEnd()
3565 
    oprot.writeFieldStop()
3566 
    oprot.writeStructEnd()
3567 
 
3568 
  def validate(self):
3569 
    return
3570 
 
3571 
 
3572 
  def __repr__(self):
3573 
    L = ['%s=%r' % (key, value)
3574 
      for key, value in self.__dict__.iteritems()]
3575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3576 
 
3577 
  def __eq__(self, other):
3578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3579 
 
3580 
  def __ne__(self, other):
3581 
    return not (self == other)
3582 
 
3583 
class updateInventory_args:
3584 
  """
3585 
  Attributes:
3586 
   - warehouse_id
3587 
   - timestamp
3588 
   - availability
3589 
  """
3590 
 
3591 
  thrift_spec = (
3592 
    None, # 0
3593 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
3594 
    (2, TType.STRING, 'timestamp', None, None, ), # 2
3595 
    (3, TType.MAP, 'availability', (TType.STRING,None,TType.I64,None), None, ), # 3
3596 
  )
3597 
 
3598 
  def __init__(self, warehouse_id=None, timestamp=None, availability=None,):
3599 
    self.warehouse_id = warehouse_id
3600 
    self.timestamp = timestamp
3601 
    self.availability = availability
3602 
 
3603 
  def read(self, iprot):
3604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3606 
      return
3607 
    iprot.readStructBegin()
3608 
    while True:
3609 
      (fname, ftype, fid) = iprot.readFieldBegin()
3610 
      if ftype == TType.STOP:
3611 
        break
3612 
      if fid == 1:
3613 
        if ftype == TType.I64:
3614 
          self.warehouse_id = iprot.readI64();
3615 
        else:
3616 
          iprot.skip(ftype)
3617 
      elif fid == 2:
3618 
        if ftype == TType.STRING:
3619 
          self.timestamp = iprot.readString();
3620 
        else:
3621 
          iprot.skip(ftype)
3622 
      elif fid == 3:
3623 
        if ftype == TType.MAP:
3624 
          self.availability = {}
8182 amar.kumar 3625 
          (_ktype37, _vtype38, _size36 ) = iprot.readMapBegin()
3626 
          for _i40 in xrange(_size36):
3627 
            _key41 = iprot.readString();
3628 
            _val42 = iprot.readI64();
3629 
            self.availability[_key41] = _val42
5944 mandeep.dh 3630 
          iprot.readMapEnd()
3631 
        else:
3632 
          iprot.skip(ftype)
3633 
      else:
3634 
        iprot.skip(ftype)
3635 
      iprot.readFieldEnd()
3636 
    iprot.readStructEnd()
3637 
 
3638 
  def write(self, oprot):
3639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3641 
      return
3642 
    oprot.writeStructBegin('updateInventory_args')
3643 
    if self.warehouse_id is not None:
3644 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
3645 
      oprot.writeI64(self.warehouse_id)
3646 
      oprot.writeFieldEnd()
3647 
    if self.timestamp is not None:
3648 
      oprot.writeFieldBegin('timestamp', TType.STRING, 2)
3649 
      oprot.writeString(self.timestamp)
3650 
      oprot.writeFieldEnd()
3651 
    if self.availability is not None:
3652 
      oprot.writeFieldBegin('availability', TType.MAP, 3)
3653 
      oprot.writeMapBegin(TType.STRING, TType.I64, len(self.availability))
8182 amar.kumar 3654 
      for kiter43,viter44 in self.availability.items():
3655 
        oprot.writeString(kiter43)
3656 
        oprot.writeI64(viter44)
5944 mandeep.dh 3657 
      oprot.writeMapEnd()
3658 
      oprot.writeFieldEnd()
3659 
    oprot.writeFieldStop()
3660 
    oprot.writeStructEnd()
3661 
 
3662 
  def validate(self):
3663 
    return
3664 
 
3665 
 
3666 
  def __repr__(self):
3667 
    L = ['%s=%r' % (key, value)
3668 
      for key, value in self.__dict__.iteritems()]
3669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3670 
 
3671 
  def __eq__(self, other):
3672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3673 
 
3674 
  def __ne__(self, other):
3675 
    return not (self == other)
3676 
 
3677 
class updateInventory_result:
3678 
  """
3679 
  Attributes:
3680 
   - cex
3681 
  """
3682 
 
3683 
  thrift_spec = (
3684 
    None, # 0
3685 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3686 
  )
3687 
 
3688 
  def __init__(self, cex=None,):
3689 
    self.cex = cex
3690 
 
3691 
  def read(self, iprot):
3692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3694 
      return
3695 
    iprot.readStructBegin()
3696 
    while True:
3697 
      (fname, ftype, fid) = iprot.readFieldBegin()
3698 
      if ftype == TType.STOP:
3699 
        break
3700 
      if fid == 1:
3701 
        if ftype == TType.STRUCT:
3702 
          self.cex = InventoryServiceException()
3703 
          self.cex.read(iprot)
3704 
        else:
3705 
          iprot.skip(ftype)
3706 
      else:
3707 
        iprot.skip(ftype)
3708 
      iprot.readFieldEnd()
3709 
    iprot.readStructEnd()
3710 
 
3711 
  def write(self, oprot):
3712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3714 
      return
3715 
    oprot.writeStructBegin('updateInventory_result')
3716 
    if self.cex is not None:
3717 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3718 
      self.cex.write(oprot)
3719 
      oprot.writeFieldEnd()
3720 
    oprot.writeFieldStop()
3721 
    oprot.writeStructEnd()
3722 
 
3723 
  def validate(self):
3724 
    return
3725 
 
3726 
 
3727 
  def __repr__(self):
3728 
    L = ['%s=%r' % (key, value)
3729 
      for key, value in self.__dict__.iteritems()]
3730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3731 
 
3732 
  def __eq__(self, other):
3733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3734 
 
3735 
  def __ne__(self, other):
3736 
    return not (self == other)
3737 
 
3738 
class addInventory_args:
3739 
  """
3740 
  Attributes:
3741 
   - itemId
3742 
   - warehouseId
3743 
   - quantity
3744 
  """
3745 
 
3746 
  thrift_spec = (
3747 
    None, # 0
3748 
    (1, TType.I64, 'itemId', None, None, ), # 1
3749 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
3750 
    (3, TType.I64, 'quantity', None, None, ), # 3
3751 
  )
3752 
 
3753 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
3754 
    self.itemId = itemId
3755 
    self.warehouseId = warehouseId
3756 
    self.quantity = quantity
3757 
 
3758 
  def read(self, iprot):
3759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3761 
      return
3762 
    iprot.readStructBegin()
3763 
    while True:
3764 
      (fname, ftype, fid) = iprot.readFieldBegin()
3765 
      if ftype == TType.STOP:
3766 
        break
3767 
      if fid == 1:
3768 
        if ftype == TType.I64:
3769 
          self.itemId = iprot.readI64();
3770 
        else:
3771 
          iprot.skip(ftype)
3772 
      elif fid == 2:
3773 
        if ftype == TType.I64:
3774 
          self.warehouseId = iprot.readI64();
3775 
        else:
3776 
          iprot.skip(ftype)
3777 
      elif fid == 3:
3778 
        if ftype == TType.I64:
3779 
          self.quantity = iprot.readI64();
3780 
        else:
3781 
          iprot.skip(ftype)
3782 
      else:
3783 
        iprot.skip(ftype)
3784 
      iprot.readFieldEnd()
3785 
    iprot.readStructEnd()
3786 
 
3787 
  def write(self, oprot):
3788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3790 
      return
3791 
    oprot.writeStructBegin('addInventory_args')
3792 
    if self.itemId is not None:
3793 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
3794 
      oprot.writeI64(self.itemId)
3795 
      oprot.writeFieldEnd()
3796 
    if self.warehouseId is not None:
3797 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
3798 
      oprot.writeI64(self.warehouseId)
3799 
      oprot.writeFieldEnd()
3800 
    if self.quantity is not None:
3801 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
3802 
      oprot.writeI64(self.quantity)
3803 
      oprot.writeFieldEnd()
3804 
    oprot.writeFieldStop()
3805 
    oprot.writeStructEnd()
3806 
 
3807 
  def validate(self):
3808 
    return
3809 
 
3810 
 
3811 
  def __repr__(self):
3812 
    L = ['%s=%r' % (key, value)
3813 
      for key, value in self.__dict__.iteritems()]
3814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3815 
 
3816 
  def __eq__(self, other):
3817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3818 
 
3819 
  def __ne__(self, other):
3820 
    return not (self == other)
3821 
 
3822 
class addInventory_result:
3823 
  """
3824 
  Attributes:
3825 
   - cex
3826 
  """
3827 
 
3828 
  thrift_spec = (
3829 
    None, # 0
3830 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3831 
  )
3832 
 
3833 
  def __init__(self, cex=None,):
3834 
    self.cex = cex
3835 
 
3836 
  def read(self, iprot):
3837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3839 
      return
3840 
    iprot.readStructBegin()
3841 
    while True:
3842 
      (fname, ftype, fid) = iprot.readFieldBegin()
3843 
      if ftype == TType.STOP:
3844 
        break
3845 
      if fid == 1:
3846 
        if ftype == TType.STRUCT:
3847 
          self.cex = InventoryServiceException()
3848 
          self.cex.read(iprot)
3849 
        else:
3850 
          iprot.skip(ftype)
3851 
      else:
3852 
        iprot.skip(ftype)
3853 
      iprot.readFieldEnd()
3854 
    iprot.readStructEnd()
3855 
 
3856 
  def write(self, oprot):
3857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3859 
      return
3860 
    oprot.writeStructBegin('addInventory_result')
3861 
    if self.cex is not None:
3862 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3863 
      self.cex.write(oprot)
3864 
      oprot.writeFieldEnd()
3865 
    oprot.writeFieldStop()
3866 
    oprot.writeStructEnd()
3867 
 
3868 
  def validate(self):
3869 
    return
3870 
 
3871 
 
3872 
  def __repr__(self):
3873 
    L = ['%s=%r' % (key, value)
3874 
      for key, value in self.__dict__.iteritems()]
3875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3876 
 
3877 
  def __eq__(self, other):
3878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3879 
 
3880 
  def __ne__(self, other):
3881 
    return not (self == other)
3882 
 
3883 
class retireWarehouse_args:
3884 
  """
3885 
  Attributes:
3886 
   - warehouse_id
3887 
  """
3888 
 
3889 
  thrift_spec = (
3890 
    None, # 0
3891 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
3892 
  )
3893 
 
3894 
  def __init__(self, warehouse_id=None,):
3895 
    self.warehouse_id = warehouse_id
3896 
 
3897 
  def read(self, iprot):
3898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3900 
      return
3901 
    iprot.readStructBegin()
3902 
    while True:
3903 
      (fname, ftype, fid) = iprot.readFieldBegin()
3904 
      if ftype == TType.STOP:
3905 
        break
3906 
      if fid == 1:
3907 
        if ftype == TType.I64:
3908 
          self.warehouse_id = iprot.readI64();
3909 
        else:
3910 
          iprot.skip(ftype)
3911 
      else:
3912 
        iprot.skip(ftype)
3913 
      iprot.readFieldEnd()
3914 
    iprot.readStructEnd()
3915 
 
3916 
  def write(self, oprot):
3917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3919 
      return
3920 
    oprot.writeStructBegin('retireWarehouse_args')
3921 
    if self.warehouse_id is not None:
3922 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
3923 
      oprot.writeI64(self.warehouse_id)
3924 
      oprot.writeFieldEnd()
3925 
    oprot.writeFieldStop()
3926 
    oprot.writeStructEnd()
3927 
 
3928 
  def validate(self):
3929 
    return
3930 
 
3931 
 
3932 
  def __repr__(self):
3933 
    L = ['%s=%r' % (key, value)
3934 
      for key, value in self.__dict__.iteritems()]
3935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3936 
 
3937 
  def __eq__(self, other):
3938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3939 
 
3940 
  def __ne__(self, other):
3941 
    return not (self == other)
3942 
 
3943 
class retireWarehouse_result:
3944 
  """
3945 
  Attributes:
3946 
   - cex
3947 
  """
3948 
 
3949 
  thrift_spec = (
3950 
    None, # 0
3951 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
3952 
  )
3953 
 
3954 
  def __init__(self, cex=None,):
3955 
    self.cex = cex
3956 
 
3957 
  def read(self, iprot):
3958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3960 
      return
3961 
    iprot.readStructBegin()
3962 
    while True:
3963 
      (fname, ftype, fid) = iprot.readFieldBegin()
3964 
      if ftype == TType.STOP:
3965 
        break
3966 
      if fid == 1:
3967 
        if ftype == TType.STRUCT:
3968 
          self.cex = InventoryServiceException()
3969 
          self.cex.read(iprot)
3970 
        else:
3971 
          iprot.skip(ftype)
3972 
      else:
3973 
        iprot.skip(ftype)
3974 
      iprot.readFieldEnd()
3975 
    iprot.readStructEnd()
3976 
 
3977 
  def write(self, oprot):
3978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3980 
      return
3981 
    oprot.writeStructBegin('retireWarehouse_result')
3982 
    if self.cex is not None:
3983 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
3984 
      self.cex.write(oprot)
3985 
      oprot.writeFieldEnd()
3986 
    oprot.writeFieldStop()
3987 
    oprot.writeStructEnd()
3988 
 
3989 
  def validate(self):
3990 
    return
3991 
 
3992 
 
3993 
  def __repr__(self):
3994 
    L = ['%s=%r' % (key, value)
3995 
      for key, value in self.__dict__.iteritems()]
3996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3997 
 
3998 
  def __eq__(self, other):
3999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4000 
 
4001 
  def __ne__(self, other):
4002 
    return not (self == other)
4003 
 
4004 
class getItemInventoryByItemId_args:
4005 
  """
4006 
  Attributes:
4007 
   - item_id
4008 
  """
4009 
 
4010 
  thrift_spec = (
4011 
    None, # 0
4012 
    (1, TType.I64, 'item_id', None, None, ), # 1
4013 
  )
4014 
 
4015 
  def __init__(self, item_id=None,):
4016 
    self.item_id = item_id
4017 
 
4018 
  def read(self, iprot):
4019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4021 
      return
4022 
    iprot.readStructBegin()
4023 
    while True:
4024 
      (fname, ftype, fid) = iprot.readFieldBegin()
4025 
      if ftype == TType.STOP:
4026 
        break
4027 
      if fid == 1:
4028 
        if ftype == TType.I64:
4029 
          self.item_id = iprot.readI64();
4030 
        else:
4031 
          iprot.skip(ftype)
4032 
      else:
4033 
        iprot.skip(ftype)
4034 
      iprot.readFieldEnd()
4035 
    iprot.readStructEnd()
4036 
 
4037 
  def write(self, oprot):
4038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4040 
      return
4041 
    oprot.writeStructBegin('getItemInventoryByItemId_args')
4042 
    if self.item_id is not None:
4043 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
4044 
      oprot.writeI64(self.item_id)
4045 
      oprot.writeFieldEnd()
4046 
    oprot.writeFieldStop()
4047 
    oprot.writeStructEnd()
4048 
 
4049 
  def validate(self):
4050 
    return
4051 
 
4052 
 
4053 
  def __repr__(self):
4054 
    L = ['%s=%r' % (key, value)
4055 
      for key, value in self.__dict__.iteritems()]
4056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4057 
 
4058 
  def __eq__(self, other):
4059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4060 
 
4061 
  def __ne__(self, other):
4062 
    return not (self == other)
4063 
 
4064 
class getItemInventoryByItemId_result:
4065 
  """
4066 
  Attributes:
4067 
   - success
4068 
   - cex
4069 
  """
4070 
 
4071 
  thrift_spec = (
4072 
    (0, TType.STRUCT, 'success', (ItemInventory, ItemInventory.thrift_spec), None, ), # 0
4073 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4074 
  )
4075 
 
4076 
  def __init__(self, success=None, cex=None,):
4077 
    self.success = success
4078 
    self.cex = cex
4079 
 
4080 
  def read(self, iprot):
4081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4083 
      return
4084 
    iprot.readStructBegin()
4085 
    while True:
4086 
      (fname, ftype, fid) = iprot.readFieldBegin()
4087 
      if ftype == TType.STOP:
4088 
        break
4089 
      if fid == 0:
4090 
        if ftype == TType.STRUCT:
4091 
          self.success = ItemInventory()
4092 
          self.success.read(iprot)
4093 
        else:
4094 
          iprot.skip(ftype)
4095 
      elif fid == 1:
4096 
        if ftype == TType.STRUCT:
4097 
          self.cex = InventoryServiceException()
4098 
          self.cex.read(iprot)
4099 
        else:
4100 
          iprot.skip(ftype)
4101 
      else:
4102 
        iprot.skip(ftype)
4103 
      iprot.readFieldEnd()
4104 
    iprot.readStructEnd()
4105 
 
4106 
  def write(self, oprot):
4107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4109 
      return
4110 
    oprot.writeStructBegin('getItemInventoryByItemId_result')
4111 
    if self.success is not None:
4112 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4113 
      self.success.write(oprot)
4114 
      oprot.writeFieldEnd()
4115 
    if self.cex is not None:
4116 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4117 
      self.cex.write(oprot)
4118 
      oprot.writeFieldEnd()
4119 
    oprot.writeFieldStop()
4120 
    oprot.writeStructEnd()
4121 
 
4122 
  def validate(self):
4123 
    return
4124 
 
4125 
 
4126 
  def __repr__(self):
4127 
    L = ['%s=%r' % (key, value)
4128 
      for key, value in self.__dict__.iteritems()]
4129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4130 
 
4131 
  def __eq__(self, other):
4132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4133 
 
4134 
  def __ne__(self, other):
4135 
    return not (self == other)
4136 
 
4137 
class getItemAvailibilityAtWarehouse_args:
4138 
  """
4139 
  Attributes:
4140 
   - warehouse_id
4141 
   - item_id
4142 
  """
4143 
 
4144 
  thrift_spec = (
4145 
    None, # 0
4146 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4147 
    (2, TType.I64, 'item_id', None, None, ), # 2
4148 
  )
4149 
 
4150 
  def __init__(self, warehouse_id=None, item_id=None,):
4151 
    self.warehouse_id = warehouse_id
4152 
    self.item_id = item_id
4153 
 
4154 
  def read(self, iprot):
4155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4157 
      return
4158 
    iprot.readStructBegin()
4159 
    while True:
4160 
      (fname, ftype, fid) = iprot.readFieldBegin()
4161 
      if ftype == TType.STOP:
4162 
        break
4163 
      if fid == 1:
4164 
        if ftype == TType.I64:
4165 
          self.warehouse_id = iprot.readI64();
4166 
        else:
4167 
          iprot.skip(ftype)
4168 
      elif fid == 2:
4169 
        if ftype == TType.I64:
4170 
          self.item_id = iprot.readI64();
4171 
        else:
4172 
          iprot.skip(ftype)
4173 
      else:
4174 
        iprot.skip(ftype)
4175 
      iprot.readFieldEnd()
4176 
    iprot.readStructEnd()
4177 
 
4178 
  def write(self, oprot):
4179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4181 
      return
4182 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_args')
4183 
    if self.warehouse_id is not None:
4184 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
4185 
      oprot.writeI64(self.warehouse_id)
4186 
      oprot.writeFieldEnd()
4187 
    if self.item_id is not None:
4188 
      oprot.writeFieldBegin('item_id', TType.I64, 2)
4189 
      oprot.writeI64(self.item_id)
4190 
      oprot.writeFieldEnd()
4191 
    oprot.writeFieldStop()
4192 
    oprot.writeStructEnd()
4193 
 
4194 
  def validate(self):
4195 
    return
4196 
 
4197 
 
4198 
  def __repr__(self):
4199 
    L = ['%s=%r' % (key, value)
4200 
      for key, value in self.__dict__.iteritems()]
4201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4202 
 
4203 
  def __eq__(self, other):
4204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4205 
 
4206 
  def __ne__(self, other):
4207 
    return not (self == other)
4208 
 
4209 
class getItemAvailibilityAtWarehouse_result:
4210 
  """
4211 
  Attributes:
4212 
   - success
4213 
   - cex
4214 
  """
4215 
 
4216 
  thrift_spec = (
4217 
    (0, TType.I64, 'success', None, None, ), # 0
4218 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4219 
  )
4220 
 
4221 
  def __init__(self, success=None, cex=None,):
4222 
    self.success = success
4223 
    self.cex = cex
4224 
 
4225 
  def read(self, iprot):
4226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4228 
      return
4229 
    iprot.readStructBegin()
4230 
    while True:
4231 
      (fname, ftype, fid) = iprot.readFieldBegin()
4232 
      if ftype == TType.STOP:
4233 
        break
4234 
      if fid == 0:
4235 
        if ftype == TType.I64:
4236 
          self.success = iprot.readI64();
4237 
        else:
4238 
          iprot.skip(ftype)
4239 
      elif fid == 1:
4240 
        if ftype == TType.STRUCT:
4241 
          self.cex = InventoryServiceException()
4242 
          self.cex.read(iprot)
4243 
        else:
4244 
          iprot.skip(ftype)
4245 
      else:
4246 
        iprot.skip(ftype)
4247 
      iprot.readFieldEnd()
4248 
    iprot.readStructEnd()
4249 
 
4250 
  def write(self, oprot):
4251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4253 
      return
4254 
    oprot.writeStructBegin('getItemAvailibilityAtWarehouse_result')
4255 
    if self.success is not None:
4256 
      oprot.writeFieldBegin('success', TType.I64, 0)
4257 
      oprot.writeI64(self.success)
4258 
      oprot.writeFieldEnd()
4259 
    if self.cex is not None:
4260 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4261 
      self.cex.write(oprot)
4262 
      oprot.writeFieldEnd()
4263 
    oprot.writeFieldStop()
4264 
    oprot.writeStructEnd()
4265 
 
4266 
  def validate(self):
4267 
    return
4268 
 
4269 
 
4270 
  def __repr__(self):
4271 
    L = ['%s=%r' % (key, value)
4272 
      for key, value in self.__dict__.iteritems()]
4273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4274 
 
4275 
  def __eq__(self, other):
4276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4277 
 
4278 
  def __ne__(self, other):
4279 
    return not (self == other)
4280 
 
4281 
class getItemAvailabilityAtLocation_args:
4282 
  """
4283 
  Attributes:
4284 
   - itemId
5978 rajveer 4285 
   - sourceId
5944 mandeep.dh 4286 
  """
4287 
 
4288 
  thrift_spec = (
4289 
    None, # 0
4290 
    (1, TType.I64, 'itemId', None, None, ), # 1
5978 rajveer 4291 
    (2, TType.I64, 'sourceId', None, None, ), # 2
5944 mandeep.dh 4292 
  )
4293 
 
5978 rajveer 4294 
  def __init__(self, itemId=None, sourceId=None,):
5944 mandeep.dh 4295 
    self.itemId = itemId
5978 rajveer 4296 
    self.sourceId = sourceId
5944 mandeep.dh 4297 
 
4298 
  def read(self, iprot):
4299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4301 
      return
4302 
    iprot.readStructBegin()
4303 
    while True:
4304 
      (fname, ftype, fid) = iprot.readFieldBegin()
4305 
      if ftype == TType.STOP:
4306 
        break
4307 
      if fid == 1:
4308 
        if ftype == TType.I64:
4309 
          self.itemId = iprot.readI64();
4310 
        else:
4311 
          iprot.skip(ftype)
5978 rajveer 4312 
      elif fid == 2:
4313 
        if ftype == TType.I64:
4314 
          self.sourceId = iprot.readI64();
4315 
        else:
4316 
          iprot.skip(ftype)
5944 mandeep.dh 4317 
      else:
4318 
        iprot.skip(ftype)
4319 
      iprot.readFieldEnd()
4320 
    iprot.readStructEnd()
4321 
 
4322 
  def write(self, oprot):
4323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4325 
      return
4326 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_args')
4327 
    if self.itemId is not None:
4328 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
4329 
      oprot.writeI64(self.itemId)
4330 
      oprot.writeFieldEnd()
5978 rajveer 4331 
    if self.sourceId is not None:
4332 
      oprot.writeFieldBegin('sourceId', TType.I64, 2)
4333 
      oprot.writeI64(self.sourceId)
4334 
      oprot.writeFieldEnd()
5944 mandeep.dh 4335 
    oprot.writeFieldStop()
4336 
    oprot.writeStructEnd()
4337 
 
4338 
  def validate(self):
4339 
    return
4340 
 
4341 
 
4342 
  def __repr__(self):
4343 
    L = ['%s=%r' % (key, value)
4344 
      for key, value in self.__dict__.iteritems()]
4345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4346 
 
4347 
  def __eq__(self, other):
4348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4349 
 
4350 
  def __ne__(self, other):
4351 
    return not (self == other)
4352 
 
4353 
class getItemAvailabilityAtLocation_result:
4354 
  """
4355 
  Attributes:
4356 
   - success
4357 
   - isex
4358 
  """
4359 
 
4360 
  thrift_spec = (
4361 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4362 
    (1, TType.STRUCT, 'isex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4363 
  )
4364 
 
4365 
  def __init__(self, success=None, isex=None,):
4366 
    self.success = success
4367 
    self.isex = isex
4368 
 
4369 
  def read(self, iprot):
4370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4372 
      return
4373 
    iprot.readStructBegin()
4374 
    while True:
4375 
      (fname, ftype, fid) = iprot.readFieldBegin()
4376 
      if ftype == TType.STOP:
4377 
        break
4378 
      if fid == 0:
4379 
        if ftype == TType.LIST:
4380 
          self.success = []
8182 amar.kumar 4381 
          (_etype48, _size45) = iprot.readListBegin()
4382 
          for _i49 in xrange(_size45):
4383 
            _elem50 = iprot.readI64();
4384 
            self.success.append(_elem50)
5944 mandeep.dh 4385 
          iprot.readListEnd()
4386 
        else:
4387 
          iprot.skip(ftype)
4388 
      elif fid == 1:
4389 
        if ftype == TType.STRUCT:
4390 
          self.isex = InventoryServiceException()
4391 
          self.isex.read(iprot)
4392 
        else:
4393 
          iprot.skip(ftype)
4394 
      else:
4395 
        iprot.skip(ftype)
4396 
      iprot.readFieldEnd()
4397 
    iprot.readStructEnd()
4398 
 
4399 
  def write(self, oprot):
4400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4402 
      return
4403 
    oprot.writeStructBegin('getItemAvailabilityAtLocation_result')
4404 
    if self.success is not None:
4405 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4406 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 4407 
      for iter51 in self.success:
4408 
        oprot.writeI64(iter51)
5944 mandeep.dh 4409 
      oprot.writeListEnd()
4410 
      oprot.writeFieldEnd()
4411 
    if self.isex is not None:
4412 
      oprot.writeFieldBegin('isex', TType.STRUCT, 1)
4413 
      self.isex.write(oprot)
4414 
      oprot.writeFieldEnd()
4415 
    oprot.writeFieldStop()
4416 
    oprot.writeStructEnd()
4417 
 
4418 
  def validate(self):
4419 
    return
4420 
 
4421 
 
4422 
  def __repr__(self):
4423 
    L = ['%s=%r' % (key, value)
4424 
      for key, value in self.__dict__.iteritems()]
4425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4426 
 
4427 
  def __eq__(self, other):
4428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4429 
 
4430 
  def __ne__(self, other):
4431 
    return not (self == other)
4432 
 
4433 
class getAllWarehouses_args:
4434 
  """
4435 
  Attributes:
4436 
   - isActive
4437 
  """
4438 
 
4439 
  thrift_spec = (
4440 
    None, # 0
4441 
    (1, TType.BOOL, 'isActive', None, None, ), # 1
4442 
  )
4443 
 
4444 
  def __init__(self, isActive=None,):
4445 
    self.isActive = isActive
4446 
 
4447 
  def read(self, iprot):
4448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4450 
      return
4451 
    iprot.readStructBegin()
4452 
    while True:
4453 
      (fname, ftype, fid) = iprot.readFieldBegin()
4454 
      if ftype == TType.STOP:
4455 
        break
4456 
      if fid == 1:
4457 
        if ftype == TType.BOOL:
4458 
          self.isActive = iprot.readBool();
4459 
        else:
4460 
          iprot.skip(ftype)
4461 
      else:
4462 
        iprot.skip(ftype)
4463 
      iprot.readFieldEnd()
4464 
    iprot.readStructEnd()
4465 
 
4466 
  def write(self, oprot):
4467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4469 
      return
4470 
    oprot.writeStructBegin('getAllWarehouses_args')
4471 
    if self.isActive is not None:
4472 
      oprot.writeFieldBegin('isActive', TType.BOOL, 1)
4473 
      oprot.writeBool(self.isActive)
4474 
      oprot.writeFieldEnd()
4475 
    oprot.writeFieldStop()
4476 
    oprot.writeStructEnd()
4477 
 
4478 
  def validate(self):
4479 
    return
4480 
 
4481 
 
4482 
  def __repr__(self):
4483 
    L = ['%s=%r' % (key, value)
4484 
      for key, value in self.__dict__.iteritems()]
4485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4486 
 
4487 
  def __eq__(self, other):
4488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4489 
 
4490 
  def __ne__(self, other):
4491 
    return not (self == other)
4492 
 
4493 
class getAllWarehouses_result:
4494 
  """
4495 
  Attributes:
4496 
   - success
4497 
   - cex
4498 
  """
4499 
 
4500 
  thrift_spec = (
4501 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
4502 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4503 
  )
4504 
 
4505 
  def __init__(self, success=None, cex=None,):
4506 
    self.success = success
4507 
    self.cex = cex
4508 
 
4509 
  def read(self, iprot):
4510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4512 
      return
4513 
    iprot.readStructBegin()
4514 
    while True:
4515 
      (fname, ftype, fid) = iprot.readFieldBegin()
4516 
      if ftype == TType.STOP:
4517 
        break
4518 
      if fid == 0:
4519 
        if ftype == TType.LIST:
4520 
          self.success = []
8182 amar.kumar 4521 
          (_etype55, _size52) = iprot.readListBegin()
4522 
          for _i56 in xrange(_size52):
4523 
            _elem57 = Warehouse()
4524 
            _elem57.read(iprot)
4525 
            self.success.append(_elem57)
5944 mandeep.dh 4526 
          iprot.readListEnd()
4527 
        else:
4528 
          iprot.skip(ftype)
4529 
      elif fid == 1:
4530 
        if ftype == TType.STRUCT:
4531 
          self.cex = InventoryServiceException()
4532 
          self.cex.read(iprot)
4533 
        else:
4534 
          iprot.skip(ftype)
4535 
      else:
4536 
        iprot.skip(ftype)
4537 
      iprot.readFieldEnd()
4538 
    iprot.readStructEnd()
4539 
 
4540 
  def write(self, oprot):
4541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4543 
      return
4544 
    oprot.writeStructBegin('getAllWarehouses_result')
4545 
    if self.success is not None:
4546 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4547 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 4548 
      for iter58 in self.success:
4549 
        iter58.write(oprot)
5944 mandeep.dh 4550 
      oprot.writeListEnd()
4551 
      oprot.writeFieldEnd()
4552 
    if self.cex is not None:
4553 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4554 
      self.cex.write(oprot)
4555 
      oprot.writeFieldEnd()
4556 
    oprot.writeFieldStop()
4557 
    oprot.writeStructEnd()
4558 
 
4559 
  def validate(self):
4560 
    return
4561 
 
4562 
 
4563 
  def __repr__(self):
4564 
    L = ['%s=%r' % (key, value)
4565 
      for key, value in self.__dict__.iteritems()]
4566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4567 
 
4568 
  def __eq__(self, other):
4569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4570 
 
4571 
  def __ne__(self, other):
4572 
    return not (self == other)
4573 
 
4574 
class getWarehouse_args:
4575 
  """
4576 
  Attributes:
4577 
   - warehouse_id
4578 
  """
4579 
 
4580 
  thrift_spec = (
4581 
    None, # 0
4582 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4583 
  )
4584 
 
4585 
  def __init__(self, warehouse_id=None,):
4586 
    self.warehouse_id = warehouse_id
4587 
 
4588 
  def read(self, iprot):
4589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4591 
      return
4592 
    iprot.readStructBegin()
4593 
    while True:
4594 
      (fname, ftype, fid) = iprot.readFieldBegin()
4595 
      if ftype == TType.STOP:
4596 
        break
4597 
      if fid == 1:
4598 
        if ftype == TType.I64:
4599 
          self.warehouse_id = iprot.readI64();
4600 
        else:
4601 
          iprot.skip(ftype)
4602 
      else:
4603 
        iprot.skip(ftype)
4604 
      iprot.readFieldEnd()
4605 
    iprot.readStructEnd()
4606 
 
4607 
  def write(self, oprot):
4608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4610 
      return
4611 
    oprot.writeStructBegin('getWarehouse_args')
4612 
    if self.warehouse_id is not None:
4613 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
4614 
      oprot.writeI64(self.warehouse_id)
4615 
      oprot.writeFieldEnd()
4616 
    oprot.writeFieldStop()
4617 
    oprot.writeStructEnd()
4618 
 
4619 
  def validate(self):
4620 
    return
4621 
 
4622 
 
4623 
  def __repr__(self):
4624 
    L = ['%s=%r' % (key, value)
4625 
      for key, value in self.__dict__.iteritems()]
4626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4627 
 
4628 
  def __eq__(self, other):
4629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4630 
 
4631 
  def __ne__(self, other):
4632 
    return not (self == other)
4633 
 
4634 
class getWarehouse_result:
4635 
  """
4636 
  Attributes:
4637 
   - success
4638 
   - cex
4639 
  """
4640 
 
4641 
  thrift_spec = (
4642 
    (0, TType.STRUCT, 'success', (Warehouse, Warehouse.thrift_spec), None, ), # 0
4643 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4644 
  )
4645 
 
4646 
  def __init__(self, success=None, cex=None,):
4647 
    self.success = success
4648 
    self.cex = cex
4649 
 
4650 
  def read(self, iprot):
4651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4653 
      return
4654 
    iprot.readStructBegin()
4655 
    while True:
4656 
      (fname, ftype, fid) = iprot.readFieldBegin()
4657 
      if ftype == TType.STOP:
4658 
        break
4659 
      if fid == 0:
4660 
        if ftype == TType.STRUCT:
4661 
          self.success = Warehouse()
4662 
          self.success.read(iprot)
4663 
        else:
4664 
          iprot.skip(ftype)
4665 
      elif fid == 1:
4666 
        if ftype == TType.STRUCT:
4667 
          self.cex = InventoryServiceException()
4668 
          self.cex.read(iprot)
4669 
        else:
4670 
          iprot.skip(ftype)
4671 
      else:
4672 
        iprot.skip(ftype)
4673 
      iprot.readFieldEnd()
4674 
    iprot.readStructEnd()
4675 
 
4676 
  def write(self, oprot):
4677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4679 
      return
4680 
    oprot.writeStructBegin('getWarehouse_result')
4681 
    if self.success is not None:
4682 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4683 
      self.success.write(oprot)
4684 
      oprot.writeFieldEnd()
4685 
    if self.cex is not None:
4686 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4687 
      self.cex.write(oprot)
4688 
      oprot.writeFieldEnd()
4689 
    oprot.writeFieldStop()
4690 
    oprot.writeStructEnd()
4691 
 
4692 
  def validate(self):
4693 
    return
4694 
 
4695 
 
4696 
  def __repr__(self):
4697 
    L = ['%s=%r' % (key, value)
4698 
      for key, value in self.__dict__.iteritems()]
4699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4700 
 
4701 
  def __eq__(self, other):
4702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4703 
 
4704 
  def __ne__(self, other):
4705 
    return not (self == other)
4706 
 
4707 
class getAllItemsForWarehouse_args:
4708 
  """
4709 
  Attributes:
4710 
   - warehouse_id
4711 
  """
4712 
 
4713 
  thrift_spec = (
4714 
    None, # 0
4715 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
4716 
  )
4717 
 
4718 
  def __init__(self, warehouse_id=None,):
4719 
    self.warehouse_id = warehouse_id
4720 
 
4721 
  def read(self, iprot):
4722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4724 
      return
4725 
    iprot.readStructBegin()
4726 
    while True:
4727 
      (fname, ftype, fid) = iprot.readFieldBegin()
4728 
      if ftype == TType.STOP:
4729 
        break
4730 
      if fid == 1:
4731 
        if ftype == TType.I64:
4732 
          self.warehouse_id = iprot.readI64();
4733 
        else:
4734 
          iprot.skip(ftype)
4735 
      else:
4736 
        iprot.skip(ftype)
4737 
      iprot.readFieldEnd()
4738 
    iprot.readStructEnd()
4739 
 
4740 
  def write(self, oprot):
4741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4743 
      return
4744 
    oprot.writeStructBegin('getAllItemsForWarehouse_args')
4745 
    if self.warehouse_id is not None:
4746 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
4747 
      oprot.writeI64(self.warehouse_id)
4748 
      oprot.writeFieldEnd()
4749 
    oprot.writeFieldStop()
4750 
    oprot.writeStructEnd()
4751 
 
4752 
  def validate(self):
4753 
    return
4754 
 
4755 
 
4756 
  def __repr__(self):
4757 
    L = ['%s=%r' % (key, value)
4758 
      for key, value in self.__dict__.iteritems()]
4759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4760 
 
4761 
  def __eq__(self, other):
4762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4763 
 
4764 
  def __ne__(self, other):
4765 
    return not (self == other)
4766 
 
4767 
class getAllItemsForWarehouse_result:
4768 
  """
4769 
  Attributes:
4770 
   - success
4771 
   - cex
4772 
  """
4773 
 
4774 
  thrift_spec = (
4775 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4776 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
4777 
  )
4778 
 
4779 
  def __init__(self, success=None, cex=None,):
4780 
    self.success = success
4781 
    self.cex = cex
4782 
 
4783 
  def read(self, iprot):
4784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4786 
      return
4787 
    iprot.readStructBegin()
4788 
    while True:
4789 
      (fname, ftype, fid) = iprot.readFieldBegin()
4790 
      if ftype == TType.STOP:
4791 
        break
4792 
      if fid == 0:
4793 
        if ftype == TType.LIST:
4794 
          self.success = []
8182 amar.kumar 4795 
          (_etype62, _size59) = iprot.readListBegin()
4796 
          for _i63 in xrange(_size59):
4797 
            _elem64 = iprot.readI64();
4798 
            self.success.append(_elem64)
5944 mandeep.dh 4799 
          iprot.readListEnd()
4800 
        else:
4801 
          iprot.skip(ftype)
4802 
      elif fid == 1:
4803 
        if ftype == TType.STRUCT:
4804 
          self.cex = InventoryServiceException()
4805 
          self.cex.read(iprot)
4806 
        else:
4807 
          iprot.skip(ftype)
4808 
      else:
4809 
        iprot.skip(ftype)
4810 
      iprot.readFieldEnd()
4811 
    iprot.readStructEnd()
4812 
 
4813 
  def write(self, oprot):
4814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4816 
      return
4817 
    oprot.writeStructBegin('getAllItemsForWarehouse_result')
4818 
    if self.success is not None:
4819 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4820 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 4821 
      for iter65 in self.success:
4822 
        oprot.writeI64(iter65)
5944 mandeep.dh 4823 
      oprot.writeListEnd()
4824 
      oprot.writeFieldEnd()
4825 
    if self.cex is not None:
4826 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
4827 
      self.cex.write(oprot)
4828 
      oprot.writeFieldEnd()
4829 
    oprot.writeFieldStop()
4830 
    oprot.writeStructEnd()
4831 
 
4832 
  def validate(self):
4833 
    return
4834 
 
4835 
 
4836 
  def __repr__(self):
4837 
    L = ['%s=%r' % (key, value)
4838 
      for key, value in self.__dict__.iteritems()]
4839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4840 
 
4841 
  def __eq__(self, other):
4842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4843 
 
4844 
  def __ne__(self, other):
4845 
    return not (self == other)
4846 
 
5966 rajveer 4847 
class isOrderBillable_args:
4848 
  """
4849 
  Attributes:
4850 
   - itemId
4851 
   - warehouseId
4852 
   - sourceId
4853 
   - orderId
4854 
  """
4855 
 
4856 
  thrift_spec = (
4857 
    None, # 0
4858 
    (1, TType.I64, 'itemId', None, None, ), # 1
4859 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
4860 
    (3, TType.I64, 'sourceId', None, None, ), # 3
4861 
    (4, TType.I64, 'orderId', None, None, ), # 4
4862 
  )
4863 
 
4864 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None,):
4865 
    self.itemId = itemId
4866 
    self.warehouseId = warehouseId
4867 
    self.sourceId = sourceId
4868 
    self.orderId = orderId
4869 
 
4870 
  def read(self, iprot):
4871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4873 
      return
4874 
    iprot.readStructBegin()
4875 
    while True:
4876 
      (fname, ftype, fid) = iprot.readFieldBegin()
4877 
      if ftype == TType.STOP:
4878 
        break
4879 
      if fid == 1:
4880 
        if ftype == TType.I64:
4881 
          self.itemId = iprot.readI64();
4882 
        else:
4883 
          iprot.skip(ftype)
4884 
      elif fid == 2:
4885 
        if ftype == TType.I64:
4886 
          self.warehouseId = iprot.readI64();
4887 
        else:
4888 
          iprot.skip(ftype)
4889 
      elif fid == 3:
4890 
        if ftype == TType.I64:
4891 
          self.sourceId = iprot.readI64();
4892 
        else:
4893 
          iprot.skip(ftype)
4894 
      elif fid == 4:
4895 
        if ftype == TType.I64:
4896 
          self.orderId = iprot.readI64();
4897 
        else:
4898 
          iprot.skip(ftype)
4899 
      else:
4900 
        iprot.skip(ftype)
4901 
      iprot.readFieldEnd()
4902 
    iprot.readStructEnd()
4903 
 
4904 
  def write(self, oprot):
4905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4907 
      return
4908 
    oprot.writeStructBegin('isOrderBillable_args')
4909 
    if self.itemId is not None:
4910 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
4911 
      oprot.writeI64(self.itemId)
4912 
      oprot.writeFieldEnd()
4913 
    if self.warehouseId is not None:
4914 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
4915 
      oprot.writeI64(self.warehouseId)
4916 
      oprot.writeFieldEnd()
4917 
    if self.sourceId is not None:
4918 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
4919 
      oprot.writeI64(self.sourceId)
4920 
      oprot.writeFieldEnd()
4921 
    if self.orderId is not None:
4922 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
4923 
      oprot.writeI64(self.orderId)
4924 
      oprot.writeFieldEnd()
4925 
    oprot.writeFieldStop()
4926 
    oprot.writeStructEnd()
4927 
 
4928 
  def validate(self):
4929 
    return
4930 
 
4931 
 
4932 
  def __repr__(self):
4933 
    L = ['%s=%r' % (key, value)
4934 
      for key, value in self.__dict__.iteritems()]
4935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4936 
 
4937 
  def __eq__(self, other):
4938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4939 
 
4940 
  def __ne__(self, other):
4941 
    return not (self == other)
4942 
 
4943 
class isOrderBillable_result:
4944 
  """
4945 
  Attributes:
4946 
   - success
4947 
  """
4948 
 
4949 
  thrift_spec = (
4950 
    (0, TType.BOOL, 'success', None, None, ), # 0
4951 
  )
4952 
 
4953 
  def __init__(self, success=None,):
4954 
    self.success = success
4955 
 
4956 
  def read(self, iprot):
4957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4959 
      return
4960 
    iprot.readStructBegin()
4961 
    while True:
4962 
      (fname, ftype, fid) = iprot.readFieldBegin()
4963 
      if ftype == TType.STOP:
4964 
        break
4965 
      if fid == 0:
4966 
        if ftype == TType.BOOL:
4967 
          self.success = iprot.readBool();
4968 
        else:
4969 
          iprot.skip(ftype)
4970 
      else:
4971 
        iprot.skip(ftype)
4972 
      iprot.readFieldEnd()
4973 
    iprot.readStructEnd()
4974 
 
4975 
  def write(self, oprot):
4976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4978 
      return
4979 
    oprot.writeStructBegin('isOrderBillable_result')
4980 
    if self.success is not None:
4981 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4982 
      oprot.writeBool(self.success)
4983 
      oprot.writeFieldEnd()
4984 
    oprot.writeFieldStop()
4985 
    oprot.writeStructEnd()
4986 
 
4987 
  def validate(self):
4988 
    return
4989 
 
4990 
 
4991 
  def __repr__(self):
4992 
    L = ['%s=%r' % (key, value)
4993 
      for key, value in self.__dict__.iteritems()]
4994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4995 
 
4996 
  def __eq__(self, other):
4997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4998 
 
4999 
  def __ne__(self, other):
5000 
    return not (self == other)
5001 
 
5944 mandeep.dh 5002 
class reserveItemInWarehouse_args:
5003 
  """
5004 
  Attributes:
5005 
   - itemId
5006 
   - warehouseId
5966 rajveer 5007 
   - sourceId
5008 
   - orderId
5009 
   - createdTimestamp
5010 
   - promisedShippingTimestamp
5944 mandeep.dh 5011 
   - quantity
5012 
  """
5013 
 
5014 
  thrift_spec = (
5015 
    None, # 0
5016 
    (1, TType.I64, 'itemId', None, None, ), # 1
5017 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 5018 
    (3, TType.I64, 'sourceId', None, None, ), # 3
5019 
    (4, TType.I64, 'orderId', None, None, ), # 4
5020 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
5021 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
5022 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
5944 mandeep.dh 5023 
  )
5024 
 
5966 rajveer 5025 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
5944 mandeep.dh 5026 
    self.itemId = itemId
5027 
    self.warehouseId = warehouseId
5966 rajveer 5028 
    self.sourceId = sourceId
5029 
    self.orderId = orderId
5030 
    self.createdTimestamp = createdTimestamp
5031 
    self.promisedShippingTimestamp = promisedShippingTimestamp
5944 mandeep.dh 5032 
    self.quantity = quantity
5033 
 
5034 
  def read(self, iprot):
5035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5037 
      return
5038 
    iprot.readStructBegin()
5039 
    while True:
5040 
      (fname, ftype, fid) = iprot.readFieldBegin()
5041 
      if ftype == TType.STOP:
5042 
        break
5043 
      if fid == 1:
5044 
        if ftype == TType.I64:
5045 
          self.itemId = iprot.readI64();
5046 
        else:
5047 
          iprot.skip(ftype)
5048 
      elif fid == 2:
5049 
        if ftype == TType.I64:
5050 
          self.warehouseId = iprot.readI64();
5051 
        else:
5052 
          iprot.skip(ftype)
5053 
      elif fid == 3:
5966 rajveer 5054 
        if ftype == TType.I64:
5055 
          self.sourceId = iprot.readI64();
5056 
        else:
5057 
          iprot.skip(ftype)
5058 
      elif fid == 4:
5059 
        if ftype == TType.I64:
5060 
          self.orderId = iprot.readI64();
5061 
        else:
5062 
          iprot.skip(ftype)
5063 
      elif fid == 5:
5064 
        if ftype == TType.I64:
5065 
          self.createdTimestamp = iprot.readI64();
5066 
        else:
5067 
          iprot.skip(ftype)
5068 
      elif fid == 6:
5069 
        if ftype == TType.I64:
5070 
          self.promisedShippingTimestamp = iprot.readI64();
5071 
        else:
5072 
          iprot.skip(ftype)
5073 
      elif fid == 7:
5944 mandeep.dh 5074 
        if ftype == TType.DOUBLE:
5075 
          self.quantity = iprot.readDouble();
5076 
        else:
5077 
          iprot.skip(ftype)
5078 
      else:
5079 
        iprot.skip(ftype)
5080 
      iprot.readFieldEnd()
5081 
    iprot.readStructEnd()
5082 
 
5083 
  def write(self, oprot):
5084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5086 
      return
5087 
    oprot.writeStructBegin('reserveItemInWarehouse_args')
5088 
    if self.itemId is not None:
5089 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5090 
      oprot.writeI64(self.itemId)
5091 
      oprot.writeFieldEnd()
5092 
    if self.warehouseId is not None:
5093 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5094 
      oprot.writeI64(self.warehouseId)
5095 
      oprot.writeFieldEnd()
5966 rajveer 5096 
    if self.sourceId is not None:
5097 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
5098 
      oprot.writeI64(self.sourceId)
5099 
      oprot.writeFieldEnd()
5100 
    if self.orderId is not None:
5101 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
5102 
      oprot.writeI64(self.orderId)
5103 
      oprot.writeFieldEnd()
5104 
    if self.createdTimestamp is not None:
5105 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
5106 
      oprot.writeI64(self.createdTimestamp)
5107 
      oprot.writeFieldEnd()
5108 
    if self.promisedShippingTimestamp is not None:
5109 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
5110 
      oprot.writeI64(self.promisedShippingTimestamp)
5111 
      oprot.writeFieldEnd()
5944 mandeep.dh 5112 
    if self.quantity is not None:
5966 rajveer 5113 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
5944 mandeep.dh 5114 
      oprot.writeDouble(self.quantity)
5115 
      oprot.writeFieldEnd()
5116 
    oprot.writeFieldStop()
5117 
    oprot.writeStructEnd()
5118 
 
5119 
  def validate(self):
5120 
    return
5121 
 
5122 
 
5123 
  def __repr__(self):
5124 
    L = ['%s=%r' % (key, value)
5125 
      for key, value in self.__dict__.iteritems()]
5126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5127 
 
5128 
  def __eq__(self, other):
5129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5130 
 
5131 
  def __ne__(self, other):
5132 
    return not (self == other)
5133 
 
5134 
class reserveItemInWarehouse_result:
5135 
  """
5136 
  Attributes:
5137 
   - success
5138 
   - cex
5139 
  """
5140 
 
5141 
  thrift_spec = (
5142 
    (0, TType.BOOL, 'success', None, None, ), # 0
5143 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5144 
  )
5145 
 
5146 
  def __init__(self, success=None, cex=None,):
5147 
    self.success = success
5148 
    self.cex = cex
5149 
 
5150 
  def read(self, iprot):
5151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5153 
      return
5154 
    iprot.readStructBegin()
5155 
    while True:
5156 
      (fname, ftype, fid) = iprot.readFieldBegin()
5157 
      if ftype == TType.STOP:
5158 
        break
5159 
      if fid == 0:
5160 
        if ftype == TType.BOOL:
5161 
          self.success = iprot.readBool();
5162 
        else:
5163 
          iprot.skip(ftype)
5164 
      elif fid == 1:
5165 
        if ftype == TType.STRUCT:
5166 
          self.cex = InventoryServiceException()
5167 
          self.cex.read(iprot)
5168 
        else:
5169 
          iprot.skip(ftype)
5170 
      else:
5171 
        iprot.skip(ftype)
5172 
      iprot.readFieldEnd()
5173 
    iprot.readStructEnd()
5174 
 
5175 
  def write(self, oprot):
5176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5178 
      return
5179 
    oprot.writeStructBegin('reserveItemInWarehouse_result')
5180 
    if self.success is not None:
5181 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5182 
      oprot.writeBool(self.success)
5183 
      oprot.writeFieldEnd()
5184 
    if self.cex is not None:
5185 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5186 
      self.cex.write(oprot)
5187 
      oprot.writeFieldEnd()
5188 
    oprot.writeFieldStop()
5189 
    oprot.writeStructEnd()
5190 
 
5191 
  def validate(self):
5192 
    return
5193 
 
5194 
 
5195 
  def __repr__(self):
5196 
    L = ['%s=%r' % (key, value)
5197 
      for key, value in self.__dict__.iteritems()]
5198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5199 
 
5200 
  def __eq__(self, other):
5201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5202 
 
5203 
  def __ne__(self, other):
5204 
    return not (self == other)
5205 
 
7968 amar.kumar 5206 
class updateReservationForOrder_args:
5207 
  """
5208 
  Attributes:
5209 
   - itemId
5210 
   - warehouseId
5211 
   - sourceId
5212 
   - orderId
5213 
   - createdTimestamp
5214 
   - promisedShippingTimestamp
5215 
   - quantity
5216 
  """
5217 
 
5218 
  thrift_spec = (
5219 
    None, # 0
5220 
    (1, TType.I64, 'itemId', None, None, ), # 1
5221 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5222 
    (3, TType.I64, 'sourceId', None, None, ), # 3
5223 
    (4, TType.I64, 'orderId', None, None, ), # 4
5224 
    (5, TType.I64, 'createdTimestamp', None, None, ), # 5
5225 
    (6, TType.I64, 'promisedShippingTimestamp', None, None, ), # 6
5226 
    (7, TType.DOUBLE, 'quantity', None, None, ), # 7
5227 
  )
5228 
 
5229 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, createdTimestamp=None, promisedShippingTimestamp=None, quantity=None,):
5230 
    self.itemId = itemId
5231 
    self.warehouseId = warehouseId
5232 
    self.sourceId = sourceId
5233 
    self.orderId = orderId
5234 
    self.createdTimestamp = createdTimestamp
5235 
    self.promisedShippingTimestamp = promisedShippingTimestamp
5236 
    self.quantity = quantity
5237 
 
5238 
  def read(self, iprot):
5239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5241 
      return
5242 
    iprot.readStructBegin()
5243 
    while True:
5244 
      (fname, ftype, fid) = iprot.readFieldBegin()
5245 
      if ftype == TType.STOP:
5246 
        break
5247 
      if fid == 1:
5248 
        if ftype == TType.I64:
5249 
          self.itemId = iprot.readI64();
5250 
        else:
5251 
          iprot.skip(ftype)
5252 
      elif fid == 2:
5253 
        if ftype == TType.I64:
5254 
          self.warehouseId = iprot.readI64();
5255 
        else:
5256 
          iprot.skip(ftype)
5257 
      elif fid == 3:
5258 
        if ftype == TType.I64:
5259 
          self.sourceId = iprot.readI64();
5260 
        else:
5261 
          iprot.skip(ftype)
5262 
      elif fid == 4:
5263 
        if ftype == TType.I64:
5264 
          self.orderId = iprot.readI64();
5265 
        else:
5266 
          iprot.skip(ftype)
5267 
      elif fid == 5:
5268 
        if ftype == TType.I64:
5269 
          self.createdTimestamp = iprot.readI64();
5270 
        else:
5271 
          iprot.skip(ftype)
5272 
      elif fid == 6:
5273 
        if ftype == TType.I64:
5274 
          self.promisedShippingTimestamp = iprot.readI64();
5275 
        else:
5276 
          iprot.skip(ftype)
5277 
      elif fid == 7:
5278 
        if ftype == TType.DOUBLE:
5279 
          self.quantity = iprot.readDouble();
5280 
        else:
5281 
          iprot.skip(ftype)
5282 
      else:
5283 
        iprot.skip(ftype)
5284 
      iprot.readFieldEnd()
5285 
    iprot.readStructEnd()
5286 
 
5287 
  def write(self, oprot):
5288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5290 
      return
5291 
    oprot.writeStructBegin('updateReservationForOrder_args')
5292 
    if self.itemId is not None:
5293 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5294 
      oprot.writeI64(self.itemId)
5295 
      oprot.writeFieldEnd()
5296 
    if self.warehouseId is not None:
5297 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5298 
      oprot.writeI64(self.warehouseId)
5299 
      oprot.writeFieldEnd()
5300 
    if self.sourceId is not None:
5301 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
5302 
      oprot.writeI64(self.sourceId)
5303 
      oprot.writeFieldEnd()
5304 
    if self.orderId is not None:
5305 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
5306 
      oprot.writeI64(self.orderId)
5307 
      oprot.writeFieldEnd()
5308 
    if self.createdTimestamp is not None:
5309 
      oprot.writeFieldBegin('createdTimestamp', TType.I64, 5)
5310 
      oprot.writeI64(self.createdTimestamp)
5311 
      oprot.writeFieldEnd()
5312 
    if self.promisedShippingTimestamp is not None:
5313 
      oprot.writeFieldBegin('promisedShippingTimestamp', TType.I64, 6)
5314 
      oprot.writeI64(self.promisedShippingTimestamp)
5315 
      oprot.writeFieldEnd()
5316 
    if self.quantity is not None:
5317 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 7)
5318 
      oprot.writeDouble(self.quantity)
5319 
      oprot.writeFieldEnd()
5320 
    oprot.writeFieldStop()
5321 
    oprot.writeStructEnd()
5322 
 
5323 
  def validate(self):
5324 
    return
5325 
 
5326 
 
5327 
  def __repr__(self):
5328 
    L = ['%s=%r' % (key, value)
5329 
      for key, value in self.__dict__.iteritems()]
5330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5331 
 
5332 
  def __eq__(self, other):
5333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5334 
 
5335 
  def __ne__(self, other):
5336 
    return not (self == other)
5337 
 
5338 
class updateReservationForOrder_result:
5339 
  """
5340 
  Attributes:
5341 
   - success
5342 
   - cex
5343 
  """
5344 
 
5345 
  thrift_spec = (
5346 
    (0, TType.BOOL, 'success', None, None, ), # 0
5347 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5348 
  )
5349 
 
5350 
  def __init__(self, success=None, cex=None,):
5351 
    self.success = success
5352 
    self.cex = cex
5353 
 
5354 
  def read(self, iprot):
5355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5357 
      return
5358 
    iprot.readStructBegin()
5359 
    while True:
5360 
      (fname, ftype, fid) = iprot.readFieldBegin()
5361 
      if ftype == TType.STOP:
5362 
        break
5363 
      if fid == 0:
5364 
        if ftype == TType.BOOL:
5365 
          self.success = iprot.readBool();
5366 
        else:
5367 
          iprot.skip(ftype)
5368 
      elif fid == 1:
5369 
        if ftype == TType.STRUCT:
5370 
          self.cex = InventoryServiceException()
5371 
          self.cex.read(iprot)
5372 
        else:
5373 
          iprot.skip(ftype)
5374 
      else:
5375 
        iprot.skip(ftype)
5376 
      iprot.readFieldEnd()
5377 
    iprot.readStructEnd()
5378 
 
5379 
  def write(self, oprot):
5380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5382 
      return
5383 
    oprot.writeStructBegin('updateReservationForOrder_result')
5384 
    if self.success is not None:
5385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5386 
      oprot.writeBool(self.success)
5387 
      oprot.writeFieldEnd()
5388 
    if self.cex is not None:
5389 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5390 
      self.cex.write(oprot)
5391 
      oprot.writeFieldEnd()
5392 
    oprot.writeFieldStop()
5393 
    oprot.writeStructEnd()
5394 
 
5395 
  def validate(self):
5396 
    return
5397 
 
5398 
 
5399 
  def __repr__(self):
5400 
    L = ['%s=%r' % (key, value)
5401 
      for key, value in self.__dict__.iteritems()]
5402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5403 
 
5404 
  def __eq__(self, other):
5405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5406 
 
5407 
  def __ne__(self, other):
5408 
    return not (self == other)
5409 
 
5944 mandeep.dh 5410 
class reduceReservationCount_args:
5411 
  """
5412 
  Attributes:
5413 
   - itemId
5414 
   - warehouseId
5966 rajveer 5415 
   - sourceId
5416 
   - orderId
5944 mandeep.dh 5417 
   - quantity
5418 
  """
5419 
 
5420 
  thrift_spec = (
5421 
    None, # 0
5422 
    (1, TType.I64, 'itemId', None, None, ), # 1
5423 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
5966 rajveer 5424 
    (3, TType.I64, 'sourceId', None, None, ), # 3
5425 
    (4, TType.I64, 'orderId', None, None, ), # 4
5426 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
5944 mandeep.dh 5427 
  )
5428 
 
5966 rajveer 5429 
  def __init__(self, itemId=None, warehouseId=None, sourceId=None, orderId=None, quantity=None,):
5944 mandeep.dh 5430 
    self.itemId = itemId
5431 
    self.warehouseId = warehouseId
5966 rajveer 5432 
    self.sourceId = sourceId
5433 
    self.orderId = orderId
5944 mandeep.dh 5434 
    self.quantity = quantity
5435 
 
5436 
  def read(self, iprot):
5437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5439 
      return
5440 
    iprot.readStructBegin()
5441 
    while True:
5442 
      (fname, ftype, fid) = iprot.readFieldBegin()
5443 
      if ftype == TType.STOP:
5444 
        break
5445 
      if fid == 1:
5446 
        if ftype == TType.I64:
5447 
          self.itemId = iprot.readI64();
5448 
        else:
5449 
          iprot.skip(ftype)
5450 
      elif fid == 2:
5451 
        if ftype == TType.I64:
5452 
          self.warehouseId = iprot.readI64();
5453 
        else:
5454 
          iprot.skip(ftype)
5455 
      elif fid == 3:
5966 rajveer 5456 
        if ftype == TType.I64:
5457 
          self.sourceId = iprot.readI64();
5458 
        else:
5459 
          iprot.skip(ftype)
5460 
      elif fid == 4:
5461 
        if ftype == TType.I64:
5462 
          self.orderId = iprot.readI64();
5463 
        else:
5464 
          iprot.skip(ftype)
5465 
      elif fid == 5:
5944 mandeep.dh 5466 
        if ftype == TType.DOUBLE:
5467 
          self.quantity = iprot.readDouble();
5468 
        else:
5469 
          iprot.skip(ftype)
5470 
      else:
5471 
        iprot.skip(ftype)
5472 
      iprot.readFieldEnd()
5473 
    iprot.readStructEnd()
5474 
 
5475 
  def write(self, oprot):
5476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5478 
      return
5479 
    oprot.writeStructBegin('reduceReservationCount_args')
5480 
    if self.itemId is not None:
5481 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5482 
      oprot.writeI64(self.itemId)
5483 
      oprot.writeFieldEnd()
5484 
    if self.warehouseId is not None:
5485 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
5486 
      oprot.writeI64(self.warehouseId)
5487 
      oprot.writeFieldEnd()
5966 rajveer 5488 
    if self.sourceId is not None:
5489 
      oprot.writeFieldBegin('sourceId', TType.I64, 3)
5490 
      oprot.writeI64(self.sourceId)
5491 
      oprot.writeFieldEnd()
5492 
    if self.orderId is not None:
5493 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
5494 
      oprot.writeI64(self.orderId)
5495 
      oprot.writeFieldEnd()
5944 mandeep.dh 5496 
    if self.quantity is not None:
5966 rajveer 5497 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
5944 mandeep.dh 5498 
      oprot.writeDouble(self.quantity)
5499 
      oprot.writeFieldEnd()
5500 
    oprot.writeFieldStop()
5501 
    oprot.writeStructEnd()
5502 
 
5503 
  def validate(self):
5504 
    return
5505 
 
5506 
 
5507 
  def __repr__(self):
5508 
    L = ['%s=%r' % (key, value)
5509 
      for key, value in self.__dict__.iteritems()]
5510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5511 
 
5512 
  def __eq__(self, other):
5513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5514 
 
5515 
  def __ne__(self, other):
5516 
    return not (self == other)
5517 
 
5518 
class reduceReservationCount_result:
5519 
  """
5520 
  Attributes:
5521 
   - success
5522 
   - cex
5523 
  """
5524 
 
5525 
  thrift_spec = (
5526 
    (0, TType.BOOL, 'success', None, None, ), # 0
5527 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5528 
  )
5529 
 
5530 
  def __init__(self, success=None, cex=None,):
5531 
    self.success = success
5532 
    self.cex = cex
5533 
 
5534 
  def read(self, iprot):
5535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5537 
      return
5538 
    iprot.readStructBegin()
5539 
    while True:
5540 
      (fname, ftype, fid) = iprot.readFieldBegin()
5541 
      if ftype == TType.STOP:
5542 
        break
5543 
      if fid == 0:
5544 
        if ftype == TType.BOOL:
5545 
          self.success = iprot.readBool();
5546 
        else:
5547 
          iprot.skip(ftype)
5548 
      elif fid == 1:
5549 
        if ftype == TType.STRUCT:
5550 
          self.cex = InventoryServiceException()
5551 
          self.cex.read(iprot)
5552 
        else:
5553 
          iprot.skip(ftype)
5554 
      else:
5555 
        iprot.skip(ftype)
5556 
      iprot.readFieldEnd()
5557 
    iprot.readStructEnd()
5558 
 
5559 
  def write(self, oprot):
5560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5562 
      return
5563 
    oprot.writeStructBegin('reduceReservationCount_result')
5564 
    if self.success is not None:
5565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5566 
      oprot.writeBool(self.success)
5567 
      oprot.writeFieldEnd()
5568 
    if self.cex is not None:
5569 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5570 
      self.cex.write(oprot)
5571 
      oprot.writeFieldEnd()
5572 
    oprot.writeFieldStop()
5573 
    oprot.writeStructEnd()
5574 
 
5575 
  def validate(self):
5576 
    return
5577 
 
5578 
 
5579 
  def __repr__(self):
5580 
    L = ['%s=%r' % (key, value)
5581 
      for key, value in self.__dict__.iteritems()]
5582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5583 
 
5584 
  def __eq__(self, other):
5585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5586 
 
5587 
  def __ne__(self, other):
5588 
    return not (self == other)
5589 
 
5590 
class getItemPricing_args:
5591 
  """
5592 
  Attributes:
5593 
   - itemId
5594 
   - vendorId
5595 
  """
5596 
 
5597 
  thrift_spec = (
5598 
    None, # 0
5599 
    (1, TType.I64, 'itemId', None, None, ), # 1
5600 
    (2, TType.I64, 'vendorId', None, None, ), # 2
5601 
  )
5602 
 
5603 
  def __init__(self, itemId=None, vendorId=None,):
5604 
    self.itemId = itemId
5605 
    self.vendorId = vendorId
5606 
 
5607 
  def read(self, iprot):
5608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5610 
      return
5611 
    iprot.readStructBegin()
5612 
    while True:
5613 
      (fname, ftype, fid) = iprot.readFieldBegin()
5614 
      if ftype == TType.STOP:
5615 
        break
5616 
      if fid == 1:
5617 
        if ftype == TType.I64:
5618 
          self.itemId = iprot.readI64();
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      elif fid == 2:
5622 
        if ftype == TType.I64:
5623 
          self.vendorId = iprot.readI64();
5624 
        else:
5625 
          iprot.skip(ftype)
5626 
      else:
5627 
        iprot.skip(ftype)
5628 
      iprot.readFieldEnd()
5629 
    iprot.readStructEnd()
5630 
 
5631 
  def write(self, oprot):
5632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5634 
      return
5635 
    oprot.writeStructBegin('getItemPricing_args')
5636 
    if self.itemId is not None:
5637 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5638 
      oprot.writeI64(self.itemId)
5639 
      oprot.writeFieldEnd()
5640 
    if self.vendorId is not None:
5641 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
5642 
      oprot.writeI64(self.vendorId)
5643 
      oprot.writeFieldEnd()
5644 
    oprot.writeFieldStop()
5645 
    oprot.writeStructEnd()
5646 
 
5647 
  def validate(self):
5648 
    return
5649 
 
5650 
 
5651 
  def __repr__(self):
5652 
    L = ['%s=%r' % (key, value)
5653 
      for key, value in self.__dict__.iteritems()]
5654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5655 
 
5656 
  def __eq__(self, other):
5657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5658 
 
5659 
  def __ne__(self, other):
5660 
    return not (self == other)
5661 
 
5662 
class getItemPricing_result:
5663 
  """
5664 
  Attributes:
5665 
   - success
5666 
   - cex
5667 
  """
5668 
 
5669 
  thrift_spec = (
5670 
    (0, TType.STRUCT, 'success', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 0
5671 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5672 
  )
5673 
 
5674 
  def __init__(self, success=None, cex=None,):
5675 
    self.success = success
5676 
    self.cex = cex
5677 
 
5678 
  def read(self, iprot):
5679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5681 
      return
5682 
    iprot.readStructBegin()
5683 
    while True:
5684 
      (fname, ftype, fid) = iprot.readFieldBegin()
5685 
      if ftype == TType.STOP:
5686 
        break
5687 
      if fid == 0:
5688 
        if ftype == TType.STRUCT:
5689 
          self.success = VendorItemPricing()
5690 
          self.success.read(iprot)
5691 
        else:
5692 
          iprot.skip(ftype)
5693 
      elif fid == 1:
5694 
        if ftype == TType.STRUCT:
5695 
          self.cex = InventoryServiceException()
5696 
          self.cex.read(iprot)
5697 
        else:
5698 
          iprot.skip(ftype)
5699 
      else:
5700 
        iprot.skip(ftype)
5701 
      iprot.readFieldEnd()
5702 
    iprot.readStructEnd()
5703 
 
5704 
  def write(self, oprot):
5705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5707 
      return
5708 
    oprot.writeStructBegin('getItemPricing_result')
5709 
    if self.success is not None:
5710 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5711 
      self.success.write(oprot)
5712 
      oprot.writeFieldEnd()
5713 
    if self.cex is not None:
5714 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5715 
      self.cex.write(oprot)
5716 
      oprot.writeFieldEnd()
5717 
    oprot.writeFieldStop()
5718 
    oprot.writeStructEnd()
5719 
 
5720 
  def validate(self):
5721 
    return
5722 
 
5723 
 
5724 
  def __repr__(self):
5725 
    L = ['%s=%r' % (key, value)
5726 
      for key, value in self.__dict__.iteritems()]
5727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5728 
 
5729 
  def __eq__(self, other):
5730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5731 
 
5732 
  def __ne__(self, other):
5733 
    return not (self == other)
5734 
 
5735 
class getAllItemPricing_args:
5736 
  """
5737 
  Attributes:
5738 
   - itemId
5739 
  """
5740 
 
5741 
  thrift_spec = (
5742 
    None, # 0
5743 
    (1, TType.I64, 'itemId', None, None, ), # 1
5744 
  )
5745 
 
5746 
  def __init__(self, itemId=None,):
5747 
    self.itemId = itemId
5748 
 
5749 
  def read(self, iprot):
5750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5752 
      return
5753 
    iprot.readStructBegin()
5754 
    while True:
5755 
      (fname, ftype, fid) = iprot.readFieldBegin()
5756 
      if ftype == TType.STOP:
5757 
        break
5758 
      if fid == 1:
5759 
        if ftype == TType.I64:
5760 
          self.itemId = iprot.readI64();
5761 
        else:
5762 
          iprot.skip(ftype)
5763 
      else:
5764 
        iprot.skip(ftype)
5765 
      iprot.readFieldEnd()
5766 
    iprot.readStructEnd()
5767 
 
5768 
  def write(self, oprot):
5769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5771 
      return
5772 
    oprot.writeStructBegin('getAllItemPricing_args')
5773 
    if self.itemId is not None:
5774 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5775 
      oprot.writeI64(self.itemId)
5776 
      oprot.writeFieldEnd()
5777 
    oprot.writeFieldStop()
5778 
    oprot.writeStructEnd()
5779 
 
5780 
  def validate(self):
5781 
    return
5782 
 
5783 
 
5784 
  def __repr__(self):
5785 
    L = ['%s=%r' % (key, value)
5786 
      for key, value in self.__dict__.iteritems()]
5787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5788 
 
5789 
  def __eq__(self, other):
5790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5791 
 
5792 
  def __ne__(self, other):
5793 
    return not (self == other)
5794 
 
5795 
class getAllItemPricing_result:
5796 
  """
5797 
  Attributes:
5798 
   - success
5799 
   - cex
5800 
  """
5801 
 
5802 
  thrift_spec = (
5803 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemPricing, VendorItemPricing.thrift_spec)), None, ), # 0
5804 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5805 
  )
5806 
 
5807 
  def __init__(self, success=None, cex=None,):
5808 
    self.success = success
5809 
    self.cex = cex
5810 
 
5811 
  def read(self, iprot):
5812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5814 
      return
5815 
    iprot.readStructBegin()
5816 
    while True:
5817 
      (fname, ftype, fid) = iprot.readFieldBegin()
5818 
      if ftype == TType.STOP:
5819 
        break
5820 
      if fid == 0:
5821 
        if ftype == TType.LIST:
5822 
          self.success = []
8182 amar.kumar 5823 
          (_etype69, _size66) = iprot.readListBegin()
5824 
          for _i70 in xrange(_size66):
5825 
            _elem71 = VendorItemPricing()
5826 
            _elem71.read(iprot)
5827 
            self.success.append(_elem71)
5944 mandeep.dh 5828 
          iprot.readListEnd()
5829 
        else:
5830 
          iprot.skip(ftype)
5831 
      elif fid == 1:
5832 
        if ftype == TType.STRUCT:
5833 
          self.cex = InventoryServiceException()
5834 
          self.cex.read(iprot)
5835 
        else:
5836 
          iprot.skip(ftype)
5837 
      else:
5838 
        iprot.skip(ftype)
5839 
      iprot.readFieldEnd()
5840 
    iprot.readStructEnd()
5841 
 
5842 
  def write(self, oprot):
5843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5845 
      return
5846 
    oprot.writeStructBegin('getAllItemPricing_result')
5847 
    if self.success is not None:
5848 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5849 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 5850 
      for iter72 in self.success:
5851 
        iter72.write(oprot)
5944 mandeep.dh 5852 
      oprot.writeListEnd()
5853 
      oprot.writeFieldEnd()
5854 
    if self.cex is not None:
5855 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5856 
      self.cex.write(oprot)
5857 
      oprot.writeFieldEnd()
5858 
    oprot.writeFieldStop()
5859 
    oprot.writeStructEnd()
5860 
 
5861 
  def validate(self):
5862 
    return
5863 
 
5864 
 
5865 
  def __repr__(self):
5866 
    L = ['%s=%r' % (key, value)
5867 
      for key, value in self.__dict__.iteritems()]
5868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5869 
 
5870 
  def __eq__(self, other):
5871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5872 
 
5873 
  def __ne__(self, other):
5874 
    return not (self == other)
5875 
 
5876 
class addVendorItemPricing_args:
5877 
  """
5878 
  Attributes:
5879 
   - vendorItemPricing
5880 
  """
5881 
 
5882 
  thrift_spec = (
5883 
    None, # 0
5884 
    (1, TType.STRUCT, 'vendorItemPricing', (VendorItemPricing, VendorItemPricing.thrift_spec), None, ), # 1
5885 
  )
5886 
 
5887 
  def __init__(self, vendorItemPricing=None,):
5888 
    self.vendorItemPricing = vendorItemPricing
5889 
 
5890 
  def read(self, iprot):
5891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5893 
      return
5894 
    iprot.readStructBegin()
5895 
    while True:
5896 
      (fname, ftype, fid) = iprot.readFieldBegin()
5897 
      if ftype == TType.STOP:
5898 
        break
5899 
      if fid == 1:
5900 
        if ftype == TType.STRUCT:
5901 
          self.vendorItemPricing = VendorItemPricing()
5902 
          self.vendorItemPricing.read(iprot)
5903 
        else:
5904 
          iprot.skip(ftype)
5905 
      else:
5906 
        iprot.skip(ftype)
5907 
      iprot.readFieldEnd()
5908 
    iprot.readStructEnd()
5909 
 
5910 
  def write(self, oprot):
5911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5913 
      return
5914 
    oprot.writeStructBegin('addVendorItemPricing_args')
5915 
    if self.vendorItemPricing is not None:
5916 
      oprot.writeFieldBegin('vendorItemPricing', TType.STRUCT, 1)
5917 
      self.vendorItemPricing.write(oprot)
5918 
      oprot.writeFieldEnd()
5919 
    oprot.writeFieldStop()
5920 
    oprot.writeStructEnd()
5921 
 
5922 
  def validate(self):
5923 
    return
5924 
 
5925 
 
5926 
  def __repr__(self):
5927 
    L = ['%s=%r' % (key, value)
5928 
      for key, value in self.__dict__.iteritems()]
5929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5930 
 
5931 
  def __eq__(self, other):
5932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5933 
 
5934 
  def __ne__(self, other):
5935 
    return not (self == other)
5936 
 
5937 
class addVendorItemPricing_result:
5938 
  """
5939 
  Attributes:
5940 
   - cex
5941 
  """
5942 
 
5943 
  thrift_spec = (
5944 
    None, # 0
5945 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
5946 
  )
5947 
 
5948 
  def __init__(self, cex=None,):
5949 
    self.cex = cex
5950 
 
5951 
  def read(self, iprot):
5952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5954 
      return
5955 
    iprot.readStructBegin()
5956 
    while True:
5957 
      (fname, ftype, fid) = iprot.readFieldBegin()
5958 
      if ftype == TType.STOP:
5959 
        break
5960 
      if fid == 1:
5961 
        if ftype == TType.STRUCT:
5962 
          self.cex = InventoryServiceException()
5963 
          self.cex.read(iprot)
5964 
        else:
5965 
          iprot.skip(ftype)
5966 
      else:
5967 
        iprot.skip(ftype)
5968 
      iprot.readFieldEnd()
5969 
    iprot.readStructEnd()
5970 
 
5971 
  def write(self, oprot):
5972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5974 
      return
5975 
    oprot.writeStructBegin('addVendorItemPricing_result')
5976 
    if self.cex is not None:
5977 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
5978 
      self.cex.write(oprot)
5979 
      oprot.writeFieldEnd()
5980 
    oprot.writeFieldStop()
5981 
    oprot.writeStructEnd()
5982 
 
5983 
  def validate(self):
5984 
    return
5985 
 
5986 
 
5987 
  def __repr__(self):
5988 
    L = ['%s=%r' % (key, value)
5989 
      for key, value in self.__dict__.iteritems()]
5990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5991 
 
5992 
  def __eq__(self, other):
5993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5994 
 
5995 
  def __ne__(self, other):
5996 
    return not (self == other)
5997 
 
5998 
class getVendor_args:
5999 
  """
6000 
  Attributes:
6001 
   - vendorId
6002 
  """
6003 
 
6004 
  thrift_spec = (
6005 
    None, # 0
6006 
    (1, TType.I64, 'vendorId', None, None, ), # 1
6007 
  )
6008 
 
6009 
  def __init__(self, vendorId=None,):
6010 
    self.vendorId = vendorId
6011 
 
6012 
  def read(self, iprot):
6013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6015 
      return
6016 
    iprot.readStructBegin()
6017 
    while True:
6018 
      (fname, ftype, fid) = iprot.readFieldBegin()
6019 
      if ftype == TType.STOP:
6020 
        break
6021 
      if fid == 1:
6022 
        if ftype == TType.I64:
6023 
          self.vendorId = iprot.readI64();
6024 
        else:
6025 
          iprot.skip(ftype)
6026 
      else:
6027 
        iprot.skip(ftype)
6028 
      iprot.readFieldEnd()
6029 
    iprot.readStructEnd()
6030 
 
6031 
  def write(self, oprot):
6032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6034 
      return
6035 
    oprot.writeStructBegin('getVendor_args')
6036 
    if self.vendorId is not None:
6037 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
6038 
      oprot.writeI64(self.vendorId)
6039 
      oprot.writeFieldEnd()
6040 
    oprot.writeFieldStop()
6041 
    oprot.writeStructEnd()
6042 
 
6043 
  def validate(self):
6044 
    return
6045 
 
6046 
 
6047 
  def __repr__(self):
6048 
    L = ['%s=%r' % (key, value)
6049 
      for key, value in self.__dict__.iteritems()]
6050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6051 
 
6052 
  def __eq__(self, other):
6053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6054 
 
6055 
  def __ne__(self, other):
6056 
    return not (self == other)
6057 
 
6058 
class getVendor_result:
6059 
  """
6060 
  Attributes:
6061 
   - success
6062 
  """
6063 
 
6064 
  thrift_spec = (
6065 
    (0, TType.STRUCT, 'success', (Vendor, Vendor.thrift_spec), None, ), # 0
6066 
  )
6067 
 
6068 
  def __init__(self, success=None,):
6069 
    self.success = success
6070 
 
6071 
  def read(self, iprot):
6072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6074 
      return
6075 
    iprot.readStructBegin()
6076 
    while True:
6077 
      (fname, ftype, fid) = iprot.readFieldBegin()
6078 
      if ftype == TType.STOP:
6079 
        break
6080 
      if fid == 0:
6081 
        if ftype == TType.STRUCT:
6082 
          self.success = Vendor()
6083 
          self.success.read(iprot)
6084 
        else:
6085 
          iprot.skip(ftype)
6086 
      else:
6087 
        iprot.skip(ftype)
6088 
      iprot.readFieldEnd()
6089 
    iprot.readStructEnd()
6090 
 
6091 
  def write(self, oprot):
6092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6094 
      return
6095 
    oprot.writeStructBegin('getVendor_result')
6096 
    if self.success is not None:
6097 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6098 
      self.success.write(oprot)
6099 
      oprot.writeFieldEnd()
6100 
    oprot.writeFieldStop()
6101 
    oprot.writeStructEnd()
6102 
 
6103 
  def validate(self):
6104 
    return
6105 
 
6106 
 
6107 
  def __repr__(self):
6108 
    L = ['%s=%r' % (key, value)
6109 
      for key, value in self.__dict__.iteritems()]
6110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6111 
 
6112 
  def __eq__(self, other):
6113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6114 
 
6115 
  def __ne__(self, other):
6116 
    return not (self == other)
6117 
 
6118 
class getAllVendors_args:
6119 
 
6120 
  thrift_spec = (
6121 
  )
6122 
 
6123 
  def read(self, iprot):
6124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6126 
      return
6127 
    iprot.readStructBegin()
6128 
    while True:
6129 
      (fname, ftype, fid) = iprot.readFieldBegin()
6130 
      if ftype == TType.STOP:
6131 
        break
6132 
      else:
6133 
        iprot.skip(ftype)
6134 
      iprot.readFieldEnd()
6135 
    iprot.readStructEnd()
6136 
 
6137 
  def write(self, oprot):
6138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6140 
      return
6141 
    oprot.writeStructBegin('getAllVendors_args')
6142 
    oprot.writeFieldStop()
6143 
    oprot.writeStructEnd()
6144 
 
6145 
  def validate(self):
6146 
    return
6147 
 
6148 
 
6149 
  def __repr__(self):
6150 
    L = ['%s=%r' % (key, value)
6151 
      for key, value in self.__dict__.iteritems()]
6152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6153 
 
6154 
  def __eq__(self, other):
6155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6156 
 
6157 
  def __ne__(self, other):
6158 
    return not (self == other)
6159 
 
6160 
class getAllVendors_result:
6161 
  """
6162 
  Attributes:
6163 
   - success
6164 
  """
6165 
 
6166 
  thrift_spec = (
6167 
    (0, TType.LIST, 'success', (TType.STRUCT,(Vendor, Vendor.thrift_spec)), None, ), # 0
6168 
  )
6169 
 
6170 
  def __init__(self, success=None,):
6171 
    self.success = success
6172 
 
6173 
  def read(self, iprot):
6174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6176 
      return
6177 
    iprot.readStructBegin()
6178 
    while True:
6179 
      (fname, ftype, fid) = iprot.readFieldBegin()
6180 
      if ftype == TType.STOP:
6181 
        break
6182 
      if fid == 0:
6183 
        if ftype == TType.LIST:
6184 
          self.success = []
8182 amar.kumar 6185 
          (_etype76, _size73) = iprot.readListBegin()
6186 
          for _i77 in xrange(_size73):
6187 
            _elem78 = Vendor()
6188 
            _elem78.read(iprot)
6189 
            self.success.append(_elem78)
5944 mandeep.dh 6190 
          iprot.readListEnd()
6191 
        else:
6192 
          iprot.skip(ftype)
6193 
      else:
6194 
        iprot.skip(ftype)
6195 
      iprot.readFieldEnd()
6196 
    iprot.readStructEnd()
6197 
 
6198 
  def write(self, oprot):
6199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6201 
      return
6202 
    oprot.writeStructBegin('getAllVendors_result')
6203 
    if self.success is not None:
6204 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6205 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6206 
      for iter79 in self.success:
6207 
        iter79.write(oprot)
5944 mandeep.dh 6208 
      oprot.writeListEnd()
6209 
      oprot.writeFieldEnd()
6210 
    oprot.writeFieldStop()
6211 
    oprot.writeStructEnd()
6212 
 
6213 
  def validate(self):
6214 
    return
6215 
 
6216 
 
6217 
  def __repr__(self):
6218 
    L = ['%s=%r' % (key, value)
6219 
      for key, value in self.__dict__.iteritems()]
6220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6221 
 
6222 
  def __eq__(self, other):
6223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6224 
 
6225 
  def __ne__(self, other):
6226 
    return not (self == other)
6227 
 
6228 
class addVendorItemMapping_args:
6229 
  """
6230 
  Attributes:
6231 
   - key
6232 
   - vendorItemMapping
6233 
  """
6234 
 
6235 
  thrift_spec = (
6236 
    None, # 0
6237 
    (1, TType.STRING, 'key', None, None, ), # 1
6238 
    (2, TType.STRUCT, 'vendorItemMapping', (VendorItemMapping, VendorItemMapping.thrift_spec), None, ), # 2
6239 
  )
6240 
 
6241 
  def __init__(self, key=None, vendorItemMapping=None,):
6242 
    self.key = key
6243 
    self.vendorItemMapping = vendorItemMapping
6244 
 
6245 
  def read(self, iprot):
6246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6248 
      return
6249 
    iprot.readStructBegin()
6250 
    while True:
6251 
      (fname, ftype, fid) = iprot.readFieldBegin()
6252 
      if ftype == TType.STOP:
6253 
        break
6254 
      if fid == 1:
6255 
        if ftype == TType.STRING:
6256 
          self.key = iprot.readString();
6257 
        else:
6258 
          iprot.skip(ftype)
6259 
      elif fid == 2:
6260 
        if ftype == TType.STRUCT:
6261 
          self.vendorItemMapping = VendorItemMapping()
6262 
          self.vendorItemMapping.read(iprot)
6263 
        else:
6264 
          iprot.skip(ftype)
6265 
      else:
6266 
        iprot.skip(ftype)
6267 
      iprot.readFieldEnd()
6268 
    iprot.readStructEnd()
6269 
 
6270 
  def write(self, oprot):
6271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6273 
      return
6274 
    oprot.writeStructBegin('addVendorItemMapping_args')
6275 
    if self.key is not None:
6276 
      oprot.writeFieldBegin('key', TType.STRING, 1)
6277 
      oprot.writeString(self.key)
6278 
      oprot.writeFieldEnd()
6279 
    if self.vendorItemMapping is not None:
6280 
      oprot.writeFieldBegin('vendorItemMapping', TType.STRUCT, 2)
6281 
      self.vendorItemMapping.write(oprot)
6282 
      oprot.writeFieldEnd()
6283 
    oprot.writeFieldStop()
6284 
    oprot.writeStructEnd()
6285 
 
6286 
  def validate(self):
6287 
    return
6288 
 
6289 
 
6290 
  def __repr__(self):
6291 
    L = ['%s=%r' % (key, value)
6292 
      for key, value in self.__dict__.iteritems()]
6293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6294 
 
6295 
  def __eq__(self, other):
6296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6297 
 
6298 
  def __ne__(self, other):
6299 
    return not (self == other)
6300 
 
6301 
class addVendorItemMapping_result:
6302 
  """
6303 
  Attributes:
6304 
   - cex
6305 
  """
6306 
 
6307 
  thrift_spec = (
6308 
    None, # 0
6309 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6310 
  )
6311 
 
6312 
  def __init__(self, cex=None,):
6313 
    self.cex = cex
6314 
 
6315 
  def read(self, iprot):
6316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6318 
      return
6319 
    iprot.readStructBegin()
6320 
    while True:
6321 
      (fname, ftype, fid) = iprot.readFieldBegin()
6322 
      if ftype == TType.STOP:
6323 
        break
6324 
      if fid == 1:
6325 
        if ftype == TType.STRUCT:
6326 
          self.cex = InventoryServiceException()
6327 
          self.cex.read(iprot)
6328 
        else:
6329 
          iprot.skip(ftype)
6330 
      else:
6331 
        iprot.skip(ftype)
6332 
      iprot.readFieldEnd()
6333 
    iprot.readStructEnd()
6334 
 
6335 
  def write(self, oprot):
6336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6338 
      return
6339 
    oprot.writeStructBegin('addVendorItemMapping_result')
6340 
    if self.cex is not None:
6341 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6342 
      self.cex.write(oprot)
6343 
      oprot.writeFieldEnd()
6344 
    oprot.writeFieldStop()
6345 
    oprot.writeStructEnd()
6346 
 
6347 
  def validate(self):
6348 
    return
6349 
 
6350 
 
6351 
  def __repr__(self):
6352 
    L = ['%s=%r' % (key, value)
6353 
      for key, value in self.__dict__.iteritems()]
6354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6355 
 
6356 
  def __eq__(self, other):
6357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6358 
 
6359 
  def __ne__(self, other):
6360 
    return not (self == other)
6361 
 
6362 
class getVendorItemMappings_args:
6363 
  """
6364 
  Attributes:
6365 
   - itemId
6366 
  """
6367 
 
6368 
  thrift_spec = (
6369 
    None, # 0
6370 
    (1, TType.I64, 'itemId', None, None, ), # 1
6371 
  )
6372 
 
6373 
  def __init__(self, itemId=None,):
6374 
    self.itemId = itemId
6375 
 
6376 
  def read(self, iprot):
6377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6379 
      return
6380 
    iprot.readStructBegin()
6381 
    while True:
6382 
      (fname, ftype, fid) = iprot.readFieldBegin()
6383 
      if ftype == TType.STOP:
6384 
        break
6385 
      if fid == 1:
6386 
        if ftype == TType.I64:
6387 
          self.itemId = iprot.readI64();
6388 
        else:
6389 
          iprot.skip(ftype)
6390 
      else:
6391 
        iprot.skip(ftype)
6392 
      iprot.readFieldEnd()
6393 
    iprot.readStructEnd()
6394 
 
6395 
  def write(self, oprot):
6396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6398 
      return
6399 
    oprot.writeStructBegin('getVendorItemMappings_args')
6400 
    if self.itemId is not None:
6401 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6402 
      oprot.writeI64(self.itemId)
6403 
      oprot.writeFieldEnd()
6404 
    oprot.writeFieldStop()
6405 
    oprot.writeStructEnd()
6406 
 
6407 
  def validate(self):
6408 
    return
6409 
 
6410 
 
6411 
  def __repr__(self):
6412 
    L = ['%s=%r' % (key, value)
6413 
      for key, value in self.__dict__.iteritems()]
6414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6415 
 
6416 
  def __eq__(self, other):
6417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6418 
 
6419 
  def __ne__(self, other):
6420 
    return not (self == other)
6421 
 
6422 
class getVendorItemMappings_result:
6423 
  """
6424 
  Attributes:
6425 
   - success
6426 
   - cex
6427 
  """
6428 
 
6429 
  thrift_spec = (
6430 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
6431 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6432 
  )
6433 
 
6434 
  def __init__(self, success=None, cex=None,):
6435 
    self.success = success
6436 
    self.cex = cex
6437 
 
6438 
  def read(self, iprot):
6439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6441 
      return
6442 
    iprot.readStructBegin()
6443 
    while True:
6444 
      (fname, ftype, fid) = iprot.readFieldBegin()
6445 
      if ftype == TType.STOP:
6446 
        break
6447 
      if fid == 0:
6448 
        if ftype == TType.LIST:
6449 
          self.success = []
8182 amar.kumar 6450 
          (_etype83, _size80) = iprot.readListBegin()
6451 
          for _i84 in xrange(_size80):
6452 
            _elem85 = VendorItemMapping()
6453 
            _elem85.read(iprot)
6454 
            self.success.append(_elem85)
5944 mandeep.dh 6455 
          iprot.readListEnd()
6456 
        else:
6457 
          iprot.skip(ftype)
6458 
      elif fid == 1:
6459 
        if ftype == TType.STRUCT:
6460 
          self.cex = InventoryServiceException()
6461 
          self.cex.read(iprot)
6462 
        else:
6463 
          iprot.skip(ftype)
6464 
      else:
6465 
        iprot.skip(ftype)
6466 
      iprot.readFieldEnd()
6467 
    iprot.readStructEnd()
6468 
 
6469 
  def write(self, oprot):
6470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6472 
      return
6473 
    oprot.writeStructBegin('getVendorItemMappings_result')
6474 
    if self.success is not None:
6475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6477 
      for iter86 in self.success:
6478 
        iter86.write(oprot)
5944 mandeep.dh 6479 
      oprot.writeListEnd()
6480 
      oprot.writeFieldEnd()
6481 
    if self.cex is not None:
6482 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6483 
      self.cex.write(oprot)
6484 
      oprot.writeFieldEnd()
6485 
    oprot.writeFieldStop()
6486 
    oprot.writeStructEnd()
6487 
 
6488 
  def validate(self):
6489 
    return
6490 
 
6491 
 
6492 
  def __repr__(self):
6493 
    L = ['%s=%r' % (key, value)
6494 
      for key, value in self.__dict__.iteritems()]
6495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6496 
 
6497 
  def __eq__(self, other):
6498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6499 
 
6500 
  def __ne__(self, other):
6501 
    return not (self == other)
6502 
 
6503 
class getPendingOrdersInventory_args:
6504 
  """
6505 
  Attributes:
6506 
   - vendorid
6507 
  """
6508 
 
6509 
  thrift_spec = (
6510 
    None, # 0
6511 
    (1, TType.I64, 'vendorid', None, None, ), # 1
6512 
  )
6513 
 
6514 
  def __init__(self, vendorid=None,):
6515 
    self.vendorid = vendorid
6516 
 
6517 
  def read(self, iprot):
6518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6520 
      return
6521 
    iprot.readStructBegin()
6522 
    while True:
6523 
      (fname, ftype, fid) = iprot.readFieldBegin()
6524 
      if ftype == TType.STOP:
6525 
        break
6526 
      if fid == 1:
6527 
        if ftype == TType.I64:
6528 
          self.vendorid = iprot.readI64();
6529 
        else:
6530 
          iprot.skip(ftype)
6531 
      else:
6532 
        iprot.skip(ftype)
6533 
      iprot.readFieldEnd()
6534 
    iprot.readStructEnd()
6535 
 
6536 
  def write(self, oprot):
6537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6539 
      return
6540 
    oprot.writeStructBegin('getPendingOrdersInventory_args')
6541 
    if self.vendorid is not None:
6542 
      oprot.writeFieldBegin('vendorid', TType.I64, 1)
6543 
      oprot.writeI64(self.vendorid)
6544 
      oprot.writeFieldEnd()
6545 
    oprot.writeFieldStop()
6546 
    oprot.writeStructEnd()
6547 
 
6548 
  def validate(self):
6549 
    return
6550 
 
6551 
 
6552 
  def __repr__(self):
6553 
    L = ['%s=%r' % (key, value)
6554 
      for key, value in self.__dict__.iteritems()]
6555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6556 
 
6557 
  def __eq__(self, other):
6558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6559 
 
6560 
  def __ne__(self, other):
6561 
    return not (self == other)
6562 
 
6563 
class getPendingOrdersInventory_result:
6564 
  """
6565 
  Attributes:
6566 
   - success
6567 
  """
6568 
 
6569 
  thrift_spec = (
6570 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
6571 
  )
6572 
 
6573 
  def __init__(self, success=None,):
6574 
    self.success = success
6575 
 
6576 
  def read(self, iprot):
6577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6579 
      return
6580 
    iprot.readStructBegin()
6581 
    while True:
6582 
      (fname, ftype, fid) = iprot.readFieldBegin()
6583 
      if ftype == TType.STOP:
6584 
        break
6585 
      if fid == 0:
6586 
        if ftype == TType.LIST:
6587 
          self.success = []
8182 amar.kumar 6588 
          (_etype90, _size87) = iprot.readListBegin()
6589 
          for _i91 in xrange(_size87):
6590 
            _elem92 = AvailableAndReservedStock()
6591 
            _elem92.read(iprot)
6592 
            self.success.append(_elem92)
5944 mandeep.dh 6593 
          iprot.readListEnd()
6594 
        else:
6595 
          iprot.skip(ftype)
6596 
      else:
6597 
        iprot.skip(ftype)
6598 
      iprot.readFieldEnd()
6599 
    iprot.readStructEnd()
6600 
 
6601 
  def write(self, oprot):
6602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6604 
      return
6605 
    oprot.writeStructBegin('getPendingOrdersInventory_result')
6606 
    if self.success is not None:
6607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6609 
      for iter93 in self.success:
6610 
        iter93.write(oprot)
5944 mandeep.dh 6611 
      oprot.writeListEnd()
6612 
      oprot.writeFieldEnd()
6613 
    oprot.writeFieldStop()
6614 
    oprot.writeStructEnd()
6615 
 
6616 
  def validate(self):
6617 
    return
6618 
 
6619 
 
6620 
  def __repr__(self):
6621 
    L = ['%s=%r' % (key, value)
6622 
      for key, value in self.__dict__.iteritems()]
6623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6624 
 
6625 
  def __eq__(self, other):
6626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6627 
 
6628 
  def __ne__(self, other):
6629 
    return not (self == other)
6630 
 
6631 
class getWarehouses_args:
6632 
  """
6633 
  Attributes:
6634 
   - warehouseType
6635 
   - inventoryType
6636 
   - vendorId
6637 
   - billingWarehouseId
6638 
   - shippingWarehouseId
6639 
  """
6640 
 
6641 
  thrift_spec = (
6642 
    None, # 0
6643 
    (1, TType.I32, 'warehouseType', None, None, ), # 1
6644 
    (2, TType.I32, 'inventoryType', None, None, ), # 2
6645 
    (3, TType.I64, 'vendorId', None, None, ), # 3
6646 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
6647 
    (5, TType.I64, 'shippingWarehouseId', None, None, ), # 5
6648 
  )
6649 
 
6650 
  def __init__(self, warehouseType=None, inventoryType=None, vendorId=None, billingWarehouseId=None, shippingWarehouseId=None,):
6651 
    self.warehouseType = warehouseType
6652 
    self.inventoryType = inventoryType
6653 
    self.vendorId = vendorId
6654 
    self.billingWarehouseId = billingWarehouseId
6655 
    self.shippingWarehouseId = shippingWarehouseId
6656 
 
6657 
  def read(self, iprot):
6658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6660 
      return
6661 
    iprot.readStructBegin()
6662 
    while True:
6663 
      (fname, ftype, fid) = iprot.readFieldBegin()
6664 
      if ftype == TType.STOP:
6665 
        break
6666 
      if fid == 1:
6667 
        if ftype == TType.I32:
6668 
          self.warehouseType = iprot.readI32();
6669 
        else:
6670 
          iprot.skip(ftype)
6671 
      elif fid == 2:
6672 
        if ftype == TType.I32:
6673 
          self.inventoryType = iprot.readI32();
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 3:
6677 
        if ftype == TType.I64:
6678 
          self.vendorId = iprot.readI64();
6679 
        else:
6680 
          iprot.skip(ftype)
6681 
      elif fid == 4:
6682 
        if ftype == TType.I64:
6683 
          self.billingWarehouseId = iprot.readI64();
6684 
        else:
6685 
          iprot.skip(ftype)
6686 
      elif fid == 5:
6687 
        if ftype == TType.I64:
6688 
          self.shippingWarehouseId = iprot.readI64();
6689 
        else:
6690 
          iprot.skip(ftype)
6691 
      else:
6692 
        iprot.skip(ftype)
6693 
      iprot.readFieldEnd()
6694 
    iprot.readStructEnd()
6695 
 
6696 
  def write(self, oprot):
6697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6699 
      return
6700 
    oprot.writeStructBegin('getWarehouses_args')
6701 
    if self.warehouseType is not None:
6702 
      oprot.writeFieldBegin('warehouseType', TType.I32, 1)
6703 
      oprot.writeI32(self.warehouseType)
6704 
      oprot.writeFieldEnd()
6705 
    if self.inventoryType is not None:
6706 
      oprot.writeFieldBegin('inventoryType', TType.I32, 2)
6707 
      oprot.writeI32(self.inventoryType)
6708 
      oprot.writeFieldEnd()
6709 
    if self.vendorId is not None:
6710 
      oprot.writeFieldBegin('vendorId', TType.I64, 3)
6711 
      oprot.writeI64(self.vendorId)
6712 
      oprot.writeFieldEnd()
6713 
    if self.billingWarehouseId is not None:
6714 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
6715 
      oprot.writeI64(self.billingWarehouseId)
6716 
      oprot.writeFieldEnd()
6717 
    if self.shippingWarehouseId is not None:
6718 
      oprot.writeFieldBegin('shippingWarehouseId', TType.I64, 5)
6719 
      oprot.writeI64(self.shippingWarehouseId)
6720 
      oprot.writeFieldEnd()
6721 
    oprot.writeFieldStop()
6722 
    oprot.writeStructEnd()
6723 
 
6724 
  def validate(self):
6725 
    return
6726 
 
6727 
 
6728 
  def __repr__(self):
6729 
    L = ['%s=%r' % (key, value)
6730 
      for key, value in self.__dict__.iteritems()]
6731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6732 
 
6733 
  def __eq__(self, other):
6734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6735 
 
6736 
  def __ne__(self, other):
6737 
    return not (self == other)
6738 
 
6739 
class getWarehouses_result:
6740 
  """
6741 
  Attributes:
6742 
   - success
6743 
  """
6744 
 
6745 
  thrift_spec = (
6746 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
6747 
  )
6748 
 
6749 
  def __init__(self, success=None,):
6750 
    self.success = success
6751 
 
6752 
  def read(self, iprot):
6753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6755 
      return
6756 
    iprot.readStructBegin()
6757 
    while True:
6758 
      (fname, ftype, fid) = iprot.readFieldBegin()
6759 
      if ftype == TType.STOP:
6760 
        break
6761 
      if fid == 0:
6762 
        if ftype == TType.LIST:
6763 
          self.success = []
8182 amar.kumar 6764 
          (_etype97, _size94) = iprot.readListBegin()
6765 
          for _i98 in xrange(_size94):
6766 
            _elem99 = Warehouse()
6767 
            _elem99.read(iprot)
6768 
            self.success.append(_elem99)
5944 mandeep.dh 6769 
          iprot.readListEnd()
6770 
        else:
6771 
          iprot.skip(ftype)
6772 
      else:
6773 
        iprot.skip(ftype)
6774 
      iprot.readFieldEnd()
6775 
    iprot.readStructEnd()
6776 
 
6777 
  def write(self, oprot):
6778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6780 
      return
6781 
    oprot.writeStructBegin('getWarehouses_result')
6782 
    if self.success is not None:
6783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6784 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 6785 
      for iter100 in self.success:
6786 
        iter100.write(oprot)
5944 mandeep.dh 6787 
      oprot.writeListEnd()
6788 
      oprot.writeFieldEnd()
6789 
    oprot.writeFieldStop()
6790 
    oprot.writeStructEnd()
6791 
 
6792 
  def validate(self):
6793 
    return
6794 
 
6795 
 
6796 
  def __repr__(self):
6797 
    L = ['%s=%r' % (key, value)
6798 
      for key, value in self.__dict__.iteritems()]
6799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6800 
 
6801 
  def __eq__(self, other):
6802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6803 
 
6804 
  def __ne__(self, other):
6805 
    return not (self == other)
6806 
 
6807 
class resetAvailability_args:
6808 
  """
6809 
  Attributes:
6810 
   - itemKey
6811 
   - vendorId
6812 
   - quantity
6813 
   - warehouseId
6814 
  """
6815 
 
6816 
  thrift_spec = (
6817 
    None, # 0
6818 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
6819 
    (2, TType.I64, 'vendorId', None, None, ), # 2
6820 
    (3, TType.I64, 'quantity', None, None, ), # 3
6821 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
6822 
  )
6823 
 
6824 
  def __init__(self, itemKey=None, vendorId=None, quantity=None, warehouseId=None,):
6825 
    self.itemKey = itemKey
6826 
    self.vendorId = vendorId
6827 
    self.quantity = quantity
6828 
    self.warehouseId = warehouseId
6829 
 
6830 
  def read(self, iprot):
6831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6833 
      return
6834 
    iprot.readStructBegin()
6835 
    while True:
6836 
      (fname, ftype, fid) = iprot.readFieldBegin()
6837 
      if ftype == TType.STOP:
6838 
        break
6839 
      if fid == 1:
6840 
        if ftype == TType.STRING:
6841 
          self.itemKey = iprot.readString();
6842 
        else:
6843 
          iprot.skip(ftype)
6844 
      elif fid == 2:
6845 
        if ftype == TType.I64:
6846 
          self.vendorId = iprot.readI64();
6847 
        else:
6848 
          iprot.skip(ftype)
6849 
      elif fid == 3:
6850 
        if ftype == TType.I64:
6851 
          self.quantity = iprot.readI64();
6852 
        else:
6853 
          iprot.skip(ftype)
6854 
      elif fid == 4:
6855 
        if ftype == TType.I64:
6856 
          self.warehouseId = iprot.readI64();
6857 
        else:
6858 
          iprot.skip(ftype)
6859 
      else:
6860 
        iprot.skip(ftype)
6861 
      iprot.readFieldEnd()
6862 
    iprot.readStructEnd()
6863 
 
6864 
  def write(self, oprot):
6865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6867 
      return
6868 
    oprot.writeStructBegin('resetAvailability_args')
6869 
    if self.itemKey is not None:
6870 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
6871 
      oprot.writeString(self.itemKey)
6872 
      oprot.writeFieldEnd()
6873 
    if self.vendorId is not None:
6874 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
6875 
      oprot.writeI64(self.vendorId)
6876 
      oprot.writeFieldEnd()
6877 
    if self.quantity is not None:
6878 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
6879 
      oprot.writeI64(self.quantity)
6880 
      oprot.writeFieldEnd()
6881 
    if self.warehouseId is not None:
6882 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
6883 
      oprot.writeI64(self.warehouseId)
6884 
      oprot.writeFieldEnd()
6885 
    oprot.writeFieldStop()
6886 
    oprot.writeStructEnd()
6887 
 
6888 
  def validate(self):
6889 
    return
6890 
 
6891 
 
6892 
  def __repr__(self):
6893 
    L = ['%s=%r' % (key, value)
6894 
      for key, value in self.__dict__.iteritems()]
6895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6896 
 
6897 
  def __eq__(self, other):
6898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6899 
 
6900 
  def __ne__(self, other):
6901 
    return not (self == other)
6902 
 
6903 
class resetAvailability_result:
6904 
  """
6905 
  Attributes:
6906 
   - cex
6907 
  """
6908 
 
6909 
  thrift_spec = (
6910 
    None, # 0
6911 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
6912 
  )
6913 
 
6914 
  def __init__(self, cex=None,):
6915 
    self.cex = cex
6916 
 
6917 
  def read(self, iprot):
6918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6920 
      return
6921 
    iprot.readStructBegin()
6922 
    while True:
6923 
      (fname, ftype, fid) = iprot.readFieldBegin()
6924 
      if ftype == TType.STOP:
6925 
        break
6926 
      if fid == 1:
6927 
        if ftype == TType.STRUCT:
6928 
          self.cex = InventoryServiceException()
6929 
          self.cex.read(iprot)
6930 
        else:
6931 
          iprot.skip(ftype)
6932 
      else:
6933 
        iprot.skip(ftype)
6934 
      iprot.readFieldEnd()
6935 
    iprot.readStructEnd()
6936 
 
6937 
  def write(self, oprot):
6938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6940 
      return
6941 
    oprot.writeStructBegin('resetAvailability_result')
6942 
    if self.cex is not None:
6943 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
6944 
      self.cex.write(oprot)
6945 
      oprot.writeFieldEnd()
6946 
    oprot.writeFieldStop()
6947 
    oprot.writeStructEnd()
6948 
 
6949 
  def validate(self):
6950 
    return
6951 
 
6952 
 
6953 
  def __repr__(self):
6954 
    L = ['%s=%r' % (key, value)
6955 
      for key, value in self.__dict__.iteritems()]
6956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6957 
 
6958 
  def __eq__(self, other):
6959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6960 
 
6961 
  def __ne__(self, other):
6962 
    return not (self == other)
6963 
 
6964 
class resetAvailabilityForWarehouse_args:
6965 
  """
6966 
  Attributes:
6967 
   - warehouseId
6968 
  """
6969 
 
6970 
  thrift_spec = (
6971 
    None, # 0
6972 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6973 
  )
6974 
 
6975 
  def __init__(self, warehouseId=None,):
6976 
    self.warehouseId = warehouseId
6977 
 
6978 
  def read(self, iprot):
6979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6981 
      return
6982 
    iprot.readStructBegin()
6983 
    while True:
6984 
      (fname, ftype, fid) = iprot.readFieldBegin()
6985 
      if ftype == TType.STOP:
6986 
        break
6987 
      if fid == 1:
6988 
        if ftype == TType.I64:
6989 
          self.warehouseId = iprot.readI64();
6990 
        else:
6991 
          iprot.skip(ftype)
6992 
      else:
6993 
        iprot.skip(ftype)
6994 
      iprot.readFieldEnd()
6995 
    iprot.readStructEnd()
6996 
 
6997 
  def write(self, oprot):
6998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7000 
      return
7001 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_args')
7002 
    if self.warehouseId is not None:
7003 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7004 
      oprot.writeI64(self.warehouseId)
7005 
      oprot.writeFieldEnd()
7006 
    oprot.writeFieldStop()
7007 
    oprot.writeStructEnd()
7008 
 
7009 
  def validate(self):
7010 
    return
7011 
 
7012 
 
7013 
  def __repr__(self):
7014 
    L = ['%s=%r' % (key, value)
7015 
      for key, value in self.__dict__.iteritems()]
7016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7017 
 
7018 
  def __eq__(self, other):
7019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7020 
 
7021 
  def __ne__(self, other):
7022 
    return not (self == other)
7023 
 
7024 
class resetAvailabilityForWarehouse_result:
7025 
  """
7026 
  Attributes:
7027 
   - cex
7028 
  """
7029 
 
7030 
  thrift_spec = (
7031 
    None, # 0
7032 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7033 
  )
7034 
 
7035 
  def __init__(self, cex=None,):
7036 
    self.cex = cex
7037 
 
7038 
  def read(self, iprot):
7039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7041 
      return
7042 
    iprot.readStructBegin()
7043 
    while True:
7044 
      (fname, ftype, fid) = iprot.readFieldBegin()
7045 
      if ftype == TType.STOP:
7046 
        break
7047 
      if fid == 1:
7048 
        if ftype == TType.STRUCT:
7049 
          self.cex = InventoryServiceException()
7050 
          self.cex.read(iprot)
7051 
        else:
7052 
          iprot.skip(ftype)
7053 
      else:
7054 
        iprot.skip(ftype)
7055 
      iprot.readFieldEnd()
7056 
    iprot.readStructEnd()
7057 
 
7058 
  def write(self, oprot):
7059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7061 
      return
7062 
    oprot.writeStructBegin('resetAvailabilityForWarehouse_result')
7063 
    if self.cex is not None:
7064 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7065 
      self.cex.write(oprot)
7066 
      oprot.writeFieldEnd()
7067 
    oprot.writeFieldStop()
7068 
    oprot.writeStructEnd()
7069 
 
7070 
  def validate(self):
7071 
    return
7072 
 
7073 
 
7074 
  def __repr__(self):
7075 
    L = ['%s=%r' % (key, value)
7076 
      for key, value in self.__dict__.iteritems()]
7077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7078 
 
7079 
  def __eq__(self, other):
7080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7081 
 
7082 
  def __ne__(self, other):
7083 
    return not (self == other)
7084 
 
7085 
class getItemKeysToBeProcessed_args:
7086 
  """
7087 
  Attributes:
7088 
   - warehouseId
7089 
  """
7090 
 
7091 
  thrift_spec = (
7092 
    None, # 0
7093 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
7094 
  )
7095 
 
7096 
  def __init__(self, warehouseId=None,):
7097 
    self.warehouseId = warehouseId
7098 
 
7099 
  def read(self, iprot):
7100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7102 
      return
7103 
    iprot.readStructBegin()
7104 
    while True:
7105 
      (fname, ftype, fid) = iprot.readFieldBegin()
7106 
      if ftype == TType.STOP:
7107 
        break
7108 
      if fid == 1:
7109 
        if ftype == TType.I64:
7110 
          self.warehouseId = iprot.readI64();
7111 
        else:
7112 
          iprot.skip(ftype)
7113 
      else:
7114 
        iprot.skip(ftype)
7115 
      iprot.readFieldEnd()
7116 
    iprot.readStructEnd()
7117 
 
7118 
  def write(self, oprot):
7119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7121 
      return
7122 
    oprot.writeStructBegin('getItemKeysToBeProcessed_args')
7123 
    if self.warehouseId is not None:
7124 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7125 
      oprot.writeI64(self.warehouseId)
7126 
      oprot.writeFieldEnd()
7127 
    oprot.writeFieldStop()
7128 
    oprot.writeStructEnd()
7129 
 
7130 
  def validate(self):
7131 
    return
7132 
 
7133 
 
7134 
  def __repr__(self):
7135 
    L = ['%s=%r' % (key, value)
7136 
      for key, value in self.__dict__.iteritems()]
7137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7138 
 
7139 
  def __eq__(self, other):
7140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7141 
 
7142 
  def __ne__(self, other):
7143 
    return not (self == other)
7144 
 
7145 
class getItemKeysToBeProcessed_result:
7146 
  """
7147 
  Attributes:
7148 
   - success
7149 
  """
7150 
 
7151 
  thrift_spec = (
7152 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
7153 
  )
7154 
 
7155 
  def __init__(self, success=None,):
7156 
    self.success = success
7157 
 
7158 
  def read(self, iprot):
7159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7161 
      return
7162 
    iprot.readStructBegin()
7163 
    while True:
7164 
      (fname, ftype, fid) = iprot.readFieldBegin()
7165 
      if ftype == TType.STOP:
7166 
        break
7167 
      if fid == 0:
7168 
        if ftype == TType.LIST:
7169 
          self.success = []
8182 amar.kumar 7170 
          (_etype104, _size101) = iprot.readListBegin()
7171 
          for _i105 in xrange(_size101):
7172 
            _elem106 = iprot.readString();
7173 
            self.success.append(_elem106)
5944 mandeep.dh 7174 
          iprot.readListEnd()
7175 
        else:
7176 
          iprot.skip(ftype)
7177 
      else:
7178 
        iprot.skip(ftype)
7179 
      iprot.readFieldEnd()
7180 
    iprot.readStructEnd()
7181 
 
7182 
  def write(self, oprot):
7183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7185 
      return
7186 
    oprot.writeStructBegin('getItemKeysToBeProcessed_result')
7187 
    if self.success is not None:
7188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7189 
      oprot.writeListBegin(TType.STRING, len(self.success))
8182 amar.kumar 7190 
      for iter107 in self.success:
7191 
        oprot.writeString(iter107)
5944 mandeep.dh 7192 
      oprot.writeListEnd()
7193 
      oprot.writeFieldEnd()
7194 
    oprot.writeFieldStop()
7195 
    oprot.writeStructEnd()
7196 
 
7197 
  def validate(self):
7198 
    return
7199 
 
7200 
 
7201 
  def __repr__(self):
7202 
    L = ['%s=%r' % (key, value)
7203 
      for key, value in self.__dict__.iteritems()]
7204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7205 
 
7206 
  def __eq__(self, other):
7207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7208 
 
7209 
  def __ne__(self, other):
7210 
    return not (self == other)
7211 
 
7212 
class markMissedInventoryUpdatesAsProcessed_args:
7213 
  """
7214 
  Attributes:
7215 
   - itemKey
7216 
   - warehouseId
7217 
  """
7218 
 
7219 
  thrift_spec = (
7220 
    None, # 0
7221 
    (1, TType.STRING, 'itemKey', None, None, ), # 1
7222 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7223 
  )
7224 
 
7225 
  def __init__(self, itemKey=None, warehouseId=None,):
7226 
    self.itemKey = itemKey
7227 
    self.warehouseId = warehouseId
7228 
 
7229 
  def read(self, iprot):
7230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7232 
      return
7233 
    iprot.readStructBegin()
7234 
    while True:
7235 
      (fname, ftype, fid) = iprot.readFieldBegin()
7236 
      if ftype == TType.STOP:
7237 
        break
7238 
      if fid == 1:
7239 
        if ftype == TType.STRING:
7240 
          self.itemKey = iprot.readString();
7241 
        else:
7242 
          iprot.skip(ftype)
7243 
      elif fid == 2:
7244 
        if ftype == TType.I64:
7245 
          self.warehouseId = iprot.readI64();
7246 
        else:
7247 
          iprot.skip(ftype)
7248 
      else:
7249 
        iprot.skip(ftype)
7250 
      iprot.readFieldEnd()
7251 
    iprot.readStructEnd()
7252 
 
7253 
  def write(self, oprot):
7254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7256 
      return
7257 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_args')
7258 
    if self.itemKey is not None:
7259 
      oprot.writeFieldBegin('itemKey', TType.STRING, 1)
7260 
      oprot.writeString(self.itemKey)
7261 
      oprot.writeFieldEnd()
7262 
    if self.warehouseId is not None:
7263 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7264 
      oprot.writeI64(self.warehouseId)
7265 
      oprot.writeFieldEnd()
7266 
    oprot.writeFieldStop()
7267 
    oprot.writeStructEnd()
7268 
 
7269 
  def validate(self):
7270 
    return
7271 
 
7272 
 
7273 
  def __repr__(self):
7274 
    L = ['%s=%r' % (key, value)
7275 
      for key, value in self.__dict__.iteritems()]
7276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7277 
 
7278 
  def __eq__(self, other):
7279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7280 
 
7281 
  def __ne__(self, other):
7282 
    return not (self == other)
7283 
 
7284 
class markMissedInventoryUpdatesAsProcessed_result:
7285 
 
7286 
  thrift_spec = (
7287 
  )
7288 
 
7289 
  def read(self, iprot):
7290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7292 
      return
7293 
    iprot.readStructBegin()
7294 
    while True:
7295 
      (fname, ftype, fid) = iprot.readFieldBegin()
7296 
      if ftype == TType.STOP:
7297 
        break
7298 
      else:
7299 
        iprot.skip(ftype)
7300 
      iprot.readFieldEnd()
7301 
    iprot.readStructEnd()
7302 
 
7303 
  def write(self, oprot):
7304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7306 
      return
7307 
    oprot.writeStructBegin('markMissedInventoryUpdatesAsProcessed_result')
7308 
    oprot.writeFieldStop()
7309 
    oprot.writeStructEnd()
7310 
 
7311 
  def validate(self):
7312 
    return
7313 
 
7314 
 
7315 
  def __repr__(self):
7316 
    L = ['%s=%r' % (key, value)
7317 
      for key, value in self.__dict__.iteritems()]
7318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7319 
 
7320 
  def __eq__(self, other):
7321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7322 
 
7323 
  def __ne__(self, other):
7324 
    return not (self == other)
7325 
 
7326 
class getIgnoredItemKeys_args:
7327 
 
7328 
  thrift_spec = (
7329 
  )
7330 
 
7331 
  def read(self, iprot):
7332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7334 
      return
7335 
    iprot.readStructBegin()
7336 
    while True:
7337 
      (fname, ftype, fid) = iprot.readFieldBegin()
7338 
      if ftype == TType.STOP:
7339 
        break
7340 
      else:
7341 
        iprot.skip(ftype)
7342 
      iprot.readFieldEnd()
7343 
    iprot.readStructEnd()
7344 
 
7345 
  def write(self, oprot):
7346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7348 
      return
7349 
    oprot.writeStructBegin('getIgnoredItemKeys_args')
7350 
    oprot.writeFieldStop()
7351 
    oprot.writeStructEnd()
7352 
 
7353 
  def validate(self):
7354 
    return
7355 
 
7356 
 
7357 
  def __repr__(self):
7358 
    L = ['%s=%r' % (key, value)
7359 
      for key, value in self.__dict__.iteritems()]
7360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7361 
 
7362 
  def __eq__(self, other):
7363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7364 
 
7365 
  def __ne__(self, other):
7366 
    return not (self == other)
7367 
 
7368 
class getIgnoredItemKeys_result:
7369 
  """
7370 
  Attributes:
7371 
   - success
7372 
  """
7373 
 
7374 
  thrift_spec = (
7375 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.MAP,(TType.I64,None,TType.I64,None)), None, ), # 0
7376 
  )
7377 
 
7378 
  def __init__(self, success=None,):
7379 
    self.success = success
7380 
 
7381 
  def read(self, iprot):
7382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7384 
      return
7385 
    iprot.readStructBegin()
7386 
    while True:
7387 
      (fname, ftype, fid) = iprot.readFieldBegin()
7388 
      if ftype == TType.STOP:
7389 
        break
7390 
      if fid == 0:
7391 
        if ftype == TType.MAP:
7392 
          self.success = {}
8182 amar.kumar 7393 
          (_ktype109, _vtype110, _size108 ) = iprot.readMapBegin()
7394 
          for _i112 in xrange(_size108):
7395 
            _key113 = iprot.readString();
7396 
            _val114 = {}
7397 
            (_ktype116, _vtype117, _size115 ) = iprot.readMapBegin()
7398 
            for _i119 in xrange(_size115):
7399 
              _key120 = iprot.readI64();
7400 
              _val121 = iprot.readI64();
7401 
              _val114[_key120] = _val121
5944 mandeep.dh 7402 
            iprot.readMapEnd()
8182 amar.kumar 7403 
            self.success[_key113] = _val114
5944 mandeep.dh 7404 
          iprot.readMapEnd()
7405 
        else:
7406 
          iprot.skip(ftype)
7407 
      else:
7408 
        iprot.skip(ftype)
7409 
      iprot.readFieldEnd()
7410 
    iprot.readStructEnd()
7411 
 
7412 
  def write(self, oprot):
7413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7415 
      return
7416 
    oprot.writeStructBegin('getIgnoredItemKeys_result')
7417 
    if self.success is not None:
7418 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7419 
      oprot.writeMapBegin(TType.STRING, TType.MAP, len(self.success))
8182 amar.kumar 7420 
      for kiter122,viter123 in self.success.items():
7421 
        oprot.writeString(kiter122)
7422 
        oprot.writeMapBegin(TType.I64, TType.I64, len(viter123))
7423 
        for kiter124,viter125 in viter123.items():
7424 
          oprot.writeI64(kiter124)
7425 
          oprot.writeI64(viter125)
5944 mandeep.dh 7426 
        oprot.writeMapEnd()
7427 
      oprot.writeMapEnd()
7428 
      oprot.writeFieldEnd()
7429 
    oprot.writeFieldStop()
7430 
    oprot.writeStructEnd()
7431 
 
7432 
  def validate(self):
7433 
    return
7434 
 
7435 
 
7436 
  def __repr__(self):
7437 
    L = ['%s=%r' % (key, value)
7438 
      for key, value in self.__dict__.iteritems()]
7439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7440 
 
7441 
  def __eq__(self, other):
7442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7443 
 
7444 
  def __ne__(self, other):
7445 
    return not (self == other)
7446 
 
7447 
class addBadInventory_args:
7448 
  """
7449 
  Attributes:
7450 
   - itemId
7451 
   - warehouseId
7452 
   - quantity
7453 
  """
7454 
 
7455 
  thrift_spec = (
7456 
    None, # 0
7457 
    (1, TType.I64, 'itemId', None, None, ), # 1
7458 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
7459 
    (3, TType.I64, 'quantity', None, None, ), # 3
7460 
  )
7461 
 
7462 
  def __init__(self, itemId=None, warehouseId=None, quantity=None,):
7463 
    self.itemId = itemId
7464 
    self.warehouseId = warehouseId
7465 
    self.quantity = quantity
7466 
 
7467 
  def read(self, iprot):
7468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7470 
      return
7471 
    iprot.readStructBegin()
7472 
    while True:
7473 
      (fname, ftype, fid) = iprot.readFieldBegin()
7474 
      if ftype == TType.STOP:
7475 
        break
7476 
      if fid == 1:
7477 
        if ftype == TType.I64:
7478 
          self.itemId = iprot.readI64();
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 2:
7482 
        if ftype == TType.I64:
7483 
          self.warehouseId = iprot.readI64();
7484 
        else:
7485 
          iprot.skip(ftype)
7486 
      elif fid == 3:
7487 
        if ftype == TType.I64:
7488 
          self.quantity = iprot.readI64();
7489 
        else:
7490 
          iprot.skip(ftype)
7491 
      else:
7492 
        iprot.skip(ftype)
7493 
      iprot.readFieldEnd()
7494 
    iprot.readStructEnd()
7495 
 
7496 
  def write(self, oprot):
7497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7499 
      return
7500 
    oprot.writeStructBegin('addBadInventory_args')
7501 
    if self.itemId is not None:
7502 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7503 
      oprot.writeI64(self.itemId)
7504 
      oprot.writeFieldEnd()
7505 
    if self.warehouseId is not None:
7506 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7507 
      oprot.writeI64(self.warehouseId)
7508 
      oprot.writeFieldEnd()
7509 
    if self.quantity is not None:
7510 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
7511 
      oprot.writeI64(self.quantity)
7512 
      oprot.writeFieldEnd()
7513 
    oprot.writeFieldStop()
7514 
    oprot.writeStructEnd()
7515 
 
7516 
  def validate(self):
7517 
    return
7518 
 
7519 
 
7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
7531 
class addBadInventory_result:
7532 
  """
7533 
  Attributes:
7534 
   - cex
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    None, # 0
7539 
    (1, TType.STRUCT, 'cex', (InventoryServiceException, InventoryServiceException.thrift_spec), None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, cex=None,):
7543 
    self.cex = cex
7544 
 
7545 
  def read(self, iprot):
7546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7548 
      return
7549 
    iprot.readStructBegin()
7550 
    while True:
7551 
      (fname, ftype, fid) = iprot.readFieldBegin()
7552 
      if ftype == TType.STOP:
7553 
        break
7554 
      if fid == 1:
7555 
        if ftype == TType.STRUCT:
7556 
          self.cex = InventoryServiceException()
7557 
          self.cex.read(iprot)
7558 
        else:
7559 
          iprot.skip(ftype)
7560 
      else:
7561 
        iprot.skip(ftype)
7562 
      iprot.readFieldEnd()
7563 
    iprot.readStructEnd()
7564 
 
7565 
  def write(self, oprot):
7566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7568 
      return
7569 
    oprot.writeStructBegin('addBadInventory_result')
7570 
    if self.cex is not None:
7571 
      oprot.writeFieldBegin('cex', TType.STRUCT, 1)
7572 
      self.cex.write(oprot)
7573 
      oprot.writeFieldEnd()
7574 
    oprot.writeFieldStop()
7575 
    oprot.writeStructEnd()
7576 
 
7577 
  def validate(self):
7578 
    return
7579 
 
7580 
 
7581 
  def __repr__(self):
7582 
    L = ['%s=%r' % (key, value)
7583 
      for key, value in self.__dict__.iteritems()]
7584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7585 
 
7586 
  def __eq__(self, other):
7587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7588 
 
7589 
  def __ne__(self, other):
7590 
    return not (self == other)
7591 
 
7592 
class getShippingLocations_args:
7593 
 
7594 
  thrift_spec = (
7595 
  )
7596 
 
7597 
  def read(self, iprot):
7598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7600 
      return
7601 
    iprot.readStructBegin()
7602 
    while True:
7603 
      (fname, ftype, fid) = iprot.readFieldBegin()
7604 
      if ftype == TType.STOP:
7605 
        break
7606 
      else:
7607 
        iprot.skip(ftype)
7608 
      iprot.readFieldEnd()
7609 
    iprot.readStructEnd()
7610 
 
7611 
  def write(self, oprot):
7612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7614 
      return
7615 
    oprot.writeStructBegin('getShippingLocations_args')
7616 
    oprot.writeFieldStop()
7617 
    oprot.writeStructEnd()
7618 
 
7619 
  def validate(self):
7620 
    return
7621 
 
7622 
 
7623 
  def __repr__(self):
7624 
    L = ['%s=%r' % (key, value)
7625 
      for key, value in self.__dict__.iteritems()]
7626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7627 
 
7628 
  def __eq__(self, other):
7629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7630 
 
7631 
  def __ne__(self, other):
7632 
    return not (self == other)
7633 
 
7634 
class getShippingLocations_result:
7635 
  """
7636 
  Attributes:
7637 
   - success
7638 
  """
7639 
 
7640 
  thrift_spec = (
7641 
    (0, TType.LIST, 'success', (TType.STRUCT,(Warehouse, Warehouse.thrift_spec)), None, ), # 0
7642 
  )
7643 
 
7644 
  def __init__(self, success=None,):
7645 
    self.success = success
7646 
 
7647 
  def read(self, iprot):
7648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7650 
      return
7651 
    iprot.readStructBegin()
7652 
    while True:
7653 
      (fname, ftype, fid) = iprot.readFieldBegin()
7654 
      if ftype == TType.STOP:
7655 
        break
7656 
      if fid == 0:
7657 
        if ftype == TType.LIST:
7658 
          self.success = []
8182 amar.kumar 7659 
          (_etype129, _size126) = iprot.readListBegin()
7660 
          for _i130 in xrange(_size126):
7661 
            _elem131 = Warehouse()
7662 
            _elem131.read(iprot)
7663 
            self.success.append(_elem131)
5944 mandeep.dh 7664 
          iprot.readListEnd()
7665 
        else:
7666 
          iprot.skip(ftype)
7667 
      else:
7668 
        iprot.skip(ftype)
7669 
      iprot.readFieldEnd()
7670 
    iprot.readStructEnd()
7671 
 
7672 
  def write(self, oprot):
7673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7675 
      return
7676 
    oprot.writeStructBegin('getShippingLocations_result')
7677 
    if self.success is not None:
7678 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7679 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7680 
      for iter132 in self.success:
7681 
        iter132.write(oprot)
5944 mandeep.dh 7682 
      oprot.writeListEnd()
7683 
      oprot.writeFieldEnd()
7684 
    oprot.writeFieldStop()
7685 
    oprot.writeStructEnd()
7686 
 
7687 
  def validate(self):
7688 
    return
7689 
 
7690 
 
7691 
  def __repr__(self):
7692 
    L = ['%s=%r' % (key, value)
7693 
      for key, value in self.__dict__.iteritems()]
7694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7695 
 
7696 
  def __eq__(self, other):
7697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7698 
 
7699 
  def __ne__(self, other):
7700 
    return not (self == other)
7701 
 
7702 
class getAllVendorItemMappings_args:
7703 
 
7704 
  thrift_spec = (
7705 
  )
7706 
 
7707 
  def read(self, iprot):
7708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7710 
      return
7711 
    iprot.readStructBegin()
7712 
    while True:
7713 
      (fname, ftype, fid) = iprot.readFieldBegin()
7714 
      if ftype == TType.STOP:
7715 
        break
7716 
      else:
7717 
        iprot.skip(ftype)
7718 
      iprot.readFieldEnd()
7719 
    iprot.readStructEnd()
7720 
 
7721 
  def write(self, oprot):
7722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7724 
      return
7725 
    oprot.writeStructBegin('getAllVendorItemMappings_args')
7726 
    oprot.writeFieldStop()
7727 
    oprot.writeStructEnd()
7728 
 
7729 
  def validate(self):
7730 
    return
7731 
 
7732 
 
7733 
  def __repr__(self):
7734 
    L = ['%s=%r' % (key, value)
7735 
      for key, value in self.__dict__.iteritems()]
7736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7737 
 
7738 
  def __eq__(self, other):
7739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7740 
 
7741 
  def __ne__(self, other):
7742 
    return not (self == other)
7743 
 
7744 
class getAllVendorItemMappings_result:
7745 
  """
7746 
  Attributes:
7747 
   - success
7748 
  """
7749 
 
7750 
  thrift_spec = (
7751 
    (0, TType.LIST, 'success', (TType.STRUCT,(VendorItemMapping, VendorItemMapping.thrift_spec)), None, ), # 0
7752 
  )
7753 
 
7754 
  def __init__(self, success=None,):
7755 
    self.success = success
7756 
 
7757 
  def read(self, iprot):
7758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7760 
      return
7761 
    iprot.readStructBegin()
7762 
    while True:
7763 
      (fname, ftype, fid) = iprot.readFieldBegin()
7764 
      if ftype == TType.STOP:
7765 
        break
7766 
      if fid == 0:
7767 
        if ftype == TType.LIST:
7768 
          self.success = []
8182 amar.kumar 7769 
          (_etype136, _size133) = iprot.readListBegin()
7770 
          for _i137 in xrange(_size133):
7771 
            _elem138 = VendorItemMapping()
7772 
            _elem138.read(iprot)
7773 
            self.success.append(_elem138)
5944 mandeep.dh 7774 
          iprot.readListEnd()
7775 
        else:
7776 
          iprot.skip(ftype)
7777 
      else:
7778 
        iprot.skip(ftype)
7779 
      iprot.readFieldEnd()
7780 
    iprot.readStructEnd()
7781 
 
7782 
  def write(self, oprot):
7783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7785 
      return
7786 
    oprot.writeStructBegin('getAllVendorItemMappings_result')
7787 
    if self.success is not None:
7788 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7789 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 7790 
      for iter139 in self.success:
7791 
        iter139.write(oprot)
5944 mandeep.dh 7792 
      oprot.writeListEnd()
7793 
      oprot.writeFieldEnd()
7794 
    oprot.writeFieldStop()
7795 
    oprot.writeStructEnd()
7796 
 
7797 
  def validate(self):
7798 
    return
7799 
 
7800 
 
7801 
  def __repr__(self):
7802 
    L = ['%s=%r' % (key, value)
7803 
      for key, value in self.__dict__.iteritems()]
7804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7805 
 
7806 
  def __eq__(self, other):
7807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7808 
 
7809 
  def __ne__(self, other):
7810 
    return not (self == other)
7811 
 
7812 
class getInventorySnapshot_args:
7813 
  """
7814 
  Attributes:
7815 
   - warehouseId
7816 
  """
7817 
 
7818 
  thrift_spec = (
7819 
    None, # 0
7820 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
7821 
  )
7822 
 
7823 
  def __init__(self, warehouseId=None,):
7824 
    self.warehouseId = warehouseId
7825 
 
7826 
  def read(self, iprot):
7827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7829 
      return
7830 
    iprot.readStructBegin()
7831 
    while True:
7832 
      (fname, ftype, fid) = iprot.readFieldBegin()
7833 
      if ftype == TType.STOP:
7834 
        break
7835 
      if fid == 1:
7836 
        if ftype == TType.I64:
7837 
          self.warehouseId = iprot.readI64();
7838 
        else:
7839 
          iprot.skip(ftype)
7840 
      else:
7841 
        iprot.skip(ftype)
7842 
      iprot.readFieldEnd()
7843 
    iprot.readStructEnd()
7844 
 
7845 
  def write(self, oprot):
7846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7848 
      return
7849 
    oprot.writeStructBegin('getInventorySnapshot_args')
7850 
    if self.warehouseId is not None:
7851 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
7852 
      oprot.writeI64(self.warehouseId)
7853 
      oprot.writeFieldEnd()
7854 
    oprot.writeFieldStop()
7855 
    oprot.writeStructEnd()
7856 
 
7857 
  def validate(self):
7858 
    return
7859 
 
7860 
 
7861 
  def __repr__(self):
7862 
    L = ['%s=%r' % (key, value)
7863 
      for key, value in self.__dict__.iteritems()]
7864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7865 
 
7866 
  def __eq__(self, other):
7867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7868 
 
7869 
  def __ne__(self, other):
7870 
    return not (self == other)
7871 
 
7872 
class getInventorySnapshot_result:
7873 
  """
7874 
  Attributes:
7875 
   - success
7876 
  """
7877 
 
7878 
  thrift_spec = (
7879 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRUCT,(ItemInventory, ItemInventory.thrift_spec)), None, ), # 0
7880 
  )
7881 
 
7882 
  def __init__(self, success=None,):
7883 
    self.success = success
7884 
 
7885 
  def read(self, iprot):
7886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7888 
      return
7889 
    iprot.readStructBegin()
7890 
    while True:
7891 
      (fname, ftype, fid) = iprot.readFieldBegin()
7892 
      if ftype == TType.STOP:
7893 
        break
7894 
      if fid == 0:
7895 
        if ftype == TType.MAP:
7896 
          self.success = {}
8182 amar.kumar 7897 
          (_ktype141, _vtype142, _size140 ) = iprot.readMapBegin()
7898 
          for _i144 in xrange(_size140):
7899 
            _key145 = iprot.readI64();
7900 
            _val146 = ItemInventory()
7901 
            _val146.read(iprot)
7902 
            self.success[_key145] = _val146
5944 mandeep.dh 7903 
          iprot.readMapEnd()
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      else:
7907 
        iprot.skip(ftype)
7908 
      iprot.readFieldEnd()
7909 
    iprot.readStructEnd()
7910 
 
7911 
  def write(self, oprot):
7912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7914 
      return
7915 
    oprot.writeStructBegin('getInventorySnapshot_result')
7916 
    if self.success is not None:
7917 
      oprot.writeFieldBegin('success', TType.MAP, 0)
7918 
      oprot.writeMapBegin(TType.I64, TType.STRUCT, len(self.success))
8182 amar.kumar 7919 
      for kiter147,viter148 in self.success.items():
7920 
        oprot.writeI64(kiter147)
7921 
        viter148.write(oprot)
5944 mandeep.dh 7922 
      oprot.writeMapEnd()
7923 
      oprot.writeFieldEnd()
7924 
    oprot.writeFieldStop()
7925 
    oprot.writeStructEnd()
7926 
 
7927 
  def validate(self):
7928 
    return
7929 
 
7930 
 
7931 
  def __repr__(self):
7932 
    L = ['%s=%r' % (key, value)
7933 
      for key, value in self.__dict__.iteritems()]
7934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7935 
 
7936 
  def __eq__(self, other):
7937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7938 
 
7939 
  def __ne__(self, other):
7940 
    return not (self == other)
7941 
 
7942 
class clearItemAvailabilityCache_args:
7943 
 
7944 
  thrift_spec = (
7945 
  )
7946 
 
7947 
  def read(self, iprot):
7948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7950 
      return
7951 
    iprot.readStructBegin()
7952 
    while True:
7953 
      (fname, ftype, fid) = iprot.readFieldBegin()
7954 
      if ftype == TType.STOP:
7955 
        break
7956 
      else:
7957 
        iprot.skip(ftype)
7958 
      iprot.readFieldEnd()
7959 
    iprot.readStructEnd()
7960 
 
7961 
  def write(self, oprot):
7962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7964 
      return
7965 
    oprot.writeStructBegin('clearItemAvailabilityCache_args')
7966 
    oprot.writeFieldStop()
7967 
    oprot.writeStructEnd()
7968 
 
7969 
  def validate(self):
7970 
    return
7971 
 
7972 
 
7973 
  def __repr__(self):
7974 
    L = ['%s=%r' % (key, value)
7975 
      for key, value in self.__dict__.iteritems()]
7976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7977 
 
7978 
  def __eq__(self, other):
7979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7980 
 
7981 
  def __ne__(self, other):
7982 
    return not (self == other)
7983 
 
7984 
class clearItemAvailabilityCache_result:
7985 
 
7986 
  thrift_spec = (
7987 
  )
7988 
 
7989 
  def read(self, iprot):
7990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7992 
      return
7993 
    iprot.readStructBegin()
7994 
    while True:
7995 
      (fname, ftype, fid) = iprot.readFieldBegin()
7996 
      if ftype == TType.STOP:
7997 
        break
7998 
      else:
7999 
        iprot.skip(ftype)
8000 
      iprot.readFieldEnd()
8001 
    iprot.readStructEnd()
8002 
 
8003 
  def write(self, oprot):
8004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8006 
      return
8007 
    oprot.writeStructBegin('clearItemAvailabilityCache_result')
8008 
    oprot.writeFieldStop()
8009 
    oprot.writeStructEnd()
8010 
 
8011 
  def validate(self):
8012 
    return
8013 
 
8014 
 
8015 
  def __repr__(self):
8016 
    L = ['%s=%r' % (key, value)
8017 
      for key, value in self.__dict__.iteritems()]
8018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8019 
 
8020 
  def __eq__(self, other):
8021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8022 
 
8023 
  def __ne__(self, other):
8024 
    return not (self == other)
8025 
 
8026 
class updateVendorString_args:
8027 
  """
8028 
  Attributes:
8029 
   - warehouseId
8030 
   - vendorString
8031 
  """
8032 
 
8033 
  thrift_spec = (
8034 
    None, # 0
8035 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8036 
    (2, TType.STRING, 'vendorString', None, None, ), # 2
8037 
  )
8038 
 
8039 
  def __init__(self, warehouseId=None, vendorString=None,):
8040 
    self.warehouseId = warehouseId
8041 
    self.vendorString = vendorString
8042 
 
8043 
  def read(self, iprot):
8044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8046 
      return
8047 
    iprot.readStructBegin()
8048 
    while True:
8049 
      (fname, ftype, fid) = iprot.readFieldBegin()
8050 
      if ftype == TType.STOP:
8051 
        break
8052 
      if fid == 1:
8053 
        if ftype == TType.I64:
8054 
          self.warehouseId = iprot.readI64();
8055 
        else:
8056 
          iprot.skip(ftype)
8057 
      elif fid == 2:
8058 
        if ftype == TType.STRING:
8059 
          self.vendorString = iprot.readString();
8060 
        else:
8061 
          iprot.skip(ftype)
8062 
      else:
8063 
        iprot.skip(ftype)
8064 
      iprot.readFieldEnd()
8065 
    iprot.readStructEnd()
8066 
 
8067 
  def write(self, oprot):
8068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8070 
      return
8071 
    oprot.writeStructBegin('updateVendorString_args')
8072 
    if self.warehouseId is not None:
8073 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8074 
      oprot.writeI64(self.warehouseId)
8075 
      oprot.writeFieldEnd()
8076 
    if self.vendorString is not None:
8077 
      oprot.writeFieldBegin('vendorString', TType.STRING, 2)
8078 
      oprot.writeString(self.vendorString)
8079 
      oprot.writeFieldEnd()
8080 
    oprot.writeFieldStop()
8081 
    oprot.writeStructEnd()
8082 
 
8083 
  def validate(self):
8084 
    return
8085 
 
8086 
 
8087 
  def __repr__(self):
8088 
    L = ['%s=%r' % (key, value)
8089 
      for key, value in self.__dict__.iteritems()]
8090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8091 
 
8092 
  def __eq__(self, other):
8093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8094 
 
8095 
  def __ne__(self, other):
8096 
    return not (self == other)
8097 
 
8098 
class updateVendorString_result:
8099 
 
8100 
  thrift_spec = (
8101 
  )
8102 
 
8103 
  def read(self, iprot):
8104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8106 
      return
8107 
    iprot.readStructBegin()
8108 
    while True:
8109 
      (fname, ftype, fid) = iprot.readFieldBegin()
8110 
      if ftype == TType.STOP:
8111 
        break
8112 
      else:
8113 
        iprot.skip(ftype)
8114 
      iprot.readFieldEnd()
8115 
    iprot.readStructEnd()
8116 
 
8117 
  def write(self, oprot):
8118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8120 
      return
8121 
    oprot.writeStructBegin('updateVendorString_result')
8122 
    oprot.writeFieldStop()
8123 
    oprot.writeStructEnd()
8124 
 
8125 
  def validate(self):
8126 
    return
8127 
 
8128 
 
8129 
  def __repr__(self):
8130 
    L = ['%s=%r' % (key, value)
8131 
      for key, value in self.__dict__.iteritems()]
8132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8133 
 
8134 
  def __eq__(self, other):
8135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8136 
 
8137 
  def __ne__(self, other):
8138 
    return not (self == other)
6096 amit.gupta 8139 
 
8140 
class clearItemAvailabilityCacheForItem_args:
8141 
  """
8142 
  Attributes:
8143 
   - item_id
8144 
  """
8145 
 
8146 
  thrift_spec = (
8147 
    None, # 0
8148 
    (1, TType.I64, 'item_id', None, None, ), # 1
8149 
  )
8150 
 
8151 
  def __init__(self, item_id=None,):
8152 
    self.item_id = item_id
8153 
 
8154 
  def read(self, iprot):
8155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8157 
      return
8158 
    iprot.readStructBegin()
8159 
    while True:
8160 
      (fname, ftype, fid) = iprot.readFieldBegin()
8161 
      if ftype == TType.STOP:
8162 
        break
8163 
      if fid == 1:
8164 
        if ftype == TType.I64:
8165 
          self.item_id = iprot.readI64();
8166 
        else:
8167 
          iprot.skip(ftype)
8168 
      else:
8169 
        iprot.skip(ftype)
8170 
      iprot.readFieldEnd()
8171 
    iprot.readStructEnd()
8172 
 
8173 
  def write(self, oprot):
8174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8176 
      return
8177 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_args')
8178 
    if self.item_id is not None:
8179 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8180 
      oprot.writeI64(self.item_id)
8181 
      oprot.writeFieldEnd()
8182 
    oprot.writeFieldStop()
8183 
    oprot.writeStructEnd()
8184 
 
8185 
  def validate(self):
8186 
    return
8187 
 
8188 
 
8189 
  def __repr__(self):
8190 
    L = ['%s=%r' % (key, value)
8191 
      for key, value in self.__dict__.iteritems()]
8192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8193 
 
8194 
  def __eq__(self, other):
8195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8196 
 
8197 
  def __ne__(self, other):
8198 
    return not (self == other)
8199 
 
8200 
class clearItemAvailabilityCacheForItem_result:
8201 
 
8202 
  thrift_spec = (
8203 
  )
8204 
 
8205 
  def read(self, iprot):
8206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8208 
      return
8209 
    iprot.readStructBegin()
8210 
    while True:
8211 
      (fname, ftype, fid) = iprot.readFieldBegin()
8212 
      if ftype == TType.STOP:
8213 
        break
8214 
      else:
8215 
        iprot.skip(ftype)
8216 
      iprot.readFieldEnd()
8217 
    iprot.readStructEnd()
8218 
 
8219 
  def write(self, oprot):
8220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8222 
      return
8223 
    oprot.writeStructBegin('clearItemAvailabilityCacheForItem_result')
8224 
    oprot.writeFieldStop()
8225 
    oprot.writeStructEnd()
8226 
 
8227 
  def validate(self):
8228 
    return
8229 
 
8230 
 
8231 
  def __repr__(self):
8232 
    L = ['%s=%r' % (key, value)
8233 
      for key, value in self.__dict__.iteritems()]
8234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8235 
 
8236 
  def __eq__(self, other):
8237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8238 
 
8239 
  def __ne__(self, other):
8240 
    return not (self == other)
6467 amar.kumar 8241 
 
8242 
class getOurWarehouseIdForVendor_args:
8243 
  """
8244 
  Attributes:
8245 
   - vendorId
7718 amar.kumar 8246 
   - billingWarehouseId
6467 amar.kumar 8247 
  """
8248 
 
8249 
  thrift_spec = (
8250 
    None, # 0
8251 
    (1, TType.I64, 'vendorId', None, None, ), # 1
7718 amar.kumar 8252 
    (2, TType.I64, 'billingWarehouseId', None, None, ), # 2
6467 amar.kumar 8253 
  )
8254 
 
7718 amar.kumar 8255 
  def __init__(self, vendorId=None, billingWarehouseId=None,):
6467 amar.kumar 8256 
    self.vendorId = vendorId
7718 amar.kumar 8257 
    self.billingWarehouseId = billingWarehouseId
6467 amar.kumar 8258 
 
8259 
  def read(self, iprot):
8260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8262 
      return
8263 
    iprot.readStructBegin()
8264 
    while True:
8265 
      (fname, ftype, fid) = iprot.readFieldBegin()
8266 
      if ftype == TType.STOP:
8267 
        break
8268 
      if fid == 1:
8269 
        if ftype == TType.I64:
8270 
          self.vendorId = iprot.readI64();
8271 
        else:
8272 
          iprot.skip(ftype)
7718 amar.kumar 8273 
      elif fid == 2:
8274 
        if ftype == TType.I64:
8275 
          self.billingWarehouseId = iprot.readI64();
8276 
        else:
8277 
          iprot.skip(ftype)
6467 amar.kumar 8278 
      else:
8279 
        iprot.skip(ftype)
8280 
      iprot.readFieldEnd()
8281 
    iprot.readStructEnd()
8282 
 
8283 
  def write(self, oprot):
8284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8286 
      return
8287 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_args')
8288 
    if self.vendorId is not None:
8289 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
8290 
      oprot.writeI64(self.vendorId)
8291 
      oprot.writeFieldEnd()
7718 amar.kumar 8292 
    if self.billingWarehouseId is not None:
8293 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 2)
8294 
      oprot.writeI64(self.billingWarehouseId)
8295 
      oprot.writeFieldEnd()
6467 amar.kumar 8296 
    oprot.writeFieldStop()
8297 
    oprot.writeStructEnd()
8298 
 
8299 
  def validate(self):
8300 
    return
8301 
 
8302 
 
8303 
  def __repr__(self):
8304 
    L = ['%s=%r' % (key, value)
8305 
      for key, value in self.__dict__.iteritems()]
8306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8307 
 
8308 
  def __eq__(self, other):
8309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8310 
 
8311 
  def __ne__(self, other):
8312 
    return not (self == other)
8313 
 
8314 
class getOurWarehouseIdForVendor_result:
8315 
  """
8316 
  Attributes:
8317 
   - success
8318 
  """
8319 
 
8320 
  thrift_spec = (
8321 
    (0, TType.I64, 'success', None, None, ), # 0
8322 
  )
8323 
 
8324 
  def __init__(self, success=None,):
8325 
    self.success = success
8326 
 
8327 
  def read(self, iprot):
8328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8330 
      return
8331 
    iprot.readStructBegin()
8332 
    while True:
8333 
      (fname, ftype, fid) = iprot.readFieldBegin()
8334 
      if ftype == TType.STOP:
8335 
        break
8336 
      if fid == 0:
8337 
        if ftype == TType.I64:
8338 
          self.success = iprot.readI64();
8339 
        else:
8340 
          iprot.skip(ftype)
8341 
      else:
8342 
        iprot.skip(ftype)
8343 
      iprot.readFieldEnd()
8344 
    iprot.readStructEnd()
8345 
 
8346 
  def write(self, oprot):
8347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8349 
      return
8350 
    oprot.writeStructBegin('getOurWarehouseIdForVendor_result')
8351 
    if self.success is not None:
8352 
      oprot.writeFieldBegin('success', TType.I64, 0)
8353 
      oprot.writeI64(self.success)
8354 
      oprot.writeFieldEnd()
8355 
    oprot.writeFieldStop()
8356 
    oprot.writeStructEnd()
8357 
 
8358 
  def validate(self):
8359 
    return
8360 
 
8361 
 
8362 
  def __repr__(self):
8363 
    L = ['%s=%r' % (key, value)
8364 
      for key, value in self.__dict__.iteritems()]
8365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8366 
 
8367 
  def __eq__(self, other):
8368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8369 
 
8370 
  def __ne__(self, other):
8371 
    return not (self == other)
6484 amar.kumar 8372 
 
8373 
class getItemAvailabilitiesAtOurWarehouses_args:
8374 
  """
8375 
  Attributes:
8376 
   - item_ids
8377 
  """
8378 
 
8379 
  thrift_spec = (
8380 
    None, # 0
8381 
    (1, TType.LIST, 'item_ids', (TType.I64,None), None, ), # 1
8382 
  )
8383 
 
8384 
  def __init__(self, item_ids=None,):
8385 
    self.item_ids = item_ids
8386 
 
8387 
  def read(self, iprot):
8388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8390 
      return
8391 
    iprot.readStructBegin()
8392 
    while True:
8393 
      (fname, ftype, fid) = iprot.readFieldBegin()
8394 
      if ftype == TType.STOP:
8395 
        break
8396 
      if fid == 1:
8397 
        if ftype == TType.LIST:
8398 
          self.item_ids = []
8182 amar.kumar 8399 
          (_etype152, _size149) = iprot.readListBegin()
8400 
          for _i153 in xrange(_size149):
8401 
            _elem154 = iprot.readI64();
8402 
            self.item_ids.append(_elem154)
6484 amar.kumar 8403 
          iprot.readListEnd()
8404 
        else:
8405 
          iprot.skip(ftype)
8406 
      else:
8407 
        iprot.skip(ftype)
8408 
      iprot.readFieldEnd()
8409 
    iprot.readStructEnd()
8410 
 
8411 
  def write(self, oprot):
8412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8414 
      return
8415 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_args')
8416 
    if self.item_ids is not None:
8417 
      oprot.writeFieldBegin('item_ids', TType.LIST, 1)
8418 
      oprot.writeListBegin(TType.I64, len(self.item_ids))
8182 amar.kumar 8419 
      for iter155 in self.item_ids:
8420 
        oprot.writeI64(iter155)
6484 amar.kumar 8421 
      oprot.writeListEnd()
8422 
      oprot.writeFieldEnd()
8423 
    oprot.writeFieldStop()
8424 
    oprot.writeStructEnd()
8425 
 
8426 
  def validate(self):
8427 
    return
8428 
 
8429 
 
8430 
  def __repr__(self):
8431 
    L = ['%s=%r' % (key, value)
8432 
      for key, value in self.__dict__.iteritems()]
8433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8434 
 
8435 
  def __eq__(self, other):
8436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8437 
 
8438 
  def __ne__(self, other):
8439 
    return not (self == other)
8440 
 
8441 
class getItemAvailabilitiesAtOurWarehouses_result:
8442 
  """
8443 
  Attributes:
8444 
   - success
8445 
  """
8446 
 
8447 
  thrift_spec = (
8448 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
8449 
  )
8450 
 
8451 
  def __init__(self, success=None,):
8452 
    self.success = success
8453 
 
8454 
  def read(self, iprot):
8455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8457 
      return
8458 
    iprot.readStructBegin()
8459 
    while True:
8460 
      (fname, ftype, fid) = iprot.readFieldBegin()
8461 
      if ftype == TType.STOP:
8462 
        break
8463 
      if fid == 0:
8464 
        if ftype == TType.MAP:
8465 
          self.success = {}
8182 amar.kumar 8466 
          (_ktype157, _vtype158, _size156 ) = iprot.readMapBegin()
8467 
          for _i160 in xrange(_size156):
8468 
            _key161 = iprot.readI64();
8469 
            _val162 = iprot.readI64();
8470 
            self.success[_key161] = _val162
6484 amar.kumar 8471 
          iprot.readMapEnd()
8472 
        else:
8473 
          iprot.skip(ftype)
8474 
      else:
8475 
        iprot.skip(ftype)
8476 
      iprot.readFieldEnd()
8477 
    iprot.readStructEnd()
8478 
 
8479 
  def write(self, oprot):
8480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8482 
      return
8483 
    oprot.writeStructBegin('getItemAvailabilitiesAtOurWarehouses_result')
8484 
    if self.success is not None:
8485 
      oprot.writeFieldBegin('success', TType.MAP, 0)
8486 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
8182 amar.kumar 8487 
      for kiter163,viter164 in self.success.items():
8488 
        oprot.writeI64(kiter163)
8489 
        oprot.writeI64(viter164)
6484 amar.kumar 8490 
      oprot.writeMapEnd()
8491 
      oprot.writeFieldEnd()
8492 
    oprot.writeFieldStop()
8493 
    oprot.writeStructEnd()
8494 
 
8495 
  def validate(self):
8496 
    return
8497 
 
8498 
 
8499 
  def __repr__(self):
8500 
    L = ['%s=%r' % (key, value)
8501 
      for key, value in self.__dict__.iteritems()]
8502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8503 
 
8504 
  def __eq__(self, other):
8505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8506 
 
8507 
  def __ne__(self, other):
8508 
    return not (self == other)
6531 vikram.rag 8509 
 
8510 
class getMonitoredWarehouseForVendors_args:
8511 
  """
8512 
  Attributes:
8513 
   - vendorIds
8514 
  """
8515 
 
8516 
  thrift_spec = (
8517 
    None, # 0
8518 
    (1, TType.LIST, 'vendorIds', (TType.I64,None), None, ), # 1
8519 
  )
8520 
 
8521 
  def __init__(self, vendorIds=None,):
8522 
    self.vendorIds = vendorIds
8523 
 
8524 
  def read(self, iprot):
8525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8527 
      return
8528 
    iprot.readStructBegin()
8529 
    while True:
8530 
      (fname, ftype, fid) = iprot.readFieldBegin()
8531 
      if ftype == TType.STOP:
8532 
        break
8533 
      if fid == 1:
8534 
        if ftype == TType.LIST:
8535 
          self.vendorIds = []
8182 amar.kumar 8536 
          (_etype168, _size165) = iprot.readListBegin()
8537 
          for _i169 in xrange(_size165):
8538 
            _elem170 = iprot.readI64();
8539 
            self.vendorIds.append(_elem170)
6531 vikram.rag 8540 
          iprot.readListEnd()
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      else:
8544 
        iprot.skip(ftype)
8545 
      iprot.readFieldEnd()
8546 
    iprot.readStructEnd()
8547 
 
8548 
  def write(self, oprot):
8549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8551 
      return
8552 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_args')
8553 
    if self.vendorIds is not None:
8554 
      oprot.writeFieldBegin('vendorIds', TType.LIST, 1)
8555 
      oprot.writeListBegin(TType.I64, len(self.vendorIds))
8182 amar.kumar 8556 
      for iter171 in self.vendorIds:
8557 
        oprot.writeI64(iter171)
6531 vikram.rag 8558 
      oprot.writeListEnd()
8559 
      oprot.writeFieldEnd()
8560 
    oprot.writeFieldStop()
8561 
    oprot.writeStructEnd()
8562 
 
8563 
  def validate(self):
8564 
    return
8565 
 
8566 
 
8567 
  def __repr__(self):
8568 
    L = ['%s=%r' % (key, value)
8569 
      for key, value in self.__dict__.iteritems()]
8570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8571 
 
8572 
  def __eq__(self, other):
8573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8574 
 
8575 
  def __ne__(self, other):
8576 
    return not (self == other)
8577 
 
8578 
class getMonitoredWarehouseForVendors_result:
8579 
  """
8580 
  Attributes:
8581 
   - success
8582 
  """
8583 
 
8584 
  thrift_spec = (
8585 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
8586 
  )
8587 
 
8588 
  def __init__(self, success=None,):
8589 
    self.success = success
8590 
 
8591 
  def read(self, iprot):
8592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8594 
      return
8595 
    iprot.readStructBegin()
8596 
    while True:
8597 
      (fname, ftype, fid) = iprot.readFieldBegin()
8598 
      if ftype == TType.STOP:
8599 
        break
8600 
      if fid == 0:
8601 
        if ftype == TType.LIST:
8602 
          self.success = []
8182 amar.kumar 8603 
          (_etype175, _size172) = iprot.readListBegin()
8604 
          for _i176 in xrange(_size172):
8605 
            _elem177 = iprot.readI64();
8606 
            self.success.append(_elem177)
6531 vikram.rag 8607 
          iprot.readListEnd()
8608 
        else:
8609 
          iprot.skip(ftype)
8610 
      else:
8611 
        iprot.skip(ftype)
8612 
      iprot.readFieldEnd()
8613 
    iprot.readStructEnd()
8614 
 
8615 
  def write(self, oprot):
8616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8618 
      return
8619 
    oprot.writeStructBegin('getMonitoredWarehouseForVendors_result')
8620 
    if self.success is not None:
8621 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8622 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 8623 
      for iter178 in self.success:
8624 
        oprot.writeI64(iter178)
6531 vikram.rag 8625 
      oprot.writeListEnd()
8626 
      oprot.writeFieldEnd()
8627 
    oprot.writeFieldStop()
8628 
    oprot.writeStructEnd()
8629 
 
8630 
  def validate(self):
8631 
    return
8632 
 
8633 
 
8634 
  def __repr__(self):
8635 
    L = ['%s=%r' % (key, value)
8636 
      for key, value in self.__dict__.iteritems()]
8637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8638 
 
8639 
  def __eq__(self, other):
8640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8641 
 
8642 
  def __ne__(self, other):
8643 
    return not (self == other)
8644 
 
8645 
class getIgnoredWarehouseidsAndItemids_args:
8646 
 
8647 
  thrift_spec = (
8648 
  )
8649 
 
8650 
  def read(self, iprot):
8651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8653 
      return
8654 
    iprot.readStructBegin()
8655 
    while True:
8656 
      (fname, ftype, fid) = iprot.readFieldBegin()
8657 
      if ftype == TType.STOP:
8658 
        break
8659 
      else:
8660 
        iprot.skip(ftype)
8661 
      iprot.readFieldEnd()
8662 
    iprot.readStructEnd()
8663 
 
8664 
  def write(self, oprot):
8665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8667 
      return
8668 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_args')
8669 
    oprot.writeFieldStop()
8670 
    oprot.writeStructEnd()
8671 
 
8672 
  def validate(self):
8673 
    return
8674 
 
8675 
 
8676 
  def __repr__(self):
8677 
    L = ['%s=%r' % (key, value)
8678 
      for key, value in self.__dict__.iteritems()]
8679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8680 
 
8681 
  def __eq__(self, other):
8682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8683 
 
8684 
  def __ne__(self, other):
8685 
    return not (self == other)
8686 
 
8687 
class getIgnoredWarehouseidsAndItemids_result:
8688 
  """
8689 
  Attributes:
8690 
   - success
8691 
  """
8692 
 
8693 
  thrift_spec = (
8694 
    (0, TType.LIST, 'success', (TType.STRUCT,(IgnoredInventoryUpdateItems, IgnoredInventoryUpdateItems.thrift_spec)), None, ), # 0
8695 
  )
8696 
 
8697 
  def __init__(self, success=None,):
8698 
    self.success = success
8699 
 
8700 
  def read(self, iprot):
8701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8703 
      return
8704 
    iprot.readStructBegin()
8705 
    while True:
8706 
      (fname, ftype, fid) = iprot.readFieldBegin()
8707 
      if ftype == TType.STOP:
8708 
        break
8709 
      if fid == 0:
8710 
        if ftype == TType.LIST:
8711 
          self.success = []
8182 amar.kumar 8712 
          (_etype182, _size179) = iprot.readListBegin()
8713 
          for _i183 in xrange(_size179):
8714 
            _elem184 = IgnoredInventoryUpdateItems()
8715 
            _elem184.read(iprot)
8716 
            self.success.append(_elem184)
6531 vikram.rag 8717 
          iprot.readListEnd()
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      else:
8721 
        iprot.skip(ftype)
8722 
      iprot.readFieldEnd()
8723 
    iprot.readStructEnd()
8724 
 
8725 
  def write(self, oprot):
8726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8728 
      return
8729 
    oprot.writeStructBegin('getIgnoredWarehouseidsAndItemids_result')
8730 
    if self.success is not None:
8731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8732 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 8733 
      for iter185 in self.success:
8734 
        iter185.write(oprot)
6531 vikram.rag 8735 
      oprot.writeListEnd()
8736 
      oprot.writeFieldEnd()
8737 
    oprot.writeFieldStop()
8738 
    oprot.writeStructEnd()
8739 
 
8740 
  def validate(self):
8741 
    return
8742 
 
8743 
 
8744 
  def __repr__(self):
8745 
    L = ['%s=%r' % (key, value)
8746 
      for key, value in self.__dict__.iteritems()]
8747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8748 
 
8749 
  def __eq__(self, other):
8750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8751 
 
8752 
  def __ne__(self, other):
8753 
    return not (self == other)
8754 
 
8755 
class insertItemtoIgnoreInventoryUpdatelist_args:
8756 
  """
8757 
  Attributes:
8758 
   - item_id
8759 
   - warehouse_id
8760 
  """
8761 
 
8762 
  thrift_spec = (
8763 
    None, # 0
8764 
    (1, TType.I64, 'item_id', None, None, ), # 1
8765 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
8766 
  )
8767 
 
8768 
  def __init__(self, item_id=None, warehouse_id=None,):
8769 
    self.item_id = item_id
8770 
    self.warehouse_id = warehouse_id
8771 
 
8772 
  def read(self, iprot):
8773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8775 
      return
8776 
    iprot.readStructBegin()
8777 
    while True:
8778 
      (fname, ftype, fid) = iprot.readFieldBegin()
8779 
      if ftype == TType.STOP:
8780 
        break
8781 
      if fid == 1:
8782 
        if ftype == TType.I64:
8783 
          self.item_id = iprot.readI64();
8784 
        else:
8785 
          iprot.skip(ftype)
8786 
      elif fid == 2:
8787 
        if ftype == TType.I64:
8788 
          self.warehouse_id = iprot.readI64();
8789 
        else:
8790 
          iprot.skip(ftype)
8791 
      else:
8792 
        iprot.skip(ftype)
8793 
      iprot.readFieldEnd()
8794 
    iprot.readStructEnd()
8795 
 
8796 
  def write(self, oprot):
8797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8799 
      return
8800 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_args')
8801 
    if self.item_id is not None:
8802 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8803 
      oprot.writeI64(self.item_id)
8804 
      oprot.writeFieldEnd()
8805 
    if self.warehouse_id is not None:
8806 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
8807 
      oprot.writeI64(self.warehouse_id)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
8812 
  def validate(self):
8813 
    return
8814 
 
8815 
 
8816 
  def __repr__(self):
8817 
    L = ['%s=%r' % (key, value)
8818 
      for key, value in self.__dict__.iteritems()]
8819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8820 
 
8821 
  def __eq__(self, other):
8822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8823 
 
8824 
  def __ne__(self, other):
8825 
    return not (self == other)
8826 
 
8827 
class insertItemtoIgnoreInventoryUpdatelist_result:
8828 
  """
8829 
  Attributes:
8830 
   - success
8831 
  """
8832 
 
8833 
  thrift_spec = (
8834 
    (0, TType.BOOL, 'success', None, None, ), # 0
8835 
  )
8836 
 
8837 
  def __init__(self, success=None,):
8838 
    self.success = success
8839 
 
8840 
  def read(self, iprot):
8841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8843 
      return
8844 
    iprot.readStructBegin()
8845 
    while True:
8846 
      (fname, ftype, fid) = iprot.readFieldBegin()
8847 
      if ftype == TType.STOP:
8848 
        break
8849 
      if fid == 0:
8850 
        if ftype == TType.BOOL:
8851 
          self.success = iprot.readBool();
8852 
        else:
8853 
          iprot.skip(ftype)
8854 
      else:
8855 
        iprot.skip(ftype)
8856 
      iprot.readFieldEnd()
8857 
    iprot.readStructEnd()
8858 
 
8859 
  def write(self, oprot):
8860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8862 
      return
8863 
    oprot.writeStructBegin('insertItemtoIgnoreInventoryUpdatelist_result')
8864 
    if self.success is not None:
8865 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8866 
      oprot.writeBool(self.success)
8867 
      oprot.writeFieldEnd()
8868 
    oprot.writeFieldStop()
8869 
    oprot.writeStructEnd()
8870 
 
8871 
  def validate(self):
8872 
    return
8873 
 
8874 
 
8875 
  def __repr__(self):
8876 
    L = ['%s=%r' % (key, value)
8877 
      for key, value in self.__dict__.iteritems()]
8878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8879 
 
8880 
  def __eq__(self, other):
8881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8882 
 
8883 
  def __ne__(self, other):
8884 
    return not (self == other)
8885 
 
8886 
class deleteItemFromIgnoredInventoryUpdateList_args:
8887 
  """
8888 
  Attributes:
8889 
   - item_id
8890 
   - warehouse_id
8891 
  """
8892 
 
8893 
  thrift_spec = (
8894 
    None, # 0
8895 
    (1, TType.I64, 'item_id', None, None, ), # 1
8896 
    (2, TType.I64, 'warehouse_id', None, None, ), # 2
8897 
  )
8898 
 
8899 
  def __init__(self, item_id=None, warehouse_id=None,):
8900 
    self.item_id = item_id
8901 
    self.warehouse_id = warehouse_id
8902 
 
8903 
  def read(self, iprot):
8904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8906 
      return
8907 
    iprot.readStructBegin()
8908 
    while True:
8909 
      (fname, ftype, fid) = iprot.readFieldBegin()
8910 
      if ftype == TType.STOP:
8911 
        break
8912 
      if fid == 1:
8913 
        if ftype == TType.I64:
8914 
          self.item_id = iprot.readI64();
8915 
        else:
8916 
          iprot.skip(ftype)
8917 
      elif fid == 2:
8918 
        if ftype == TType.I64:
8919 
          self.warehouse_id = iprot.readI64();
8920 
        else:
8921 
          iprot.skip(ftype)
8922 
      else:
8923 
        iprot.skip(ftype)
8924 
      iprot.readFieldEnd()
8925 
    iprot.readStructEnd()
8926 
 
8927 
  def write(self, oprot):
8928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8930 
      return
8931 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_args')
8932 
    if self.item_id is not None:
8933 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
8934 
      oprot.writeI64(self.item_id)
8935 
      oprot.writeFieldEnd()
8936 
    if self.warehouse_id is not None:
8937 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 2)
8938 
      oprot.writeI64(self.warehouse_id)
8939 
      oprot.writeFieldEnd()
8940 
    oprot.writeFieldStop()
8941 
    oprot.writeStructEnd()
8942 
 
8943 
  def validate(self):
8944 
    return
8945 
 
8946 
 
8947 
  def __repr__(self):
8948 
    L = ['%s=%r' % (key, value)
8949 
      for key, value in self.__dict__.iteritems()]
8950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8951 
 
8952 
  def __eq__(self, other):
8953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8954 
 
8955 
  def __ne__(self, other):
8956 
    return not (self == other)
8957 
 
8958 
class deleteItemFromIgnoredInventoryUpdateList_result:
8959 
  """
8960 
  Attributes:
8961 
   - success
8962 
  """
8963 
 
8964 
  thrift_spec = (
8965 
    (0, TType.BOOL, 'success', None, None, ), # 0
8966 
  )
8967 
 
8968 
  def __init__(self, success=None,):
8969 
    self.success = success
8970 
 
8971 
  def read(self, iprot):
8972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8974 
      return
8975 
    iprot.readStructBegin()
8976 
    while True:
8977 
      (fname, ftype, fid) = iprot.readFieldBegin()
8978 
      if ftype == TType.STOP:
8979 
        break
8980 
      if fid == 0:
8981 
        if ftype == TType.BOOL:
8982 
          self.success = iprot.readBool();
8983 
        else:
8984 
          iprot.skip(ftype)
8985 
      else:
8986 
        iprot.skip(ftype)
8987 
      iprot.readFieldEnd()
8988 
    iprot.readStructEnd()
8989 
 
8990 
  def write(self, oprot):
8991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8993 
      return
8994 
    oprot.writeStructBegin('deleteItemFromIgnoredInventoryUpdateList_result')
8995 
    if self.success is not None:
8996 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8997 
      oprot.writeBool(self.success)
8998 
      oprot.writeFieldEnd()
8999 
    oprot.writeFieldStop()
9000 
    oprot.writeStructEnd()
9001 
 
9002 
  def validate(self):
9003 
    return
9004 
 
9005 
 
9006 
  def __repr__(self):
9007 
    L = ['%s=%r' % (key, value)
9008 
      for key, value in self.__dict__.iteritems()]
9009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9010 
 
9011 
  def __eq__(self, other):
9012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9013 
 
9014 
  def __ne__(self, other):
9015 
    return not (self == other)
9016 
 
9017 
class getAllIgnoredInventoryupdateItemsCount_args:
9018 
 
9019 
  thrift_spec = (
9020 
  )
9021 
 
9022 
  def read(self, iprot):
9023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9025 
      return
9026 
    iprot.readStructBegin()
9027 
    while True:
9028 
      (fname, ftype, fid) = iprot.readFieldBegin()
9029 
      if ftype == TType.STOP:
9030 
        break
9031 
      else:
9032 
        iprot.skip(ftype)
9033 
      iprot.readFieldEnd()
9034 
    iprot.readStructEnd()
9035 
 
9036 
  def write(self, oprot):
9037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9039 
      return
9040 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_args')
9041 
    oprot.writeFieldStop()
9042 
    oprot.writeStructEnd()
9043 
 
9044 
  def validate(self):
9045 
    return
9046 
 
9047 
 
9048 
  def __repr__(self):
9049 
    L = ['%s=%r' % (key, value)
9050 
      for key, value in self.__dict__.iteritems()]
9051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9052 
 
9053 
  def __eq__(self, other):
9054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9055 
 
9056 
  def __ne__(self, other):
9057 
    return not (self == other)
9058 
 
9059 
class getAllIgnoredInventoryupdateItemsCount_result:
9060 
  """
9061 
  Attributes:
9062 
   - success
9063 
  """
9064 
 
9065 
  thrift_spec = (
9066 
    (0, TType.I32, 'success', None, None, ), # 0
9067 
  )
9068 
 
9069 
  def __init__(self, success=None,):
9070 
    self.success = success
9071 
 
9072 
  def read(self, iprot):
9073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9075 
      return
9076 
    iprot.readStructBegin()
9077 
    while True:
9078 
      (fname, ftype, fid) = iprot.readFieldBegin()
9079 
      if ftype == TType.STOP:
9080 
        break
9081 
      if fid == 0:
9082 
        if ftype == TType.I32:
9083 
          self.success = iprot.readI32();
9084 
        else:
9085 
          iprot.skip(ftype)
9086 
      else:
9087 
        iprot.skip(ftype)
9088 
      iprot.readFieldEnd()
9089 
    iprot.readStructEnd()
9090 
 
9091 
  def write(self, oprot):
9092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9094 
      return
9095 
    oprot.writeStructBegin('getAllIgnoredInventoryupdateItemsCount_result')
9096 
    if self.success is not None:
9097 
      oprot.writeFieldBegin('success', TType.I32, 0)
9098 
      oprot.writeI32(self.success)
9099 
      oprot.writeFieldEnd()
9100 
    oprot.writeFieldStop()
9101 
    oprot.writeStructEnd()
9102 
 
9103 
  def validate(self):
9104 
    return
9105 
 
9106 
 
9107 
  def __repr__(self):
9108 
    L = ['%s=%r' % (key, value)
9109 
      for key, value in self.__dict__.iteritems()]
9110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9111 
 
9112 
  def __eq__(self, other):
9113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9114 
 
9115 
  def __ne__(self, other):
9116 
    return not (self == other)
9117 
 
9118 
class getIgnoredInventoryUpdateItemids_args:
9119 
  """
9120 
  Attributes:
9121 
   - offset
9122 
   - limit
9123 
  """
9124 
 
9125 
  thrift_spec = (
9126 
    None, # 0
9127 
    (1, TType.I32, 'offset', None, None, ), # 1
9128 
    (2, TType.I32, 'limit', None, None, ), # 2
9129 
  )
9130 
 
9131 
  def __init__(self, offset=None, limit=None,):
9132 
    self.offset = offset
9133 
    self.limit = limit
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 
      if fid == 1:
9145 
        if ftype == TType.I32:
9146 
          self.offset = iprot.readI32();
9147 
        else:
9148 
          iprot.skip(ftype)
9149 
      elif fid == 2:
9150 
        if ftype == TType.I32:
9151 
          self.limit = iprot.readI32();
9152 
        else:
9153 
          iprot.skip(ftype)
9154 
      else:
9155 
        iprot.skip(ftype)
9156 
      iprot.readFieldEnd()
9157 
    iprot.readStructEnd()
9158 
 
9159 
  def write(self, oprot):
9160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9162 
      return
9163 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_args')
9164 
    if self.offset is not None:
9165 
      oprot.writeFieldBegin('offset', TType.I32, 1)
9166 
      oprot.writeI32(self.offset)
9167 
      oprot.writeFieldEnd()
9168 
    if self.limit is not None:
9169 
      oprot.writeFieldBegin('limit', TType.I32, 2)
9170 
      oprot.writeI32(self.limit)
9171 
      oprot.writeFieldEnd()
9172 
    oprot.writeFieldStop()
9173 
    oprot.writeStructEnd()
9174 
 
9175 
  def validate(self):
9176 
    return
9177 
 
9178 
 
9179 
  def __repr__(self):
9180 
    L = ['%s=%r' % (key, value)
9181 
      for key, value in self.__dict__.iteritems()]
9182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9183 
 
9184 
  def __eq__(self, other):
9185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9186 
 
9187 
  def __ne__(self, other):
9188 
    return not (self == other)
9189 
 
9190 
class getIgnoredInventoryUpdateItemids_result:
9191 
  """
9192 
  Attributes:
9193 
   - success
9194 
  """
9195 
 
9196 
  thrift_spec = (
9197 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9198 
  )
9199 
 
9200 
  def __init__(self, success=None,):
9201 
    self.success = success
9202 
 
9203 
  def read(self, iprot):
9204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9206 
      return
9207 
    iprot.readStructBegin()
9208 
    while True:
9209 
      (fname, ftype, fid) = iprot.readFieldBegin()
9210 
      if ftype == TType.STOP:
9211 
        break
9212 
      if fid == 0:
9213 
        if ftype == TType.LIST:
9214 
          self.success = []
8182 amar.kumar 9215 
          (_etype189, _size186) = iprot.readListBegin()
9216 
          for _i190 in xrange(_size186):
9217 
            _elem191 = iprot.readI64();
9218 
            self.success.append(_elem191)
6531 vikram.rag 9219 
          iprot.readListEnd()
9220 
        else:
9221 
          iprot.skip(ftype)
9222 
      else:
9223 
        iprot.skip(ftype)
9224 
      iprot.readFieldEnd()
9225 
    iprot.readStructEnd()
9226 
 
9227 
  def write(self, oprot):
9228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9230 
      return
9231 
    oprot.writeStructBegin('getIgnoredInventoryUpdateItemids_result')
9232 
    if self.success is not None:
9233 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9234 
      oprot.writeListBegin(TType.I64, len(self.success))
8182 amar.kumar 9235 
      for iter192 in self.success:
9236 
        oprot.writeI64(iter192)
6531 vikram.rag 9237 
      oprot.writeListEnd()
9238 
      oprot.writeFieldEnd()
9239 
    oprot.writeFieldStop()
9240 
    oprot.writeStructEnd()
9241 
 
9242 
  def validate(self):
9243 
    return
9244 
 
9245 
 
9246 
  def __repr__(self):
9247 
    L = ['%s=%r' % (key, value)
9248 
      for key, value in self.__dict__.iteritems()]
9249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9250 
 
9251 
  def __eq__(self, other):
9252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9253 
 
9254 
  def __ne__(self, other):
9255 
    return not (self == other)
6821 amar.kumar 9256 
 
9257 
class updateItemStockPurchaseParams_args:
9258 
  """
9259 
  Attributes:
9260 
   - item_id
9261 
   - numOfDaysStock
9262 
   - minStockLevel
9263 
  """
9264 
 
9265 
  thrift_spec = (
9266 
    None, # 0
9267 
    (1, TType.I64, 'item_id', None, None, ), # 1
9268 
    (2, TType.I32, 'numOfDaysStock', None, None, ), # 2
9269 
    (3, TType.I64, 'minStockLevel', None, None, ), # 3
9270 
  )
9271 
 
9272 
  def __init__(self, item_id=None, numOfDaysStock=None, minStockLevel=None,):
9273 
    self.item_id = item_id
9274 
    self.numOfDaysStock = numOfDaysStock
9275 
    self.minStockLevel = minStockLevel
9276 
 
9277 
  def read(self, iprot):
9278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9280 
      return
9281 
    iprot.readStructBegin()
9282 
    while True:
9283 
      (fname, ftype, fid) = iprot.readFieldBegin()
9284 
      if ftype == TType.STOP:
9285 
        break
9286 
      if fid == 1:
9287 
        if ftype == TType.I64:
9288 
          self.item_id = iprot.readI64();
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      elif fid == 2:
9292 
        if ftype == TType.I32:
9293 
          self.numOfDaysStock = iprot.readI32();
9294 
        else:
9295 
          iprot.skip(ftype)
9296 
      elif fid == 3:
9297 
        if ftype == TType.I64:
9298 
          self.minStockLevel = iprot.readI64();
9299 
        else:
9300 
          iprot.skip(ftype)
9301 
      else:
9302 
        iprot.skip(ftype)
9303 
      iprot.readFieldEnd()
9304 
    iprot.readStructEnd()
9305 
 
9306 
  def write(self, oprot):
9307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9309 
      return
9310 
    oprot.writeStructBegin('updateItemStockPurchaseParams_args')
9311 
    if self.item_id is not None:
9312 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
9313 
      oprot.writeI64(self.item_id)
9314 
      oprot.writeFieldEnd()
9315 
    if self.numOfDaysStock is not None:
9316 
      oprot.writeFieldBegin('numOfDaysStock', TType.I32, 2)
9317 
      oprot.writeI32(self.numOfDaysStock)
9318 
      oprot.writeFieldEnd()
9319 
    if self.minStockLevel is not None:
9320 
      oprot.writeFieldBegin('minStockLevel', TType.I64, 3)
9321 
      oprot.writeI64(self.minStockLevel)
9322 
      oprot.writeFieldEnd()
9323 
    oprot.writeFieldStop()
9324 
    oprot.writeStructEnd()
9325 
 
9326 
  def validate(self):
9327 
    return
9328 
 
9329 
 
9330 
  def __repr__(self):
9331 
    L = ['%s=%r' % (key, value)
9332 
      for key, value in self.__dict__.iteritems()]
9333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9334 
 
9335 
  def __eq__(self, other):
9336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9337 
 
9338 
  def __ne__(self, other):
9339 
    return not (self == other)
9340 
 
9341 
class updateItemStockPurchaseParams_result:
9342 
 
9343 
  thrift_spec = (
9344 
  )
9345 
 
9346 
  def read(self, iprot):
9347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9349 
      return
9350 
    iprot.readStructBegin()
9351 
    while True:
9352 
      (fname, ftype, fid) = iprot.readFieldBegin()
9353 
      if ftype == TType.STOP:
9354 
        break
9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('updateItemStockPurchaseParams_result')
9365 
    oprot.writeFieldStop()
9366 
    oprot.writeStructEnd()
9367 
 
9368 
  def validate(self):
9369 
    return
9370 
 
9371 
 
9372 
  def __repr__(self):
9373 
    L = ['%s=%r' % (key, value)
9374 
      for key, value in self.__dict__.iteritems()]
9375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9376 
 
9377 
  def __eq__(self, other):
9378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9379 
 
9380 
  def __ne__(self, other):
9381 
    return not (self == other)
9382 
 
9383 
class getItemStockPurchaseParams_args:
9384 
  """
9385 
  Attributes:
9386 
   - itemId
9387 
  """
9388 
 
9389 
  thrift_spec = (
9390 
    None, # 0
9391 
    (1, TType.I64, 'itemId', None, None, ), # 1
9392 
  )
9393 
 
9394 
  def __init__(self, itemId=None,):
9395 
    self.itemId = itemId
9396 
 
9397 
  def read(self, iprot):
9398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9400 
      return
9401 
    iprot.readStructBegin()
9402 
    while True:
9403 
      (fname, ftype, fid) = iprot.readFieldBegin()
9404 
      if ftype == TType.STOP:
9405 
        break
9406 
      if fid == 1:
9407 
        if ftype == TType.I64:
9408 
          self.itemId = iprot.readI64();
9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      else:
9412 
        iprot.skip(ftype)
9413 
      iprot.readFieldEnd()
9414 
    iprot.readStructEnd()
9415 
 
9416 
  def write(self, oprot):
9417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9419 
      return
9420 
    oprot.writeStructBegin('getItemStockPurchaseParams_args')
9421 
    if self.itemId is not None:
9422 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9423 
      oprot.writeI64(self.itemId)
9424 
      oprot.writeFieldEnd()
9425 
    oprot.writeFieldStop()
9426 
    oprot.writeStructEnd()
9427 
 
9428 
  def validate(self):
9429 
    return
9430 
 
9431 
 
9432 
  def __repr__(self):
9433 
    L = ['%s=%r' % (key, value)
9434 
      for key, value in self.__dict__.iteritems()]
9435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9436 
 
9437 
  def __eq__(self, other):
9438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9439 
 
9440 
  def __ne__(self, other):
9441 
    return not (self == other)
9442 
 
9443 
class getItemStockPurchaseParams_result:
9444 
  """
9445 
  Attributes:
9446 
   - success
9447 
  """
9448 
 
9449 
  thrift_spec = (
9450 
    (0, TType.STRUCT, 'success', (ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec), None, ), # 0
9451 
  )
9452 
 
9453 
  def __init__(self, success=None,):
9454 
    self.success = success
9455 
 
9456 
  def read(self, iprot):
9457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9459 
      return
9460 
    iprot.readStructBegin()
9461 
    while True:
9462 
      (fname, ftype, fid) = iprot.readFieldBegin()
9463 
      if ftype == TType.STOP:
9464 
        break
9465 
      if fid == 0:
9466 
        if ftype == TType.STRUCT:
9467 
          self.success = ItemStockPurchaseParams()
9468 
          self.success.read(iprot)
9469 
        else:
9470 
          iprot.skip(ftype)
9471 
      else:
9472 
        iprot.skip(ftype)
9473 
      iprot.readFieldEnd()
9474 
    iprot.readStructEnd()
9475 
 
9476 
  def write(self, oprot):
9477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9479 
      return
9480 
    oprot.writeStructBegin('getItemStockPurchaseParams_result')
9481 
    if self.success is not None:
9482 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9483 
      self.success.write(oprot)
9484 
      oprot.writeFieldEnd()
9485 
    oprot.writeFieldStop()
9486 
    oprot.writeStructEnd()
9487 
 
9488 
  def validate(self):
9489 
    return
9490 
 
9491 
 
9492 
  def __repr__(self):
9493 
    L = ['%s=%r' % (key, value)
9494 
      for key, value in self.__dict__.iteritems()]
9495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9496 
 
9497 
  def __eq__(self, other):
9498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9499 
 
9500 
  def __ne__(self, other):
9501 
    return not (self == other)
9502 
 
9503 
class addOosStatusForItem_args:
9504 
  """
9505 
  Attributes:
9506 
   - oosStatusMap
9507 
   - date
9508 
  """
9509 
 
9510 
  thrift_spec = (
9511 
    None, # 0
9512 
    (1, TType.MAP, 'oosStatusMap', (TType.I64,None,TType.BOOL,None), None, ), # 1
9513 
    (2, TType.I64, 'date', None, None, ), # 2
9514 
  )
9515 
 
9516 
  def __init__(self, oosStatusMap=None, date=None,):
9517 
    self.oosStatusMap = oosStatusMap
9518 
    self.date = date
9519 
 
9520 
  def read(self, iprot):
9521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9523 
      return
9524 
    iprot.readStructBegin()
9525 
    while True:
9526 
      (fname, ftype, fid) = iprot.readFieldBegin()
9527 
      if ftype == TType.STOP:
9528 
        break
9529 
      if fid == 1:
9530 
        if ftype == TType.MAP:
9531 
          self.oosStatusMap = {}
8182 amar.kumar 9532 
          (_ktype194, _vtype195, _size193 ) = iprot.readMapBegin()
9533 
          for _i197 in xrange(_size193):
9534 
            _key198 = iprot.readI64();
9535 
            _val199 = iprot.readBool();
9536 
            self.oosStatusMap[_key198] = _val199
6821 amar.kumar 9537 
          iprot.readMapEnd()
9538 
        else:
9539 
          iprot.skip(ftype)
9540 
      elif fid == 2:
9541 
        if ftype == TType.I64:
9542 
          self.date = iprot.readI64();
9543 
        else:
9544 
          iprot.skip(ftype)
9545 
      else:
9546 
        iprot.skip(ftype)
9547 
      iprot.readFieldEnd()
9548 
    iprot.readStructEnd()
9549 
 
9550 
  def write(self, oprot):
9551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9553 
      return
9554 
    oprot.writeStructBegin('addOosStatusForItem_args')
9555 
    if self.oosStatusMap is not None:
9556 
      oprot.writeFieldBegin('oosStatusMap', TType.MAP, 1)
9557 
      oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.oosStatusMap))
8182 amar.kumar 9558 
      for kiter200,viter201 in self.oosStatusMap.items():
9559 
        oprot.writeI64(kiter200)
9560 
        oprot.writeBool(viter201)
6821 amar.kumar 9561 
      oprot.writeMapEnd()
9562 
      oprot.writeFieldEnd()
9563 
    if self.date is not None:
9564 
      oprot.writeFieldBegin('date', TType.I64, 2)
9565 
      oprot.writeI64(self.date)
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 addOosStatusForItem_result:
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('addOosStatusForItem_result')
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)
6832 amar.kumar 9626 
 
9627 
class getOosStatusesForXDaysForItem_args:
9628 
  """
9629 
  Attributes:
9630 
   - itemId
9631 
   - days
9632 
  """
9633 
 
9634 
  thrift_spec = (
9635 
    None, # 0
9636 
    (1, TType.I64, 'itemId', None, None, ), # 1
9637 
    (2, TType.I32, 'days', None, None, ), # 2
9638 
  )
9639 
 
9640 
  def __init__(self, itemId=None, days=None,):
9641 
    self.itemId = itemId
9642 
    self.days = days
9643 
 
9644 
  def read(self, iprot):
9645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9647 
      return
9648 
    iprot.readStructBegin()
9649 
    while True:
9650 
      (fname, ftype, fid) = iprot.readFieldBegin()
9651 
      if ftype == TType.STOP:
9652 
        break
9653 
      if fid == 1:
9654 
        if ftype == TType.I64:
9655 
          self.itemId = iprot.readI64();
9656 
        else:
9657 
          iprot.skip(ftype)
9658 
      elif fid == 2:
9659 
        if ftype == TType.I32:
9660 
          self.days = iprot.readI32();
9661 
        else:
9662 
          iprot.skip(ftype)
9663 
      else:
9664 
        iprot.skip(ftype)
9665 
      iprot.readFieldEnd()
9666 
    iprot.readStructEnd()
9667 
 
9668 
  def write(self, oprot):
9669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9671 
      return
9672 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_args')
9673 
    if self.itemId is not None:
9674 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
9675 
      oprot.writeI64(self.itemId)
9676 
      oprot.writeFieldEnd()
9677 
    if self.days is not None:
9678 
      oprot.writeFieldBegin('days', TType.I32, 2)
9679 
      oprot.writeI32(self.days)
9680 
      oprot.writeFieldEnd()
9681 
    oprot.writeFieldStop()
9682 
    oprot.writeStructEnd()
9683 
 
9684 
  def validate(self):
9685 
    return
9686 
 
9687 
 
9688 
  def __repr__(self):
9689 
    L = ['%s=%r' % (key, value)
9690 
      for key, value in self.__dict__.iteritems()]
9691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9692 
 
9693 
  def __eq__(self, other):
9694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9695 
 
9696 
  def __ne__(self, other):
9697 
    return not (self == other)
9698 
 
9699 
class getOosStatusesForXDaysForItem_result:
9700 
  """
9701 
  Attributes:
9702 
   - success
9703 
  """
9704 
 
9705 
  thrift_spec = (
9706 
    (0, TType.LIST, 'success', (TType.STRUCT,(OOSStatus, OOSStatus.thrift_spec)), None, ), # 0
9707 
  )
9708 
 
9709 
  def __init__(self, success=None,):
9710 
    self.success = success
9711 
 
9712 
  def read(self, iprot):
9713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9715 
      return
9716 
    iprot.readStructBegin()
9717 
    while True:
9718 
      (fname, ftype, fid) = iprot.readFieldBegin()
9719 
      if ftype == TType.STOP:
9720 
        break
9721 
      if fid == 0:
9722 
        if ftype == TType.LIST:
9723 
          self.success = []
8182 amar.kumar 9724 
          (_etype205, _size202) = iprot.readListBegin()
9725 
          for _i206 in xrange(_size202):
9726 
            _elem207 = OOSStatus()
9727 
            _elem207.read(iprot)
9728 
            self.success.append(_elem207)
6832 amar.kumar 9729 
          iprot.readListEnd()
9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      else:
9733 
        iprot.skip(ftype)
9734 
      iprot.readFieldEnd()
9735 
    iprot.readStructEnd()
9736 
 
9737 
  def write(self, oprot):
9738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9740 
      return
9741 
    oprot.writeStructBegin('getOosStatusesForXDaysForItem_result')
9742 
    if self.success is not None:
9743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9745 
      for iter208 in self.success:
9746 
        iter208.write(oprot)
6832 amar.kumar 9747 
      oprot.writeListEnd()
9748 
      oprot.writeFieldEnd()
9749 
    oprot.writeFieldStop()
9750 
    oprot.writeStructEnd()
9751 
 
9752 
  def validate(self):
9753 
    return
9754 
 
9755 
 
9756 
  def __repr__(self):
9757 
    L = ['%s=%r' % (key, value)
9758 
      for key, value in self.__dict__.iteritems()]
9759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9760 
 
9761 
  def __eq__(self, other):
9762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9763 
 
9764 
  def __ne__(self, other):
9765 
    return not (self == other)
6857 amar.kumar 9766 
 
9767 
class getNonZeroItemStockPurchaseParams_args:
9768 
 
9769 
  thrift_spec = (
9770 
  )
9771 
 
9772 
  def read(self, iprot):
9773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9775 
      return
9776 
    iprot.readStructBegin()
9777 
    while True:
9778 
      (fname, ftype, fid) = iprot.readFieldBegin()
9779 
      if ftype == TType.STOP:
9780 
        break
9781 
      else:
9782 
        iprot.skip(ftype)
9783 
      iprot.readFieldEnd()
9784 
    iprot.readStructEnd()
9785 
 
9786 
  def write(self, oprot):
9787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9789 
      return
9790 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_args')
9791 
    oprot.writeFieldStop()
9792 
    oprot.writeStructEnd()
9793 
 
9794 
  def validate(self):
9795 
    return
9796 
 
9797 
 
9798 
  def __repr__(self):
9799 
    L = ['%s=%r' % (key, value)
9800 
      for key, value in self.__dict__.iteritems()]
9801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9802 
 
9803 
  def __eq__(self, other):
9804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9805 
 
9806 
  def __ne__(self, other):
9807 
    return not (self == other)
9808 
 
9809 
class getNonZeroItemStockPurchaseParams_result:
9810 
  """
9811 
  Attributes:
9812 
   - success
9813 
  """
9814 
 
9815 
  thrift_spec = (
9816 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemStockPurchaseParams, ItemStockPurchaseParams.thrift_spec)), None, ), # 0
9817 
  )
9818 
 
9819 
  def __init__(self, success=None,):
9820 
    self.success = success
9821 
 
9822 
  def read(self, iprot):
9823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9825 
      return
9826 
    iprot.readStructBegin()
9827 
    while True:
9828 
      (fname, ftype, fid) = iprot.readFieldBegin()
9829 
      if ftype == TType.STOP:
9830 
        break
9831 
      if fid == 0:
9832 
        if ftype == TType.LIST:
9833 
          self.success = []
8182 amar.kumar 9834 
          (_etype212, _size209) = iprot.readListBegin()
9835 
          for _i213 in xrange(_size209):
9836 
            _elem214 = ItemStockPurchaseParams()
9837 
            _elem214.read(iprot)
9838 
            self.success.append(_elem214)
6857 amar.kumar 9839 
          iprot.readListEnd()
9840 
        else:
9841 
          iprot.skip(ftype)
9842 
      else:
9843 
        iprot.skip(ftype)
9844 
      iprot.readFieldEnd()
9845 
    iprot.readStructEnd()
9846 
 
9847 
  def write(self, oprot):
9848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9850 
      return
9851 
    oprot.writeStructBegin('getNonZeroItemStockPurchaseParams_result')
9852 
    if self.success is not None:
9853 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9854 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9855 
      for iter215 in self.success:
9856 
        iter215.write(oprot)
6857 amar.kumar 9857 
      oprot.writeListEnd()
9858 
      oprot.writeFieldEnd()
9859 
    oprot.writeFieldStop()
9860 
    oprot.writeStructEnd()
9861 
 
9862 
  def validate(self):
9863 
    return
9864 
 
9865 
 
9866 
  def __repr__(self):
9867 
    L = ['%s=%r' % (key, value)
9868 
      for key, value in self.__dict__.iteritems()]
9869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9870 
 
9871 
  def __eq__(self, other):
9872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9873 
 
9874 
  def __ne__(self, other):
9875 
    return not (self == other)
7149 amar.kumar 9876 
 
9877 
class getBillableInventoryAndPendingOrders_args:
9878 
 
9879 
  thrift_spec = (
9880 
  )
9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      else:
9892 
        iprot.skip(ftype)
9893 
      iprot.readFieldEnd()
9894 
    iprot.readStructEnd()
9895 
 
9896 
  def write(self, oprot):
9897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9899 
      return
9900 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_args')
9901 
    oprot.writeFieldStop()
9902 
    oprot.writeStructEnd()
9903 
 
9904 
  def validate(self):
9905 
    return
9906 
 
9907 
 
9908 
  def __repr__(self):
9909 
    L = ['%s=%r' % (key, value)
9910 
      for key, value in self.__dict__.iteritems()]
9911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9912 
 
9913 
  def __eq__(self, other):
9914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9915 
 
9916 
  def __ne__(self, other):
9917 
    return not (self == other)
9918 
 
9919 
class getBillableInventoryAndPendingOrders_result:
9920 
  """
9921 
  Attributes:
9922 
   - success
9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    (0, TType.LIST, 'success', (TType.STRUCT,(AvailableAndReservedStock, AvailableAndReservedStock.thrift_spec)), None, ), # 0
9927 
  )
9928 
 
9929 
  def __init__(self, success=None,):
9930 
    self.success = success
9931 
 
9932 
  def read(self, iprot):
9933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9935 
      return
9936 
    iprot.readStructBegin()
9937 
    while True:
9938 
      (fname, ftype, fid) = iprot.readFieldBegin()
9939 
      if ftype == TType.STOP:
9940 
        break
9941 
      if fid == 0:
9942 
        if ftype == TType.LIST:
9943 
          self.success = []
8182 amar.kumar 9944 
          (_etype219, _size216) = iprot.readListBegin()
9945 
          for _i220 in xrange(_size216):
9946 
            _elem221 = AvailableAndReservedStock()
9947 
            _elem221.read(iprot)
9948 
            self.success.append(_elem221)
7149 amar.kumar 9949 
          iprot.readListEnd()
9950 
        else:
9951 
          iprot.skip(ftype)
9952 
      else:
9953 
        iprot.skip(ftype)
9954 
      iprot.readFieldEnd()
9955 
    iprot.readStructEnd()
9956 
 
9957 
  def write(self, oprot):
9958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9960 
      return
9961 
    oprot.writeStructBegin('getBillableInventoryAndPendingOrders_result')
9962 
    if self.success is not None:
9963 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9964 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 9965 
      for iter222 in self.success:
9966 
        iter222.write(oprot)
7149 amar.kumar 9967 
      oprot.writeListEnd()
9968 
      oprot.writeFieldEnd()
9969 
    oprot.writeFieldStop()
9970 
    oprot.writeStructEnd()
9971 
 
9972 
  def validate(self):
9973 
    return
9974 
 
9975 
 
9976 
  def __repr__(self):
9977 
    L = ['%s=%r' % (key, value)
9978 
      for key, value in self.__dict__.iteritems()]
9979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9980 
 
9981 
  def __eq__(self, other):
9982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9983 
 
9984 
  def __ne__(self, other):
9985 
    return not (self == other)
7281 kshitij.so 9986 
 
9987 
class getWarehouseName_args:
9988 
  """
9989 
  Attributes:
9990 
   - warehouse_id
9991 
  """
9992 
 
9993 
  thrift_spec = (
9994 
    None, # 0
9995 
    (1, TType.I64, 'warehouse_id', None, None, ), # 1
9996 
  )
9997 
 
9998 
  def __init__(self, warehouse_id=None,):
9999 
    self.warehouse_id = warehouse_id
10000 
 
10001 
  def read(self, iprot):
10002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10004 
      return
10005 
    iprot.readStructBegin()
10006 
    while True:
10007 
      (fname, ftype, fid) = iprot.readFieldBegin()
10008 
      if ftype == TType.STOP:
10009 
        break
10010 
      if fid == 1:
10011 
        if ftype == TType.I64:
10012 
          self.warehouse_id = iprot.readI64();
10013 
        else:
10014 
          iprot.skip(ftype)
10015 
      else:
10016 
        iprot.skip(ftype)
10017 
      iprot.readFieldEnd()
10018 
    iprot.readStructEnd()
10019 
 
10020 
  def write(self, oprot):
10021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10023 
      return
10024 
    oprot.writeStructBegin('getWarehouseName_args')
10025 
    if self.warehouse_id is not None:
10026 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 1)
10027 
      oprot.writeI64(self.warehouse_id)
10028 
      oprot.writeFieldEnd()
10029 
    oprot.writeFieldStop()
10030 
    oprot.writeStructEnd()
10031 
 
10032 
  def validate(self):
10033 
    return
10034 
 
10035 
 
10036 
  def __repr__(self):
10037 
    L = ['%s=%r' % (key, value)
10038 
      for key, value in self.__dict__.iteritems()]
10039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10040 
 
10041 
  def __eq__(self, other):
10042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10043 
 
10044 
  def __ne__(self, other):
10045 
    return not (self == other)
10046 
 
10047 
class getWarehouseName_result:
10048 
  """
10049 
  Attributes:
10050 
   - success
10051 
  """
10052 
 
10053 
  thrift_spec = (
10054 
    (0, TType.STRING, 'success', None, None, ), # 0
10055 
  )
10056 
 
10057 
  def __init__(self, success=None,):
10058 
    self.success = success
10059 
 
10060 
  def read(self, iprot):
10061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10063 
      return
10064 
    iprot.readStructBegin()
10065 
    while True:
10066 
      (fname, ftype, fid) = iprot.readFieldBegin()
10067 
      if ftype == TType.STOP:
10068 
        break
10069 
      if fid == 0:
10070 
        if ftype == TType.STRING:
10071 
          self.success = iprot.readString();
10072 
        else:
10073 
          iprot.skip(ftype)
10074 
      else:
10075 
        iprot.skip(ftype)
10076 
      iprot.readFieldEnd()
10077 
    iprot.readStructEnd()
10078 
 
10079 
  def write(self, oprot):
10080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10082 
      return
10083 
    oprot.writeStructBegin('getWarehouseName_result')
10084 
    if self.success is not None:
10085 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10086 
      oprot.writeString(self.success)
10087 
      oprot.writeFieldEnd()
10088 
    oprot.writeFieldStop()
10089 
    oprot.writeStructEnd()
10090 
 
10091 
  def validate(self):
10092 
    return
10093 
 
10094 
 
10095 
  def __repr__(self):
10096 
    L = ['%s=%r' % (key, value)
10097 
      for key, value in self.__dict__.iteritems()]
10098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10099 
 
10100 
  def __eq__(self, other):
10101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10102 
 
10103 
  def __ne__(self, other):
10104 
    return not (self == other)
10105 
 
10106 
class getAmazonInventoryForItem_args:
10107 
  """
10108 
  Attributes:
10109 
   - item_id
10110 
  """
10111 
 
10112 
  thrift_spec = (
10113 
    None, # 0
10114 
    (1, TType.I64, 'item_id', None, None, ), # 1
10115 
  )
10116 
 
10117 
  def __init__(self, item_id=None,):
10118 
    self.item_id = item_id
10119 
 
10120 
  def read(self, iprot):
10121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10123 
      return
10124 
    iprot.readStructBegin()
10125 
    while True:
10126 
      (fname, ftype, fid) = iprot.readFieldBegin()
10127 
      if ftype == TType.STOP:
10128 
        break
10129 
      if fid == 1:
10130 
        if ftype == TType.I64:
10131 
          self.item_id = iprot.readI64();
10132 
        else:
10133 
          iprot.skip(ftype)
10134 
      else:
10135 
        iprot.skip(ftype)
10136 
      iprot.readFieldEnd()
10137 
    iprot.readStructEnd()
10138 
 
10139 
  def write(self, oprot):
10140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10142 
      return
10143 
    oprot.writeStructBegin('getAmazonInventoryForItem_args')
10144 
    if self.item_id is not None:
10145 
      oprot.writeFieldBegin('item_id', TType.I64, 1)
10146 
      oprot.writeI64(self.item_id)
10147 
      oprot.writeFieldEnd()
10148 
    oprot.writeFieldStop()
10149 
    oprot.writeStructEnd()
10150 
 
10151 
  def validate(self):
10152 
    return
10153 
 
10154 
 
10155 
  def __repr__(self):
10156 
    L = ['%s=%r' % (key, value)
10157 
      for key, value in self.__dict__.iteritems()]
10158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10159 
 
10160 
  def __eq__(self, other):
10161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10162 
 
10163 
  def __ne__(self, other):
10164 
    return not (self == other)
10165 
 
10166 
class getAmazonInventoryForItem_result:
10167 
  """
10168 
  Attributes:
10169 
   - success
10170 
  """
10171 
 
10172 
  thrift_spec = (
10173 
    (0, TType.STRUCT, 'success', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 0
10174 
  )
10175 
 
10176 
  def __init__(self, success=None,):
10177 
    self.success = success
10178 
 
10179 
  def read(self, iprot):
10180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10182 
      return
10183 
    iprot.readStructBegin()
10184 
    while True:
10185 
      (fname, ftype, fid) = iprot.readFieldBegin()
10186 
      if ftype == TType.STOP:
10187 
        break
10188 
      if fid == 0:
10189 
        if ftype == TType.STRUCT:
10190 
          self.success = AmazonInventorySnapshot()
10191 
          self.success.read(iprot)
10192 
        else:
10193 
          iprot.skip(ftype)
10194 
      else:
10195 
        iprot.skip(ftype)
10196 
      iprot.readFieldEnd()
10197 
    iprot.readStructEnd()
10198 
 
10199 
  def write(self, oprot):
10200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10202 
      return
10203 
    oprot.writeStructBegin('getAmazonInventoryForItem_result')
10204 
    if self.success is not None:
10205 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
10206 
      self.success.write(oprot)
10207 
      oprot.writeFieldEnd()
10208 
    oprot.writeFieldStop()
10209 
    oprot.writeStructEnd()
10210 
 
10211 
  def validate(self):
10212 
    return
10213 
 
10214 
 
10215 
  def __repr__(self):
10216 
    L = ['%s=%r' % (key, value)
10217 
      for key, value in self.__dict__.iteritems()]
10218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10219 
 
10220 
  def __eq__(self, other):
10221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10222 
 
10223 
  def __ne__(self, other):
10224 
    return not (self == other)
10225 
 
10226 
class getAllAmazonInventory_args:
10227 
 
10228 
  thrift_spec = (
10229 
  )
10230 
 
10231 
  def read(self, iprot):
10232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10234 
      return
10235 
    iprot.readStructBegin()
10236 
    while True:
10237 
      (fname, ftype, fid) = iprot.readFieldBegin()
10238 
      if ftype == TType.STOP:
10239 
        break
10240 
      else:
10241 
        iprot.skip(ftype)
10242 
      iprot.readFieldEnd()
10243 
    iprot.readStructEnd()
10244 
 
10245 
  def write(self, oprot):
10246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10248 
      return
10249 
    oprot.writeStructBegin('getAllAmazonInventory_args')
10250 
    oprot.writeFieldStop()
10251 
    oprot.writeStructEnd()
10252 
 
10253 
  def validate(self):
10254 
    return
10255 
 
10256 
 
10257 
  def __repr__(self):
10258 
    L = ['%s=%r' % (key, value)
10259 
      for key, value in self.__dict__.iteritems()]
10260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10261 
 
10262 
  def __eq__(self, other):
10263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10264 
 
10265 
  def __ne__(self, other):
10266 
    return not (self == other)
10267 
 
10268 
class getAllAmazonInventory_result:
10269 
  """
10270 
  Attributes:
10271 
   - success
10272 
  """
10273 
 
10274 
  thrift_spec = (
10275 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec)), None, ), # 0
10276 
  )
10277 
 
10278 
  def __init__(self, success=None,):
10279 
    self.success = success
10280 
 
10281 
  def read(self, iprot):
10282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10284 
      return
10285 
    iprot.readStructBegin()
10286 
    while True:
10287 
      (fname, ftype, fid) = iprot.readFieldBegin()
10288 
      if ftype == TType.STOP:
10289 
        break
10290 
      if fid == 0:
10291 
        if ftype == TType.LIST:
10292 
          self.success = []
8182 amar.kumar 10293 
          (_etype226, _size223) = iprot.readListBegin()
10294 
          for _i227 in xrange(_size223):
10295 
            _elem228 = AmazonInventorySnapshot()
10296 
            _elem228.read(iprot)
10297 
            self.success.append(_elem228)
7281 kshitij.so 10298 
          iprot.readListEnd()
10299 
        else:
10300 
          iprot.skip(ftype)
10301 
      else:
10302 
        iprot.skip(ftype)
10303 
      iprot.readFieldEnd()
10304 
    iprot.readStructEnd()
10305 
 
10306 
  def write(self, oprot):
10307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10309 
      return
10310 
    oprot.writeStructBegin('getAllAmazonInventory_result')
10311 
    if self.success is not None:
10312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8182 amar.kumar 10314 
      for iter229 in self.success:
10315 
        iter229.write(oprot)
7281 kshitij.so 10316 
      oprot.writeListEnd()
10317 
      oprot.writeFieldEnd()
10318 
    oprot.writeFieldStop()
10319 
    oprot.writeStructEnd()
10320 
 
10321 
  def validate(self):
10322 
    return
10323 
 
10324 
 
10325 
  def __repr__(self):
10326 
    L = ['%s=%r' % (key, value)
10327 
      for key, value in self.__dict__.iteritems()]
10328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10329 
 
10330 
  def __eq__(self, other):
10331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10332 
 
10333 
  def __ne__(self, other):
10334 
    return not (self == other)
10335 
 
10336 
class addOrUpdateAmazonInventoryForItem_args:
10337 
  """
10338 
  Attributes:
10339 
   - amazonInventorySnapshot
10340 
  """
10341 
 
10342 
  thrift_spec = (
10343 
    None, # 0
10344 
    (1, TType.STRUCT, 'amazonInventorySnapshot', (AmazonInventorySnapshot, AmazonInventorySnapshot.thrift_spec), None, ), # 1
10345 
  )
10346 
 
10347 
  def __init__(self, amazonInventorySnapshot=None,):
10348 
    self.amazonInventorySnapshot = amazonInventorySnapshot
10349 
 
10350 
  def read(self, iprot):
10351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10353 
      return
10354 
    iprot.readStructBegin()
10355 
    while True:
10356 
      (fname, ftype, fid) = iprot.readFieldBegin()
10357 
      if ftype == TType.STOP:
10358 
        break
10359 
      if fid == 1:
10360 
        if ftype == TType.STRUCT:
10361 
          self.amazonInventorySnapshot = AmazonInventorySnapshot()
10362 
          self.amazonInventorySnapshot.read(iprot)
10363 
        else:
10364 
          iprot.skip(ftype)
10365 
      else:
10366 
        iprot.skip(ftype)
10367 
      iprot.readFieldEnd()
10368 
    iprot.readStructEnd()
10369 
 
10370 
  def write(self, oprot):
10371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10373 
      return
10374 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_args')
10375 
    if self.amazonInventorySnapshot is not None:
10376 
      oprot.writeFieldBegin('amazonInventorySnapshot', TType.STRUCT, 1)
10377 
      self.amazonInventorySnapshot.write(oprot)
10378 
      oprot.writeFieldEnd()
10379 
    oprot.writeFieldStop()
10380 
    oprot.writeStructEnd()
10381 
 
10382 
  def validate(self):
10383 
    return
10384 
 
10385 
 
10386 
  def __repr__(self):
10387 
    L = ['%s=%r' % (key, value)
10388 
      for key, value in self.__dict__.iteritems()]
10389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10390 
 
10391 
  def __eq__(self, other):
10392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10393 
 
10394 
  def __ne__(self, other):
10395 
    return not (self == other)
10396 
 
10397 
class addOrUpdateAmazonInventoryForItem_result:
10398 
 
10399 
  thrift_spec = (
10400 
  )
10401 
 
10402 
  def read(self, iprot):
10403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10405 
      return
10406 
    iprot.readStructBegin()
10407 
    while True:
10408 
      (fname, ftype, fid) = iprot.readFieldBegin()
10409 
      if ftype == TType.STOP:
10410 
        break
10411 
      else:
10412 
        iprot.skip(ftype)
10413 
      iprot.readFieldEnd()
10414 
    iprot.readStructEnd()
10415 
 
10416 
  def write(self, oprot):
10417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10419 
      return
10420 
    oprot.writeStructBegin('addOrUpdateAmazonInventoryForItem_result')
10421 
    oprot.writeFieldStop()
10422 
    oprot.writeStructEnd()
10423 
 
10424 
  def validate(self):
10425 
    return
10426 
 
10427 
 
10428 
  def __repr__(self):
10429 
    L = ['%s=%r' % (key, value)
10430 
      for key, value in self.__dict__.iteritems()]
10431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10432 
 
10433 
  def __eq__(self, other):
10434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10435 
 
10436 
  def __ne__(self, other):
10437 
    return not (self == other)
7972 amar.kumar 10438 
 
10439 
class getLastNdaySaleForItem_args:
10440 
  """
10441 
  Attributes:
10442 
   - itemId
10443 
   - numberOfDays
10444 
  """
10445 
 
10446 
  thrift_spec = (
10447 
    None, # 0
10448 
    (1, TType.I64, 'itemId', None, None, ), # 1
10449 
    (2, TType.I64, 'numberOfDays', None, None, ), # 2
10450 
  )
10451 
 
10452 
  def __init__(self, itemId=None, numberOfDays=None,):
10453 
    self.itemId = itemId
10454 
    self.numberOfDays = numberOfDays
10455 
 
10456 
  def read(self, iprot):
10457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10459 
      return
10460 
    iprot.readStructBegin()
10461 
    while True:
10462 
      (fname, ftype, fid) = iprot.readFieldBegin()
10463 
      if ftype == TType.STOP:
10464 
        break
10465 
      if fid == 1:
10466 
        if ftype == TType.I64:
10467 
          self.itemId = iprot.readI64();
10468 
        else:
10469 
          iprot.skip(ftype)
10470 
      elif fid == 2:
10471 
        if ftype == TType.I64:
10472 
          self.numberOfDays = iprot.readI64();
10473 
        else:
10474 
          iprot.skip(ftype)
10475 
      else:
10476 
        iprot.skip(ftype)
10477 
      iprot.readFieldEnd()
10478 
    iprot.readStructEnd()
10479 
 
10480 
  def write(self, oprot):
10481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10483 
      return
10484 
    oprot.writeStructBegin('getLastNdaySaleForItem_args')
10485 
    if self.itemId is not None:
10486 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10487 
      oprot.writeI64(self.itemId)
10488 
      oprot.writeFieldEnd()
10489 
    if self.numberOfDays is not None:
10490 
      oprot.writeFieldBegin('numberOfDays', TType.I64, 2)
10491 
      oprot.writeI64(self.numberOfDays)
10492 
      oprot.writeFieldEnd()
10493 
    oprot.writeFieldStop()
10494 
    oprot.writeStructEnd()
10495 
 
10496 
  def validate(self):
10497 
    return
10498 
 
10499 
 
10500 
  def __repr__(self):
10501 
    L = ['%s=%r' % (key, value)
10502 
      for key, value in self.__dict__.iteritems()]
10503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10504 
 
10505 
  def __eq__(self, other):
10506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10507 
 
10508 
  def __ne__(self, other):
10509 
    return not (self == other)
10510 
 
10511 
class getLastNdaySaleForItem_result:
10512 
  """
10513 
  Attributes:
10514 
   - success
10515 
  """
10516 
 
10517 
  thrift_spec = (
10518 
    (0, TType.STRING, 'success', None, None, ), # 0
10519 
  )
10520 
 
10521 
  def __init__(self, success=None,):
10522 
    self.success = success
10523 
 
10524 
  def read(self, iprot):
10525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10527 
      return
10528 
    iprot.readStructBegin()
10529 
    while True:
10530 
      (fname, ftype, fid) = iprot.readFieldBegin()
10531 
      if ftype == TType.STOP:
10532 
        break
10533 
      if fid == 0:
10534 
        if ftype == TType.STRING:
10535 
          self.success = iprot.readString();
10536 
        else:
10537 
          iprot.skip(ftype)
10538 
      else:
10539 
        iprot.skip(ftype)
10540 
      iprot.readFieldEnd()
10541 
    iprot.readStructEnd()
10542 
 
10543 
  def write(self, oprot):
10544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10546 
      return
10547 
    oprot.writeStructBegin('getLastNdaySaleForItem_result')
10548 
    if self.success is not None:
10549 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10550 
      oprot.writeString(self.success)
10551 
      oprot.writeFieldEnd()
10552 
    oprot.writeFieldStop()
10553 
    oprot.writeStructEnd()
10554 
 
10555 
  def validate(self):
10556 
    return
10557 
 
10558 
 
10559 
  def __repr__(self):
10560 
    L = ['%s=%r' % (key, value)
10561 
      for key, value in self.__dict__.iteritems()]
10562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10563 
 
10564 
  def __eq__(self, other):
10565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10566 
 
10567 
  def __ne__(self, other):
10568 
    return not (self == other)
8182 amar.kumar 10569 
 
10570 
class addUpdateHoldInventory_args:
10571 
  """
10572 
  Attributes:
10573 
   - itemId
10574 
   - warehouseId
10575 
   - holdQuantity
10576 
   - source
10577 
  """
10578 
 
10579 
  thrift_spec = (
10580 
    None, # 0
10581 
    (1, TType.I64, 'itemId', None, None, ), # 1
10582 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10583 
    (3, TType.I64, 'holdQuantity', None, None, ), # 3
10584 
    (4, TType.I64, 'source', None, None, ), # 4
10585 
  )
10586 
 
10587 
  def __init__(self, itemId=None, warehouseId=None, holdQuantity=None, source=None,):
10588 
    self.itemId = itemId
10589 
    self.warehouseId = warehouseId
10590 
    self.holdQuantity = holdQuantity
10591 
    self.source = source
10592 
 
10593 
  def read(self, iprot):
10594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10596 
      return
10597 
    iprot.readStructBegin()
10598 
    while True:
10599 
      (fname, ftype, fid) = iprot.readFieldBegin()
10600 
      if ftype == TType.STOP:
10601 
        break
10602 
      if fid == 1:
10603 
        if ftype == TType.I64:
10604 
          self.itemId = iprot.readI64();
10605 
        else:
10606 
          iprot.skip(ftype)
10607 
      elif fid == 2:
10608 
        if ftype == TType.I64:
10609 
          self.warehouseId = iprot.readI64();
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      elif fid == 3:
10613 
        if ftype == TType.I64:
10614 
          self.holdQuantity = iprot.readI64();
10615 
        else:
10616 
          iprot.skip(ftype)
10617 
      elif fid == 4:
10618 
        if ftype == TType.I64:
10619 
          self.source = iprot.readI64();
10620 
        else:
10621 
          iprot.skip(ftype)
10622 
      else:
10623 
        iprot.skip(ftype)
10624 
      iprot.readFieldEnd()
10625 
    iprot.readStructEnd()
10626 
 
10627 
  def write(self, oprot):
10628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10630 
      return
10631 
    oprot.writeStructBegin('addUpdateHoldInventory_args')
10632 
    if self.itemId is not None:
10633 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10634 
      oprot.writeI64(self.itemId)
10635 
      oprot.writeFieldEnd()
10636 
    if self.warehouseId is not None:
10637 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10638 
      oprot.writeI64(self.warehouseId)
10639 
      oprot.writeFieldEnd()
10640 
    if self.holdQuantity is not None:
10641 
      oprot.writeFieldBegin('holdQuantity', TType.I64, 3)
10642 
      oprot.writeI64(self.holdQuantity)
10643 
      oprot.writeFieldEnd()
10644 
    if self.source is not None:
10645 
      oprot.writeFieldBegin('source', TType.I64, 4)
10646 
      oprot.writeI64(self.source)
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
10665 
 
10666 
class addUpdateHoldInventory_result:
10667 
 
10668 
  thrift_spec = (
10669 
  )
10670 
 
10671 
  def read(self, iprot):
10672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10674 
      return
10675 
    iprot.readStructBegin()
10676 
    while True:
10677 
      (fname, ftype, fid) = iprot.readFieldBegin()
10678 
      if ftype == TType.STOP:
10679 
        break
10680 
      else:
10681 
        iprot.skip(ftype)
10682 
      iprot.readFieldEnd()
10683 
    iprot.readStructEnd()
10684 
 
10685 
  def write(self, oprot):
10686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10688 
      return
10689 
    oprot.writeStructBegin('addUpdateHoldInventory_result')
10690 
    oprot.writeFieldStop()
10691 
    oprot.writeStructEnd()
10692 
 
10693 
  def validate(self):
10694 
    return
10695 
 
10696 
 
10697 
  def __repr__(self):
10698 
    L = ['%s=%r' % (key, value)
10699 
      for key, value in self.__dict__.iteritems()]
10700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10701 
 
10702 
  def __eq__(self, other):
10703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10704 
 
10705 
  def __ne__(self, other):
10706 
    return not (self == other)