Subversion Repositories SmartDukaan

Rev

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

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