Subversion Repositories SmartDukaan

Rev

Rev 12531 | Rev 13504 | 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 
 
10864 manish.sha 560 
  def getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
561 
    """
562 
    Parameters:
563 
     - itemId
564 
     - currentWarehouseId
565 
     - physicalWarehouseId
566 
    """
567 
    pass
10690 manish.sha 568 
 
10864 manish.sha 569 
  def scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
570 
    """
571 
    Parameters:
572 
     - saleReturnItems
573 
     - vendorId
574 
     - billingWarehouseId
575 
    """
576 
    pass
577 
 
11751 manish.sha 578 
  def getItemsInPurchaseReturn(self, purchaseReturnId, type):
10864 manish.sha 579 
    """
580 
    Parameters:
581 
     - purchaseReturnId
11751 manish.sha 582 
     - type
10864 manish.sha 583 
    """
584 
    pass
585 
 
10886 manish.sha 586 
  def getScansForInventoryItem(self, inventoryItemId, type):
587 
    """
588 
    Parameters:
589 
     - inventoryItemId
590 
     - type
591 
    """
592 
    pass
10864 manish.sha 593 
 
12531 manish.sha 594 
  def checkGrnImeiStatus(self, imeiNos):
595 
    """
596 
    Parameters:
597 
     - imeiNos
598 
    """
599 
    pass
10886 manish.sha 600 
 
12800 manish.sha 601 
  def getInventoryAgeConsideredItems(self, itemId):
602 
    """
603 
    Parameters:
604 
     - itemId
605 
    """
606 
    pass
12531 manish.sha 607 
 
12800 manish.sha 608 
 
3376 rajveer 609 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
2821 chandransh 610 
  def __init__(self, iprot, oprot=None):
3376 rajveer 611 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
2821 chandransh 612 
 
4501 mandeep.dh 613 
  def getInventoryItem(self, serialNumber):
2832 chandransh 614 
    """
4501 mandeep.dh 615 
    Retrieves serialized inventory item given a serial number
3431 rajveer 616 
 
2832 chandransh 617 
    Parameters:
4501 mandeep.dh 618 
     - serialNumber
2832 chandransh 619 
    """
4501 mandeep.dh 620 
    self.send_getInventoryItem(serialNumber)
621 
    return self.recv_getInventoryItem()
2832 chandransh 622 
 
4501 mandeep.dh 623 
  def send_getInventoryItem(self, serialNumber):
624 
    self._oprot.writeMessageBegin('getInventoryItem', TMessageType.CALL, self._seqid)
625 
    args = getInventoryItem_args()
626 
    args.serialNumber = serialNumber
2832 chandransh 627 
    args.write(self._oprot)
628 
    self._oprot.writeMessageEnd()
629 
    self._oprot.trans.flush()
630 
 
4501 mandeep.dh 631 
  def recv_getInventoryItem(self, ):
2832 chandransh 632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
633 
    if mtype == TMessageType.EXCEPTION:
634 
      x = TApplicationException()
635 
      x.read(self._iprot)
636 
      self._iprot.readMessageEnd()
637 
      raise x
4501 mandeep.dh 638 
    result = getInventoryItem_result()
2832 chandransh 639 
    result.read(self._iprot)
640 
    self._iprot.readMessageEnd()
3431 rajveer 641 
    if result.success is not None:
2832 chandransh 642 
      return result.success
4541 mandeep.dh 643 
    if result.wex is not None:
644 
      raise result.wex
4501 mandeep.dh 645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItem failed: unknown result");
2832 chandransh 646 
 
8565 amar.kumar 647 
  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId):
2821 chandransh 648 
    """
5361 mandeep.dh 649 
    Retrieves non-serialized inventory item from a given supplier
3431 rajveer 650 
 
2821 chandransh 651 
    Parameters:
5530 mandeep.dh 652 
     - itemNumber
4501 mandeep.dh 653 
     - itemId
5530 mandeep.dh 654 
     - fulfilmentWarehouseId
8565 amar.kumar 655 
     - billingWarehouseId
2821 chandransh 656 
    """
8565 amar.kumar 657 
    self.send_getNonSeralizedInventoryItem(itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId)
5361 mandeep.dh 658 
    return self.recv_getNonSeralizedInventoryItem()
2821 chandransh 659 
 
8565 amar.kumar 660 
  def send_getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId, billingWarehouseId):
5361 mandeep.dh 661 
    self._oprot.writeMessageBegin('getNonSeralizedInventoryItem', TMessageType.CALL, self._seqid)
662 
    args = getNonSeralizedInventoryItem_args()
5530 mandeep.dh 663 
    args.itemNumber = itemNumber
4501 mandeep.dh 664 
    args.itemId = itemId
5530 mandeep.dh 665 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
8565 amar.kumar 666 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 667 
    args.write(self._oprot)
668 
    self._oprot.writeMessageEnd()
669 
    self._oprot.trans.flush()
670 
 
5361 mandeep.dh 671 
  def recv_getNonSeralizedInventoryItem(self, ):
2821 chandransh 672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
673 
    if mtype == TMessageType.EXCEPTION:
674 
      x = TApplicationException()
675 
      x.read(self._iprot)
676 
      self._iprot.readMessageEnd()
677 
      raise x
5361 mandeep.dh 678 
    result = getNonSeralizedInventoryItem_result()
2821 chandransh 679 
    result.read(self._iprot)
680 
    self._iprot.readMessageEnd()
3431 rajveer 681 
    if result.success is not None:
2821 chandransh 682 
      return result.success
5361 mandeep.dh 683 
    if result.wex is not None:
684 
      raise result.wex
685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");
2821 chandransh 686 
 
7410 amar.kumar 687 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
3383 chandransh 688 
    """
4501 mandeep.dh 689 
    Scan non-serialized items.
3431 rajveer 690 
 
2821 chandransh 691 
    Parameters:
5361 mandeep.dh 692 
     - inventoryItem
2821 chandransh 693 
     - type
4501 mandeep.dh 694 
     - quantity
5361 mandeep.dh 695 
     - billingWarehouseId
7410 amar.kumar 696 
     - transferLotId
2821 chandransh 697 
    """
7410 amar.kumar 698 
    self.send_scan(inventoryItem, type, quantity, billingWarehouseId, transferLotId)
4501 mandeep.dh 699 
    self.recv_scan()
2821 chandransh 700 
 
7410 amar.kumar 701 
  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId, transferLotId):
4501 mandeep.dh 702 
    self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
703 
    args = scan_args()
5361 mandeep.dh 704 
    args.inventoryItem = inventoryItem
2821 chandransh 705 
    args.type = type
4501 mandeep.dh 706 
    args.quantity = quantity
5361 mandeep.dh 707 
    args.billingWarehouseId = billingWarehouseId
7410 amar.kumar 708 
    args.transferLotId = transferLotId
2821 chandransh 709 
    args.write(self._oprot)
710 
    self._oprot.writeMessageEnd()
711 
    self._oprot.trans.flush()
712 
 
4501 mandeep.dh 713 
  def recv_scan(self, ):
2821 chandransh 714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
715 
    if mtype == TMessageType.EXCEPTION:
716 
      x = TApplicationException()
717 
      x.read(self._iprot)
718 
      self._iprot.readMessageEnd()
719 
      raise x
4501 mandeep.dh 720 
    result = scan_result()
2821 chandransh 721 
    result.read(self._iprot)
722 
    self._iprot.readMessageEnd()
3431 rajveer 723 
    if result.wex is not None:
2821 chandransh 724 
      raise result.wex
725 
    return
726 
 
10489 amar.kumar 727 
  def genericScan(self, inventoryItem, scan):
728 
    """
729 
    Scan non-serialized items.
730 
 
731 
    Parameters:
732 
     - inventoryItem
733 
     - scan
734 
    """
735 
    self.send_genericScan(inventoryItem, scan)
736 
    self.recv_genericScan()
737 
 
738 
  def send_genericScan(self, inventoryItem, scan):
739 
    self._oprot.writeMessageBegin('genericScan', TMessageType.CALL, self._seqid)
740 
    args = genericScan_args()
741 
    args.inventoryItem = inventoryItem
742 
    args.scan = scan
743 
    args.write(self._oprot)
744 
    self._oprot.writeMessageEnd()
745 
    self._oprot.trans.flush()
746 
 
747 
  def recv_genericScan(self, ):
748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
749 
    if mtype == TMessageType.EXCEPTION:
750 
      x = TApplicationException()
751 
      x.read(self._iprot)
752 
      self._iprot.readMessageEnd()
753 
      raise x
754 
    result = genericScan_result()
755 
    result.read(self._iprot)
756 
    self._iprot.readMessageEnd()
757 
    if result.wex is not None:
758 
      raise result.wex
759 
    return
760 
 
5110 mandeep.dh 761 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
2821 chandransh 762 
    """
4501 mandeep.dh 763 
    Scan serialized items linked with an order. Returns its price.
3431 rajveer 764 
 
2821 chandransh 765 
    Parameters:
4555 mandeep.dh 766 
     - serialNumber
2821 chandransh 767 
     - type
4501 mandeep.dh 768 
     - orderId
5110 mandeep.dh 769 
     - fulfilmentWarehouseId
770 
     - quantity
771 
     - billingWarehouseId
2821 chandransh 772 
    """
5110 mandeep.dh 773 
    self.send_scanSerializedItemForOrder(serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
4501 mandeep.dh 774 
    return self.recv_scanSerializedItemForOrder()
2821 chandransh 775 
 
5110 mandeep.dh 776 
  def send_scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 777 
    self._oprot.writeMessageBegin('scanSerializedItemForOrder', TMessageType.CALL, self._seqid)
778 
    args = scanSerializedItemForOrder_args()
4555 mandeep.dh 779 
    args.serialNumber = serialNumber
2821 chandransh 780 
    args.type = type
4501 mandeep.dh 781 
    args.orderId = orderId
5110 mandeep.dh 782 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
783 
    args.quantity = quantity
784 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 785 
    args.write(self._oprot)
786 
    self._oprot.writeMessageEnd()
787 
    self._oprot.trans.flush()
788 
 
4501 mandeep.dh 789 
  def recv_scanSerializedItemForOrder(self, ):
2821 chandransh 790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
791 
    if mtype == TMessageType.EXCEPTION:
792 
      x = TApplicationException()
793 
      x.read(self._iprot)
794 
      self._iprot.readMessageEnd()
795 
      raise x
4501 mandeep.dh 796 
    result = scanSerializedItemForOrder_result()
2821 chandransh 797 
    result.read(self._iprot)
798 
    self._iprot.readMessageEnd()
4501 mandeep.dh 799 
    if result.success is not None:
800 
      return result.success
3431 rajveer 801 
    if result.wex is not None:
2821 chandransh 802 
      raise result.wex
4501 mandeep.dh 803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanSerializedItemForOrder failed: unknown result");
804 
 
5361 mandeep.dh 805 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 806 
    """
807 
    Scan non-serialized items linked with an order.
808 
 
809 
    Parameters:
5361 mandeep.dh 810 
     - inventoryItem
4501 mandeep.dh 811 
     - type
812 
     - quantity
813 
     - orderId
5110 mandeep.dh 814 
     - fulfilmentWarehouseId
5361 mandeep.dh 815 
     - billingWarehouseId
4501 mandeep.dh 816 
    """
5361 mandeep.dh 817 
    self.send_scanForOrder(inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId)
818 
    return self.recv_scanForOrder()
4501 mandeep.dh 819 
 
5361 mandeep.dh 820 
  def send_scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 821 
    self._oprot.writeMessageBegin('scanForOrder', TMessageType.CALL, self._seqid)
822 
    args = scanForOrder_args()
5361 mandeep.dh 823 
    args.inventoryItem = inventoryItem
4501 mandeep.dh 824 
    args.type = type
825 
    args.quantity = quantity
826 
    args.orderId = orderId
5110 mandeep.dh 827 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 828 
    args.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 829 
    args.write(self._oprot)
830 
    self._oprot.writeMessageEnd()
831 
    self._oprot.trans.flush()
832 
 
833 
  def recv_scanForOrder(self, ):
834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
835 
    if mtype == TMessageType.EXCEPTION:
836 
      x = TApplicationException()
837 
      x.read(self._iprot)
838 
      self._iprot.readMessageEnd()
839 
      raise x
840 
    result = scanForOrder_result()
841 
    result.read(self._iprot)
842 
    self._iprot.readMessageEnd()
5361 mandeep.dh 843 
    if result.success is not None:
844 
      return result.success
4501 mandeep.dh 845 
    if result.wex is not None:
846 
      raise result.wex
5361 mandeep.dh 847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOrder failed: unknown result");
2821 chandransh 848 
 
4501 mandeep.dh 849 
  def createItemNumberMapping(self, itemNumber, itemId):
850 
    """
851 
    Created item number to item id mapping
2821 chandransh 852 
 
4501 mandeep.dh 853 
    Parameters:
854 
     - itemNumber
855 
     - itemId
856 
    """
857 
    self.send_createItemNumberMapping(itemNumber, itemId)
858 
    self.recv_createItemNumberMapping()
859 
 
860 
  def send_createItemNumberMapping(self, itemNumber, itemId):
861 
    self._oprot.writeMessageBegin('createItemNumberMapping', TMessageType.CALL, self._seqid)
862 
    args = createItemNumberMapping_args()
863 
    args.itemNumber = itemNumber
864 
    args.itemId = itemId
865 
    args.write(self._oprot)
866 
    self._oprot.writeMessageEnd()
867 
    self._oprot.trans.flush()
868 
 
869 
  def recv_createItemNumberMapping(self, ):
870 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
871 
    if mtype == TMessageType.EXCEPTION:
872 
      x = TApplicationException()
873 
      x.read(self._iprot)
874 
      self._iprot.readMessageEnd()
875 
      raise x
876 
    result = createItemNumberMapping_result()
877 
    result.read(self._iprot)
878 
    self._iprot.readMessageEnd()
879 
    return
880 
 
4620 amit.gupta 881 
  def getItemNumbers(self, itemId):
882 
    """
883 
    Get itemNumber mappings for itemId
4501 mandeep.dh 884 
 
4620 amit.gupta 885 
    Parameters:
886 
     - itemId
887 
    """
888 
    self.send_getItemNumbers(itemId)
889 
    return self.recv_getItemNumbers()
890 
 
891 
  def send_getItemNumbers(self, itemId):
892 
    self._oprot.writeMessageBegin('getItemNumbers', TMessageType.CALL, self._seqid)
893 
    args = getItemNumbers_args()
894 
    args.itemId = itemId
895 
    args.write(self._oprot)
896 
    self._oprot.writeMessageEnd()
897 
    self._oprot.trans.flush()
898 
 
899 
  def recv_getItemNumbers(self, ):
900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
901 
    if mtype == TMessageType.EXCEPTION:
902 
      x = TApplicationException()
903 
      x.read(self._iprot)
904 
      self._iprot.readMessageEnd()
905 
      raise x
906 
    result = getItemNumbers_result()
907 
    result.read(self._iprot)
908 
    self._iprot.readMessageEnd()
909 
    if result.success is not None:
910 
      return result.success
911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemNumbers failed: unknown result");
912 
 
5110 mandeep.dh 913 
  def getItemIds(self, itemNumber):
914 
    """
915 
    Gets item ids for a given item number
4620 amit.gupta 916 
 
5110 mandeep.dh 917 
    Parameters:
918 
     - itemNumber
919 
    """
920 
    self.send_getItemIds(itemNumber)
921 
    return self.recv_getItemIds()
922 
 
923 
  def send_getItemIds(self, itemNumber):
924 
    self._oprot.writeMessageBegin('getItemIds', TMessageType.CALL, self._seqid)
925 
    args = getItemIds_args()
926 
    args.itemNumber = itemNumber
927 
    args.write(self._oprot)
928 
    self._oprot.writeMessageEnd()
929 
    self._oprot.trans.flush()
930 
 
931 
  def recv_getItemIds(self, ):
932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
933 
    if mtype == TMessageType.EXCEPTION:
934 
      x = TApplicationException()
935 
      x.read(self._iprot)
936 
      self._iprot.readMessageEnd()
937 
      raise x
938 
    result = getItemIds_result()
939 
    result.read(self._iprot)
940 
    self._iprot.readMessageEnd()
941 
    if result.success is not None:
942 
      return result.success
943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemIds failed: unknown result");
944 
 
5185 mandeep.dh 945 
  def getInventoryItemsFromLastScanType(self, lastScanType):
946 
    """
947 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 948 
 
5185 mandeep.dh 949 
    Parameters:
950 
     - lastScanType
951 
    """
952 
    self.send_getInventoryItemsFromLastScanType(lastScanType)
953 
    return self.recv_getInventoryItemsFromLastScanType()
954 
 
955 
  def send_getInventoryItemsFromLastScanType(self, lastScanType):
956 
    self._oprot.writeMessageBegin('getInventoryItemsFromLastScanType', TMessageType.CALL, self._seqid)
957 
    args = getInventoryItemsFromLastScanType_args()
958 
    args.lastScanType = lastScanType
959 
    args.write(self._oprot)
960 
    self._oprot.writeMessageEnd()
961 
    self._oprot.trans.flush()
962 
 
963 
  def recv_getInventoryItemsFromLastScanType(self, ):
964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
965 
    if mtype == TMessageType.EXCEPTION:
966 
      x = TApplicationException()
967 
      x.read(self._iprot)
968 
      self._iprot.readMessageEnd()
969 
      raise x
970 
    result = getInventoryItemsFromLastScanType_result()
971 
    result.read(self._iprot)
972 
    self._iprot.readMessageEnd()
973 
    if result.success is not None:
974 
      return result.success
975 
    if result.wex is not None:
976 
      raise result.wex
977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsFromLastScanType failed: unknown result");
978 
 
979 
  def getInventoryItemFromId(self, inventoryItemId):
980 
    """
981 
    Retrieves inventory item given a inventoryItem id
982 
 
983 
    Parameters:
984 
     - inventoryItemId
985 
    """
986 
    self.send_getInventoryItemFromId(inventoryItemId)
987 
    return self.recv_getInventoryItemFromId()
988 
 
989 
  def send_getInventoryItemFromId(self, inventoryItemId):
990 
    self._oprot.writeMessageBegin('getInventoryItemFromId', TMessageType.CALL, self._seqid)
991 
    args = getInventoryItemFromId_args()
992 
    args.inventoryItemId = inventoryItemId
993 
    args.write(self._oprot)
994 
    self._oprot.writeMessageEnd()
995 
    self._oprot.trans.flush()
996 
 
997 
  def recv_getInventoryItemFromId(self, ):
998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
999 
    if mtype == TMessageType.EXCEPTION:
1000 
      x = TApplicationException()
1001 
      x.read(self._iprot)
1002 
      self._iprot.readMessageEnd()
1003 
      raise x
1004 
    result = getInventoryItemFromId_result()
1005 
    result.read(self._iprot)
1006 
    self._iprot.readMessageEnd()
1007 
    if result.success is not None:
1008 
      return result.success
1009 
    if result.wex is not None:
1010 
      raise result.wex
1011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromId failed: unknown result");
1012 
 
5372 mandeep.dh 1013 
  def getPurchaseScans(self, startDate, endDate):
1014 
    """
1015 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 1016 
 
5372 mandeep.dh 1017 
    Parameters:
1018 
     - startDate
1019 
     - endDate
1020 
    """
1021 
    self.send_getPurchaseScans(startDate, endDate)
1022 
    return self.recv_getPurchaseScans()
1023 
 
1024 
  def send_getPurchaseScans(self, startDate, endDate):
1025 
    self._oprot.writeMessageBegin('getPurchaseScans', TMessageType.CALL, self._seqid)
1026 
    args = getPurchaseScans_args()
1027 
    args.startDate = startDate
1028 
    args.endDate = endDate
1029 
    args.write(self._oprot)
1030 
    self._oprot.writeMessageEnd()
1031 
    self._oprot.trans.flush()
1032 
 
1033 
  def recv_getPurchaseScans(self, ):
1034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1035 
    if mtype == TMessageType.EXCEPTION:
1036 
      x = TApplicationException()
1037 
      x.read(self._iprot)
1038 
      self._iprot.readMessageEnd()
1039 
      raise x
1040 
    result = getPurchaseScans_result()
1041 
    result.read(self._iprot)
1042 
    self._iprot.readMessageEnd()
1043 
    if result.success is not None:
1044 
      return result.success
1045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScans failed: unknown result");
1046 
 
7216 amar.kumar 1047 
  def getPurchaseScansByGrnDate(self, startDate, endDate):
1048 
    """
1049 
    Returns the purchase scans between grn dates grouped by items for Purchase register reconciliation
1050 
 
1051 
    Parameters:
1052 
     - startDate
1053 
     - endDate
1054 
    """
1055 
    self.send_getPurchaseScansByGrnDate(startDate, endDate)
1056 
    return self.recv_getPurchaseScansByGrnDate()
1057 
 
1058 
  def send_getPurchaseScansByGrnDate(self, startDate, endDate):
1059 
    self._oprot.writeMessageBegin('getPurchaseScansByGrnDate', TMessageType.CALL, self._seqid)
1060 
    args = getPurchaseScansByGrnDate_args()
1061 
    args.startDate = startDate
1062 
    args.endDate = endDate
1063 
    args.write(self._oprot)
1064 
    self._oprot.writeMessageEnd()
1065 
    self._oprot.trans.flush()
1066 
 
1067 
  def recv_getPurchaseScansByGrnDate(self, ):
1068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1069 
    if mtype == TMessageType.EXCEPTION:
1070 
      x = TApplicationException()
1071 
      x.read(self._iprot)
1072 
      self._iprot.readMessageEnd()
1073 
      raise x
1074 
    result = getPurchaseScansByGrnDate_result()
1075 
    result.read(self._iprot)
1076 
    self._iprot.readMessageEnd()
1077 
    if result.success is not None:
1078 
      return result.success
1079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScansByGrnDate failed: unknown result");
1080 
 
10407 amar.kumar 1081 
  def getEmptyGrnsByDate(self, startDate, endDate):
1082 
    """
1083 
    Returns the empty grn-ids between grn dates
1084 
 
1085 
    Parameters:
1086 
     - startDate
1087 
     - endDate
1088 
    """
1089 
    self.send_getEmptyGrnsByDate(startDate, endDate)
1090 
    return self.recv_getEmptyGrnsByDate()
1091 
 
1092 
  def send_getEmptyGrnsByDate(self, startDate, endDate):
1093 
    self._oprot.writeMessageBegin('getEmptyGrnsByDate', TMessageType.CALL, self._seqid)
1094 
    args = getEmptyGrnsByDate_args()
1095 
    args.startDate = startDate
1096 
    args.endDate = endDate
1097 
    args.write(self._oprot)
1098 
    self._oprot.writeMessageEnd()
1099 
    self._oprot.trans.flush()
1100 
 
1101 
  def recv_getEmptyGrnsByDate(self, ):
1102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1103 
    if mtype == TMessageType.EXCEPTION:
1104 
      x = TApplicationException()
1105 
      x.read(self._iprot)
1106 
      self._iprot.readMessageEnd()
1107 
      raise x
1108 
    result = getEmptyGrnsByDate_result()
1109 
    result.read(self._iprot)
1110 
    self._iprot.readMessageEnd()
1111 
    if result.success is not None:
1112 
      return result.success
1113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEmptyGrnsByDate failed: unknown result");
1114 
 
5496 mandeep.dh 1115 
  def fetchScansPerInvoiceNumber(self, date):
1116 
    """
1117 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 1118 
 
5496 mandeep.dh 1119 
    Parameters:
1120 
     - date
1121 
    """
1122 
    self.send_fetchScansPerInvoiceNumber(date)
1123 
    return self.recv_fetchScansPerInvoiceNumber()
1124 
 
1125 
  def send_fetchScansPerInvoiceNumber(self, date):
1126 
    self._oprot.writeMessageBegin('fetchScansPerInvoiceNumber', TMessageType.CALL, self._seqid)
1127 
    args = fetchScansPerInvoiceNumber_args()
1128 
    args.date = date
1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_fetchScansPerInvoiceNumber(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = fetchScansPerInvoiceNumber_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
1143 
    if result.success is not None:
1144 
      return result.success
1145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerInvoiceNumber failed: unknown result");
1146 
 
5620 mandeep.dh 1147 
  def getInventoryItemFromOrder(self, orderId):
1148 
    """
1149 
    Returns inventory item for a given order
5496 mandeep.dh 1150 
 
5620 mandeep.dh 1151 
    Parameters:
1152 
     - orderId
1153 
    """
1154 
    self.send_getInventoryItemFromOrder(orderId)
1155 
    return self.recv_getInventoryItemFromOrder()
1156 
 
1157 
  def send_getInventoryItemFromOrder(self, orderId):
1158 
    self._oprot.writeMessageBegin('getInventoryItemFromOrder', TMessageType.CALL, self._seqid)
1159 
    args = getInventoryItemFromOrder_args()
1160 
    args.orderId = orderId
1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_getInventoryItemFromOrder(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = getInventoryItemFromOrder_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
1175 
    if result.success is not None:
1176 
      return result.success
1177 
    if result.we is not None:
1178 
      raise result.we
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromOrder failed: unknown result");
1180 
 
5711 mandeep.dh 1181 
  def getInventoryAge(self, ):
1182 
    """
1183 
    Fetches the stock inventory age week-wise
1184 
    """
1185 
    self.send_getInventoryAge()
1186 
    return self.recv_getInventoryAge()
5620 mandeep.dh 1187 
 
5711 mandeep.dh 1188 
  def send_getInventoryAge(self, ):
1189 
    self._oprot.writeMessageBegin('getInventoryAge', TMessageType.CALL, self._seqid)
1190 
    args = getInventoryAge_args()
1191 
    args.write(self._oprot)
1192 
    self._oprot.writeMessageEnd()
1193 
    self._oprot.trans.flush()
1194 
 
1195 
  def recv_getInventoryAge(self, ):
1196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1197 
    if mtype == TMessageType.EXCEPTION:
1198 
      x = TApplicationException()
1199 
      x.read(self._iprot)
1200 
      self._iprot.readMessageEnd()
1201 
      raise x
1202 
    result = getInventoryAge_result()
1203 
    result.read(self._iprot)
1204 
    self._iprot.readMessageEnd()
1205 
    if result.success is not None:
1206 
      return result.success
1207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAge failed: unknown result");
1208 
 
6361 rajveer 1209 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
1210 
    """
1211 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 1212 
 
6361 rajveer 1213 
    Parameters:
1214 
     - itemId
1215 
     - fromDate
1216 
     - toDate
1217 
    """
1218 
    self.send_getInventoryScansForItem(itemId, fromDate, toDate)
1219 
    return self.recv_getInventoryScansForItem()
1220 
 
1221 
  def send_getInventoryScansForItem(self, itemId, fromDate, toDate):
1222 
    self._oprot.writeMessageBegin('getInventoryScansForItem', TMessageType.CALL, self._seqid)
1223 
    args = getInventoryScansForItem_args()
1224 
    args.itemId = itemId
1225 
    args.fromDate = fromDate
1226 
    args.toDate = toDate
1227 
    args.write(self._oprot)
1228 
    self._oprot.writeMessageEnd()
1229 
    self._oprot.trans.flush()
1230 
 
1231 
  def recv_getInventoryScansForItem(self, ):
1232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1233 
    if mtype == TMessageType.EXCEPTION:
1234 
      x = TApplicationException()
1235 
      x.read(self._iprot)
1236 
      self._iprot.readMessageEnd()
1237 
      raise x
1238 
    result = getInventoryScansForItem_result()
1239 
    result.read(self._iprot)
1240 
    self._iprot.readMessageEnd()
1241 
    if result.success is not None:
1242 
      return result.success
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryScansForItem failed: unknown result");
1244 
 
1245 
  def getScanRecordsForSerialNumber(self, serialNumber):
1246 
    """
1247 
    Fetches the scanRecords for a given serialNumber for a given time interval
1248 
 
1249 
    Parameters:
1250 
     - serialNumber
1251 
    """
1252 
    self.send_getScanRecordsForSerialNumber(serialNumber)
1253 
    return self.recv_getScanRecordsForSerialNumber()
1254 
 
1255 
  def send_getScanRecordsForSerialNumber(self, serialNumber):
1256 
    self._oprot.writeMessageBegin('getScanRecordsForSerialNumber', TMessageType.CALL, self._seqid)
1257 
    args = getScanRecordsForSerialNumber_args()
1258 
    args.serialNumber = serialNumber
1259 
    args.write(self._oprot)
1260 
    self._oprot.writeMessageEnd()
1261 
    self._oprot.trans.flush()
1262 
 
1263 
  def recv_getScanRecordsForSerialNumber(self, ):
1264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1265 
    if mtype == TMessageType.EXCEPTION:
1266 
      x = TApplicationException()
1267 
      x.read(self._iprot)
1268 
      self._iprot.readMessageEnd()
1269 
      raise x
1270 
    result = getScanRecordsForSerialNumber_result()
1271 
    result.read(self._iprot)
1272 
    self._iprot.readMessageEnd()
1273 
    if result.success is not None:
1274 
      return result.success
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScanRecordsForSerialNumber failed: unknown result");
1276 
 
7718 amar.kumar 1277 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
6467 amar.kumar 1278 
    """
6630 amar.kumar 1279 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 1280 
 
6467 amar.kumar 1281 
    Parameters:
1282 
     - saleReturnItems
1283 
     - vendorId
7718 amar.kumar 1284 
     - billingWarehouseId
6467 amar.kumar 1285 
    """
7718 amar.kumar 1286 
    self.send_scanForPurchaseReturn(saleReturnItems, vendorId, billingWarehouseId)
10864 manish.sha 1287 
    return self.recv_scanForPurchaseReturn()
6467 amar.kumar 1288 
 
7718 amar.kumar 1289 
  def send_scanForPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
6467 amar.kumar 1290 
    self._oprot.writeMessageBegin('scanForPurchaseReturn', TMessageType.CALL, self._seqid)
1291 
    args = scanForPurchaseReturn_args()
1292 
    args.saleReturnItems = saleReturnItems
1293 
    args.vendorId = vendorId
7718 amar.kumar 1294 
    args.billingWarehouseId = billingWarehouseId
6467 amar.kumar 1295 
    args.write(self._oprot)
1296 
    self._oprot.writeMessageEnd()
1297 
    self._oprot.trans.flush()
1298 
 
1299 
  def recv_scanForPurchaseReturn(self, ):
1300 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1301 
    if mtype == TMessageType.EXCEPTION:
1302 
      x = TApplicationException()
1303 
      x.read(self._iprot)
1304 
      self._iprot.readMessageEnd()
1305 
      raise x
1306 
    result = scanForPurchaseReturn_result()
1307 
    result.read(self._iprot)
1308 
    self._iprot.readMessageEnd()
10864 manish.sha 1309 
    if result.success is not None:
1310 
      return result.success
6467 amar.kumar 1311 
    if result.ex is not None:
1312 
      raise result.ex
10864 manish.sha 1313 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForPurchaseReturn failed: unknown result");
6467 amar.kumar 1314 
 
7718 amar.kumar 1315 
  def scanForLostItem(self, lostItems, vendorId, billingWarehouseId):
6630 amar.kumar 1316 
    """
1317 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 1318 
 
6630 amar.kumar 1319 
    Parameters:
1320 
     - lostItems
1321 
     - vendorId
7718 amar.kumar 1322 
     - billingWarehouseId
6630 amar.kumar 1323 
    """
7718 amar.kumar 1324 
    self.send_scanForLostItem(lostItems, vendorId, billingWarehouseId)
6630 amar.kumar 1325 
    self.recv_scanForLostItem()
1326 
 
7718 amar.kumar 1327 
  def send_scanForLostItem(self, lostItems, vendorId, billingWarehouseId):
6630 amar.kumar 1328 
    self._oprot.writeMessageBegin('scanForLostItem', TMessageType.CALL, self._seqid)
1329 
    args = scanForLostItem_args()
1330 
    args.lostItems = lostItems
1331 
    args.vendorId = vendorId
7718 amar.kumar 1332 
    args.billingWarehouseId = billingWarehouseId
6630 amar.kumar 1333 
    args.write(self._oprot)
1334 
    self._oprot.writeMessageEnd()
1335 
    self._oprot.trans.flush()
1336 
 
1337 
  def recv_scanForLostItem(self, ):
1338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1339 
    if mtype == TMessageType.EXCEPTION:
1340 
      x = TApplicationException()
1341 
      x.read(self._iprot)
1342 
      self._iprot.readMessageEnd()
1343 
      raise x
1344 
    result = scanForLostItem_result()
1345 
    result.read(self._iprot)
1346 
    self._iprot.readMessageEnd()
1347 
    if result.ex is not None:
1348 
      raise result.ex
1349 
    return
1350 
 
7715 vikram.rag 1351 
  def getCurrentSerializedInventoryByScans(self, physicalWarehouseId):
6630 amar.kumar 1352 
    """
1353 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
7715 vikram.rag 1354 
 
1355 
    Parameters:
1356 
     - physicalWarehouseId
6630 amar.kumar 1357 
    """
7715 vikram.rag 1358 
    self.send_getCurrentSerializedInventoryByScans(physicalWarehouseId)
6630 amar.kumar 1359 
    return self.recv_getCurrentSerializedInventoryByScans()
1360 
 
7715 vikram.rag 1361 
  def send_getCurrentSerializedInventoryByScans(self, physicalWarehouseId):
6630 amar.kumar 1362 
    self._oprot.writeMessageBegin('getCurrentSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1363 
    args = getCurrentSerializedInventoryByScans_args()
7715 vikram.rag 1364 
    args.physicalWarehouseId = physicalWarehouseId
6630 amar.kumar 1365 
    args.write(self._oprot)
1366 
    self._oprot.writeMessageEnd()
1367 
    self._oprot.trans.flush()
1368 
 
1369 
  def recv_getCurrentSerializedInventoryByScans(self, ):
1370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1371 
    if mtype == TMessageType.EXCEPTION:
1372 
      x = TApplicationException()
1373 
      x.read(self._iprot)
1374 
      self._iprot.readMessageEnd()
1375 
      raise x
1376 
    result = getCurrentSerializedInventoryByScans_result()
1377 
    result.read(self._iprot)
1378 
    self._iprot.readMessageEnd()
1379 
    if result.success is not None:
1380 
      return result.success
1381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentSerializedInventoryByScans failed: unknown result");
1382 
 
7715 vikram.rag 1383 
  def getCurrentNonSerializedInventoryByScans(self, physicalWarehouseId):
6630 amar.kumar 1384 
    """
1385 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
7715 vikram.rag 1386 
 
1387 
    Parameters:
1388 
     - physicalWarehouseId
6630 amar.kumar 1389 
    """
7715 vikram.rag 1390 
    self.send_getCurrentNonSerializedInventoryByScans(physicalWarehouseId)
6630 amar.kumar 1391 
    return self.recv_getCurrentNonSerializedInventoryByScans()
1392 
 
7715 vikram.rag 1393 
  def send_getCurrentNonSerializedInventoryByScans(self, physicalWarehouseId):
6630 amar.kumar 1394 
    self._oprot.writeMessageBegin('getCurrentNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1395 
    args = getCurrentNonSerializedInventoryByScans_args()
7715 vikram.rag 1396 
    args.physicalWarehouseId = physicalWarehouseId
6630 amar.kumar 1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_getCurrentNonSerializedInventoryByScans(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = getCurrentNonSerializedInventoryByScans_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success is not None:
1412 
      return result.success
1413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentNonSerializedInventoryByScans failed: unknown result");
1414 
 
6762 amar.kumar 1415 
  def getHistoricSerializedInventoryByScans(self, date):
1416 
    """
1417 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
6630 amar.kumar 1418 
 
6762 amar.kumar 1419 
    Parameters:
1420 
     - date
1421 
    """
1422 
    self.send_getHistoricSerializedInventoryByScans(date)
1423 
    return self.recv_getHistoricSerializedInventoryByScans()
1424 
 
1425 
  def send_getHistoricSerializedInventoryByScans(self, date):
1426 
    self._oprot.writeMessageBegin('getHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1427 
    args = getHistoricSerializedInventoryByScans_args()
1428 
    args.date = date
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getHistoricSerializedInventoryByScans(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getHistoricSerializedInventoryByScans_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success is not None:
1444 
      return result.success
1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricSerializedInventoryByScans failed: unknown result");
1446 
 
1447 
  def getHistoricNonSerializedInventoryByScans(self, date):
1448 
    """
1449 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
1450 
 
1451 
    Parameters:
1452 
     - date
1453 
    """
1454 
    self.send_getHistoricNonSerializedInventoryByScans(date)
1455 
    return self.recv_getHistoricNonSerializedInventoryByScans()
1456 
 
1457 
  def send_getHistoricNonSerializedInventoryByScans(self, date):
1458 
    self._oprot.writeMessageBegin('getHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1459 
    args = getHistoricNonSerializedInventoryByScans_args()
1460 
    args.date = date
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_getHistoricNonSerializedInventoryByScans(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = getHistoricNonSerializedInventoryByScans_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
1475 
    if result.success is not None:
1476 
      return result.success
1477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricNonSerializedInventoryByScans failed: unknown result");
1478 
 
10407 amar.kumar 1479 
  def getOurHistoricSerializedInventoryByScans(self, date):
1480 
    """
1481 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
1482 
 
1483 
    Parameters:
1484 
     - date
1485 
    """
1486 
    self.send_getOurHistoricSerializedInventoryByScans(date)
1487 
    return self.recv_getOurHistoricSerializedInventoryByScans()
1488 
 
1489 
  def send_getOurHistoricSerializedInventoryByScans(self, date):
1490 
    self._oprot.writeMessageBegin('getOurHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1491 
    args = getOurHistoricSerializedInventoryByScans_args()
1492 
    args.date = date
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getOurHistoricSerializedInventoryByScans(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getOurHistoricSerializedInventoryByScans_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
1507 
    if result.success is not None:
1508 
      return result.success
1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricSerializedInventoryByScans failed: unknown result");
1510 
 
1511 
  def getOurHistoricNonSerializedInventoryByScans(self, date):
1512 
    """
1513 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
1514 
 
1515 
    Parameters:
1516 
     - date
1517 
    """
1518 
    self.send_getOurHistoricNonSerializedInventoryByScans(date)
1519 
    return self.recv_getOurHistoricNonSerializedInventoryByScans()
1520 
 
1521 
  def send_getOurHistoricNonSerializedInventoryByScans(self, date):
1522 
    self._oprot.writeMessageBegin('getOurHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1523 
    args = getOurHistoricNonSerializedInventoryByScans_args()
1524 
    args.date = date
1525 
    args.write(self._oprot)
1526 
    self._oprot.writeMessageEnd()
1527 
    self._oprot.trans.flush()
1528 
 
1529 
  def recv_getOurHistoricNonSerializedInventoryByScans(self, ):
1530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1531 
    if mtype == TMessageType.EXCEPTION:
1532 
      x = TApplicationException()
1533 
      x.read(self._iprot)
1534 
      self._iprot.readMessageEnd()
1535 
      raise x
1536 
    result = getOurHistoricNonSerializedInventoryByScans_result()
1537 
    result.read(self._iprot)
1538 
    self._iprot.readMessageEnd()
1539 
    if result.success is not None:
1540 
      return result.success
1541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOurHistoricNonSerializedInventoryByScans failed: unknown result");
1542 
 
7672 rajveer 1543 
  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
6762 amar.kumar 1544 
    """
6880 amar.kumar 1545 
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1546 
 
1547 
    Parameters:
1548 
     - itemId
1549 
     - serialNumber
1550 
     - itemNumber
1551 
     - invoiceNumber
1552 
     - warehouseId
1553 
     - unitPrice
7672 rajveer 1554 
     - nlc
6762 amar.kumar 1555 
     - orderId
1556 
    """
7672 rajveer 1557 
    self.send_scanForOursExternalSale(itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId)
6762 amar.kumar 1558 
    return self.recv_scanForOursExternalSale()
1559 
 
7672 rajveer 1560 
  def send_scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, nlc, orderId):
6762 amar.kumar 1561 
    self._oprot.writeMessageBegin('scanForOursExternalSale', TMessageType.CALL, self._seqid)
1562 
    args = scanForOursExternalSale_args()
1563 
    args.itemId = itemId
1564 
    args.serialNumber = serialNumber
1565 
    args.itemNumber = itemNumber
1566 
    args.invoiceNumber = invoiceNumber
1567 
    args.warehouseId = warehouseId
1568 
    args.unitPrice = unitPrice
7672 rajveer 1569 
    args.nlc = nlc
6762 amar.kumar 1570 
    args.orderId = orderId
1571 
    args.write(self._oprot)
1572 
    self._oprot.writeMessageEnd()
1573 
    self._oprot.trans.flush()
1574 
 
1575 
  def recv_scanForOursExternalSale(self, ):
1576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1577 
    if mtype == TMessageType.EXCEPTION:
1578 
      x = TApplicationException()
1579 
      x.read(self._iprot)
1580 
      self._iprot.readMessageEnd()
1581 
      raise x
1582 
    result = scanForOursExternalSale_result()
1583 
    result.read(self._iprot)
1584 
    self._iprot.readMessageEnd()
1585 
    if result.success is not None:
1586 
      return result.success
1587 
    if result.ex is not None:
1588 
      raise result.ex
1589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOursExternalSale failed: unknown result");
1590 
 
1591 
  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
1592 
    """
6880 amar.kumar 1593 
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1594 
 
1595 
    Parameters:
1596 
     - orderId
1597 
     - unitPrice
1598 
    """
1599 
    self.send_scanForOursExternalSaleReturn(orderId, unitPrice)
1600 
    self.recv_scanForOursExternalSaleReturn()
1601 
 
1602 
  def send_scanForOursExternalSaleReturn(self, orderId, unitPrice):
1603 
    self._oprot.writeMessageBegin('scanForOursExternalSaleReturn', TMessageType.CALL, self._seqid)
1604 
    args = scanForOursExternalSaleReturn_args()
1605 
    args.orderId = orderId
1606 
    args.unitPrice = unitPrice
1607 
    args.write(self._oprot)
1608 
    self._oprot.writeMessageEnd()
1609 
    self._oprot.trans.flush()
1610 
 
1611 
  def recv_scanForOursExternalSaleReturn(self, ):
1612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1613 
    if mtype == TMessageType.EXCEPTION:
1614 
      x = TApplicationException()
1615 
      x.read(self._iprot)
1616 
      self._iprot.readMessageEnd()
1617 
      raise x
1618 
    result = scanForOursExternalSaleReturn_result()
1619 
    result.read(self._iprot)
1620 
    self._iprot.readMessageEnd()
7410 amar.kumar 1621 
    if result.ex is not None:
1622 
      raise result.ex
6762 amar.kumar 1623 
    return
1624 
 
6880 amar.kumar 1625 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1626 
    """
10407 amar.kumar 1627 
    This returns movement for each non serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
1628 
 
6880 amar.kumar 1629 
    Parameters:
1630 
     - startDate
1631 
     - endDate
1632 
    """
1633 
    self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
1634 
    return self.recv_getMovementNonSerializedInventoryByScans()
6762 amar.kumar 1635 
 
6880 amar.kumar 1636 
  def send_getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1637 
    self._oprot.writeMessageBegin('getMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1638 
    args = getMovementNonSerializedInventoryByScans_args()
1639 
    args.startDate = startDate
1640 
    args.endDate = endDate
1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
1645 
  def recv_getMovementNonSerializedInventoryByScans(self, ):
1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
1652 
    result = getMovementNonSerializedInventoryByScans_result()
1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
1655 
    if result.success is not None:
1656 
      return result.success
1657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");
1658 
 
1659 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
1660 
    """
10407 amar.kumar 1661 
    This returns movement for each serialized item in the specified window.(Doesn't include Hotspot and Amazon w/h)
1662 
 
6880 amar.kumar 1663 
    Parameters:
1664 
     - startDate
1665 
     - endDate
1666 
    """
1667 
    self.send_getMovementSerializedInventoryByScans(startDate, endDate)
1668 
    return self.recv_getMovementSerializedInventoryByScans()
1669 
 
1670 
  def send_getMovementSerializedInventoryByScans(self, startDate, endDate):
1671 
    self._oprot.writeMessageBegin('getMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1672 
    args = getMovementSerializedInventoryByScans_args()
1673 
    args.startDate = startDate
1674 
    args.endDate = endDate
1675 
    args.write(self._oprot)
1676 
    self._oprot.writeMessageEnd()
1677 
    self._oprot.trans.flush()
1678 
 
1679 
  def recv_getMovementSerializedInventoryByScans(self, ):
1680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1681 
    if mtype == TMessageType.EXCEPTION:
1682 
      x = TApplicationException()
1683 
      x.read(self._iprot)
1684 
      self._iprot.readMessageEnd()
1685 
      raise x
1686 
    result = getMovementSerializedInventoryByScans_result()
1687 
    result.read(self._iprot)
1688 
    self._iprot.readMessageEnd()
1689 
    if result.success is not None:
1690 
      return result.success
1691 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");
1692 
 
7216 amar.kumar 1693 
  def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
1694 
    """
10407 amar.kumar 1695 
    This returns movement for each serialized item in the specified window.(Doesn't include Amazon w/h)
1696 
 
7216 amar.kumar 1697 
    Parameters:
1698 
     - startDate
1699 
     - endDate
1700 
    """
1701 
    self.send_getCompleteMovementSerializedInventoryByScans(startDate, endDate)
1702 
    return self.recv_getCompleteMovementSerializedInventoryByScans()
1703 
 
1704 
  def send_getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
1705 
    self._oprot.writeMessageBegin('getCompleteMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1706 
    args = getCompleteMovementSerializedInventoryByScans_args()
1707 
    args.startDate = startDate
1708 
    args.endDate = endDate
1709 
    args.write(self._oprot)
1710 
    self._oprot.writeMessageEnd()
1711 
    self._oprot.trans.flush()
1712 
 
1713 
  def recv_getCompleteMovementSerializedInventoryByScans(self, ):
1714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1715 
    if mtype == TMessageType.EXCEPTION:
1716 
      x = TApplicationException()
1717 
      x.read(self._iprot)
1718 
      self._iprot.readMessageEnd()
1719 
      raise x
1720 
    result = getCompleteMovementSerializedInventoryByScans_result()
1721 
    result.read(self._iprot)
1722 
    self._iprot.readMessageEnd()
1723 
    if result.success is not None:
1724 
      return result.success
1725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementSerializedInventoryByScans failed: unknown result");
1726 
 
1727 
  def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
1728 
    """
10407 amar.kumar 1729 
    This returns movement for each non serialized item in the specified window.(Doesn't include Amazon w/h)
1730 
 
7216 amar.kumar 1731 
    Parameters:
1732 
     - startDate
1733 
     - endDate
1734 
    """
1735 
    self.send_getCompleteMovementNonSerializedInventoryByScans(startDate, endDate)
1736 
    return self.recv_getCompleteMovementNonSerializedInventoryByScans()
1737 
 
1738 
  def send_getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
1739 
    self._oprot.writeMessageBegin('getCompleteMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1740 
    args = getCompleteMovementNonSerializedInventoryByScans_args()
1741 
    args.startDate = startDate
1742 
    args.endDate = endDate
1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_getCompleteMovementNonSerializedInventoryByScans(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = getCompleteMovementNonSerializedInventoryByScans_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
1757 
    if result.success is not None:
1758 
      return result.success
1759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementNonSerializedInventoryByScans failed: unknown result");
1760 
 
7190 amar.kumar 1761 
  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1762 
    """
1763 
    Parameters:
1764 
     - orderId
1765 
     - freebieItemId
1766 
     - freebieWarehouseId
1767 
     - scanType
1768 
    """
1769 
    self.send_scanfreebie(orderId, freebieItemId, freebieWarehouseId, scanType)
1770 
    return self.recv_scanfreebie()
6880 amar.kumar 1771 
 
7190 amar.kumar 1772 
  def send_scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1773 
    self._oprot.writeMessageBegin('scanfreebie', TMessageType.CALL, self._seqid)
1774 
    args = scanfreebie_args()
1775 
    args.orderId = orderId
1776 
    args.freebieItemId = freebieItemId
1777 
    args.freebieWarehouseId = freebieWarehouseId
1778 
    args.scanType = scanType
1779 
    args.write(self._oprot)
1780 
    self._oprot.writeMessageEnd()
1781 
    self._oprot.trans.flush()
1782 
 
1783 
  def recv_scanfreebie(self, ):
1784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1785 
    if mtype == TMessageType.EXCEPTION:
1786 
      x = TApplicationException()
1787 
      x.read(self._iprot)
1788 
      self._iprot.readMessageEnd()
1789 
      raise x
1790 
    result = scanfreebie_result()
1791 
    result.read(self._iprot)
1792 
    self._iprot.readMessageEnd()
1793 
    if result.success is not None:
1794 
      return result.success
1795 
    if result.wex is not None:
1796 
      raise result.wex
1797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanfreebie failed: unknown result");
1798 
 
7199 amar.kumar 1799 
  def reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
1800 
    """
1801 
    Parameters:
1802 
     - oldOrderId
1803 
     - newOrderId
1804 
     - freebieItemId
1805 
     - scanType
1806 
    """
1807 
    self.send_reshipfreebie(oldOrderId, newOrderId, freebieItemId, scanType)
1808 
    self.recv_reshipfreebie()
7190 amar.kumar 1809 
 
7199 amar.kumar 1810 
  def send_reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
1811 
    self._oprot.writeMessageBegin('reshipfreebie', TMessageType.CALL, self._seqid)
1812 
    args = reshipfreebie_args()
1813 
    args.oldOrderId = oldOrderId
1814 
    args.newOrderId = newOrderId
1815 
    args.freebieItemId = freebieItemId
1816 
    args.scanType = scanType
1817 
    args.write(self._oprot)
1818 
    self._oprot.writeMessageEnd()
1819 
    self._oprot.trans.flush()
1820 
 
1821 
  def recv_reshipfreebie(self, ):
1822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1823 
    if mtype == TMessageType.EXCEPTION:
1824 
      x = TApplicationException()
1825 
      x.read(self._iprot)
1826 
      self._iprot.readMessageEnd()
1827 
      raise x
1828 
    result = reshipfreebie_result()
1829 
    result.read(self._iprot)
1830 
    self._iprot.readMessageEnd()
1831 
    if result.wex is not None:
1832 
      raise result.wex
1833 
    return
1834 
 
7410 amar.kumar 1835 
  def isItemTransferAllowed(self, warehouseId, transferWarehouseId):
1836 
    """
1837 
    Parameters:
1838 
     - warehouseId
1839 
     - transferWarehouseId
1840 
    """
1841 
    self.send_isItemTransferAllowed(warehouseId, transferWarehouseId)
1842 
    return self.recv_isItemTransferAllowed()
7199 amar.kumar 1843 
 
7410 amar.kumar 1844 
  def send_isItemTransferAllowed(self, warehouseId, transferWarehouseId):
1845 
    self._oprot.writeMessageBegin('isItemTransferAllowed', TMessageType.CALL, self._seqid)
1846 
    args = isItemTransferAllowed_args()
1847 
    args.warehouseId = warehouseId
1848 
    args.transferWarehouseId = transferWarehouseId
1849 
    args.write(self._oprot)
1850 
    self._oprot.writeMessageEnd()
1851 
    self._oprot.trans.flush()
1852 
 
1853 
  def recv_isItemTransferAllowed(self, ):
1854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1855 
    if mtype == TMessageType.EXCEPTION:
1856 
      x = TApplicationException()
1857 
      x.read(self._iprot)
1858 
      self._iprot.readMessageEnd()
1859 
      raise x
1860 
    result = isItemTransferAllowed_result()
1861 
    result.read(self._iprot)
1862 
    self._iprot.readMessageEnd()
1863 
    if result.success is not None:
1864 
      return result.success
1865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isItemTransferAllowed failed: unknown result");
1866 
 
1867 
  def createTransferLot(self, originWarehouseId, destWarehouseId):
1868 
    """
1869 
    Parameters:
1870 
     - originWarehouseId
1871 
     - destWarehouseId
1872 
    """
1873 
    self.send_createTransferLot(originWarehouseId, destWarehouseId)
1874 
    return self.recv_createTransferLot()
1875 
 
1876 
  def send_createTransferLot(self, originWarehouseId, destWarehouseId):
1877 
    self._oprot.writeMessageBegin('createTransferLot', TMessageType.CALL, self._seqid)
1878 
    args = createTransferLot_args()
1879 
    args.originWarehouseId = originWarehouseId
1880 
    args.destWarehouseId = destWarehouseId
1881 
    args.write(self._oprot)
1882 
    self._oprot.writeMessageEnd()
1883 
    self._oprot.trans.flush()
1884 
 
1885 
  def recv_createTransferLot(self, ):
1886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1887 
    if mtype == TMessageType.EXCEPTION:
1888 
      x = TApplicationException()
1889 
      x.read(self._iprot)
1890 
      self._iprot.readMessageEnd()
1891 
      raise x
1892 
    result = createTransferLot_result()
1893 
    result.read(self._iprot)
1894 
    self._iprot.readMessageEnd()
1895 
    if result.success is not None:
1896 
      return result.success
1897 
    if result.wex is not None:
1898 
      raise result.wex
1899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransferLot failed: unknown result");
1900 
 
1901 
  def getTransferLot(self, transferLotId):
1902 
    """
1903 
    Parameters:
1904 
     - transferLotId
1905 
    """
1906 
    self.send_getTransferLot(transferLotId)
1907 
    return self.recv_getTransferLot()
1908 
 
1909 
  def send_getTransferLot(self, transferLotId):
1910 
    self._oprot.writeMessageBegin('getTransferLot', TMessageType.CALL, self._seqid)
1911 
    args = getTransferLot_args()
1912 
    args.transferLotId = transferLotId
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_getTransferLot(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = getTransferLot_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
1927 
    if result.success is not None:
1928 
      return result.success
1929 
    if result.wex is not None:
1930 
      raise result.wex
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLot failed: unknown result");
1932 
 
1933 
  def markTransferLotAsReceived(self, id, remoteTransferRefNumber):
1934 
    """
1935 
    Parameters:
1936 
     - id
1937 
     - remoteTransferRefNumber
1938 
    """
1939 
    self.send_markTransferLotAsReceived(id, remoteTransferRefNumber)
1940 
    self.recv_markTransferLotAsReceived()
1941 
 
1942 
  def send_markTransferLotAsReceived(self, id, remoteTransferRefNumber):
1943 
    self._oprot.writeMessageBegin('markTransferLotAsReceived', TMessageType.CALL, self._seqid)
1944 
    args = markTransferLotAsReceived_args()
1945 
    args.id = id
1946 
    args.remoteTransferRefNumber = remoteTransferRefNumber
1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
1951 
  def recv_markTransferLotAsReceived(self, ):
1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
1958 
    result = markTransferLotAsReceived_result()
1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
1961 
    if result.wex is not None:
1962 
      raise result.wex
1963 
    return
1964 
 
1965 
  def getTransferLotsByDate(self, fromDate, toDate):
1966 
    """
1967 
    Parameters:
1968 
     - fromDate
1969 
     - toDate
1970 
    """
1971 
    self.send_getTransferLotsByDate(fromDate, toDate)
1972 
    return self.recv_getTransferLotsByDate()
1973 
 
1974 
  def send_getTransferLotsByDate(self, fromDate, toDate):
1975 
    self._oprot.writeMessageBegin('getTransferLotsByDate', TMessageType.CALL, self._seqid)
1976 
    args = getTransferLotsByDate_args()
1977 
    args.fromDate = fromDate
1978 
    args.toDate = toDate
1979 
    args.write(self._oprot)
1980 
    self._oprot.writeMessageEnd()
1981 
    self._oprot.trans.flush()
1982 
 
1983 
  def recv_getTransferLotsByDate(self, ):
1984 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1985 
    if mtype == TMessageType.EXCEPTION:
1986 
      x = TApplicationException()
1987 
      x.read(self._iprot)
1988 
      self._iprot.readMessageEnd()
1989 
      raise x
1990 
    result = getTransferLotsByDate_result()
1991 
    result.read(self._iprot)
1992 
    self._iprot.readMessageEnd()
1993 
    if result.success is not None:
1994 
      return result.success
1995 
    if result.wex is not None:
1996 
      raise result.wex
1997 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLotsByDate failed: unknown result");
1998 
 
1999 
  def getAllowedDestinationWarehousesForTransfer(self, warehouseId):
2000 
    """
2001 
    Parameters:
2002 
     - warehouseId
2003 
    """
2004 
    self.send_getAllowedDestinationWarehousesForTransfer(warehouseId)
2005 
    return self.recv_getAllowedDestinationWarehousesForTransfer()
2006 
 
2007 
  def send_getAllowedDestinationWarehousesForTransfer(self, warehouseId):
2008 
    self._oprot.writeMessageBegin('getAllowedDestinationWarehousesForTransfer', TMessageType.CALL, self._seqid)
2009 
    args = getAllowedDestinationWarehousesForTransfer_args()
2010 
    args.warehouseId = warehouseId
2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
2015 
  def recv_getAllowedDestinationWarehousesForTransfer(self, ):
2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
2022 
    result = getAllowedDestinationWarehousesForTransfer_result()
2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
2025 
    if result.success is not None:
2026 
      return result.success
2027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllowedDestinationWarehousesForTransfer failed: unknown result");
2028 
 
2029 
  def getItemsInTransferLot(self, transferLotId):
2030 
    """
2031 
    Parameters:
2032 
     - transferLotId
2033 
    """
2034 
    self.send_getItemsInTransferLot(transferLotId)
2035 
    return self.recv_getItemsInTransferLot()
2036 
 
2037 
  def send_getItemsInTransferLot(self, transferLotId):
2038 
    self._oprot.writeMessageBegin('getItemsInTransferLot', TMessageType.CALL, self._seqid)
2039 
    args = getItemsInTransferLot_args()
2040 
    args.transferLotId = transferLotId
2041 
    args.write(self._oprot)
2042 
    self._oprot.writeMessageEnd()
2043 
    self._oprot.trans.flush()
2044 
 
2045 
  def recv_getItemsInTransferLot(self, ):
2046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2047 
    if mtype == TMessageType.EXCEPTION:
2048 
      x = TApplicationException()
2049 
      x.read(self._iprot)
2050 
      self._iprot.readMessageEnd()
2051 
      raise x
2052 
    result = getItemsInTransferLot_result()
2053 
    result.read(self._iprot)
2054 
    self._iprot.readMessageEnd()
2055 
    if result.success is not None:
2056 
      return result.success
2057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsInTransferLot failed: unknown result");
2058 
 
2059 
  def markItemsAsReceivedForTransferLot(self, id):
2060 
    """
2061 
    Parameters:
2062 
     - id
2063 
    """
2064 
    self.send_markItemsAsReceivedForTransferLot(id)
2065 
    self.recv_markItemsAsReceivedForTransferLot()
2066 
 
2067 
  def send_markItemsAsReceivedForTransferLot(self, id):
2068 
    self._oprot.writeMessageBegin('markItemsAsReceivedForTransferLot', TMessageType.CALL, self._seqid)
2069 
    args = markItemsAsReceivedForTransferLot_args()
2070 
    args.id = id
2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
2075 
  def recv_markItemsAsReceivedForTransferLot(self, ):
2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
2082 
    result = markItemsAsReceivedForTransferLot_result()
2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
2085 
    if result.wex is not None:
2086 
      raise result.wex
2087 
    return
2088 
 
2089 
  def updateTransferLotAfterItemReceive(self, id):
2090 
    """
2091 
    Parameters:
2092 
     - id
2093 
    """
2094 
    self.send_updateTransferLotAfterItemReceive(id)
2095 
    return self.recv_updateTransferLotAfterItemReceive()
2096 
 
2097 
  def send_updateTransferLotAfterItemReceive(self, id):
2098 
    self._oprot.writeMessageBegin('updateTransferLotAfterItemReceive', TMessageType.CALL, self._seqid)
2099 
    args = updateTransferLotAfterItemReceive_args()
2100 
    args.id = id
2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
2105 
  def recv_updateTransferLotAfterItemReceive(self, ):
2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
2112 
    result = updateTransferLotAfterItemReceive_result()
2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
2115 
    if result.success is not None:
2116 
      return result.success
2117 
    if result.wex is not None:
2118 
      raise result.wex
2119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateTransferLotAfterItemReceive failed: unknown result");
2120 
 
7459 amar.kumar 2121 
  def scanForTransferOut(self, inventoryItems, type, transferLotId):
7410 amar.kumar 2122 
    """
2123 
    Parameters:
2124 
     - inventoryItems
2125 
     - type
2126 
     - transferLotId
2127 
    """
7459 amar.kumar 2128 
    self.send_scanForTransferOut(inventoryItems, type, transferLotId)
2129 
    self.recv_scanForTransferOut()
7410 amar.kumar 2130 
 
7459 amar.kumar 2131 
  def send_scanForTransferOut(self, inventoryItems, type, transferLotId):
2132 
    self._oprot.writeMessageBegin('scanForTransferOut', TMessageType.CALL, self._seqid)
2133 
    args = scanForTransferOut_args()
7410 amar.kumar 2134 
    args.inventoryItems = inventoryItems
2135 
    args.type = type
2136 
    args.transferLotId = transferLotId
2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
7459 amar.kumar 2141 
  def recv_scanForTransferOut(self, ):
7410 amar.kumar 2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
7459 amar.kumar 2148 
    result = scanForTransferOut_result()
7410 amar.kumar 2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
2151 
    if result.wex is not None:
2152 
      raise result.wex
2153 
    return
2154 
 
7459 amar.kumar 2155 
  def scanForTransferIn(self, inventoryItems, type, transferLotId):
2156 
    """
2157 
    Parameters:
2158 
     - inventoryItems
2159 
     - type
2160 
     - transferLotId
2161 
    """
2162 
    self.send_scanForTransferIn(inventoryItems, type, transferLotId)
2163 
    self.recv_scanForTransferIn()
7410 amar.kumar 2164 
 
7459 amar.kumar 2165 
  def send_scanForTransferIn(self, inventoryItems, type, transferLotId):
2166 
    self._oprot.writeMessageBegin('scanForTransferIn', TMessageType.CALL, self._seqid)
2167 
    args = scanForTransferIn_args()
2168 
    args.inventoryItems = inventoryItems
2169 
    args.type = type
2170 
    args.transferLotId = transferLotId
2171 
    args.write(self._oprot)
2172 
    self._oprot.writeMessageEnd()
2173 
    self._oprot.trans.flush()
2174 
 
2175 
  def recv_scanForTransferIn(self, ):
2176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2177 
    if mtype == TMessageType.EXCEPTION:
2178 
      x = TApplicationException()
2179 
      x.read(self._iprot)
2180 
      self._iprot.readMessageEnd()
2181 
      raise x
2182 
    result = scanForTransferIn_result()
2183 
    result.read(self._iprot)
2184 
    self._iprot.readMessageEnd()
2185 
    if result.wex is not None:
2186 
      raise result.wex
2187 
    return
2188 
 
2189 
  def scanForOursThirdPartyReceive(self, inventoryItems, id):
2190 
    """
2191 
    Parameters:
2192 
     - inventoryItems
2193 
     - id
2194 
    """
2195 
    self.send_scanForOursThirdPartyReceive(inventoryItems, id)
2196 
    self.recv_scanForOursThirdPartyReceive()
2197 
 
2198 
  def send_scanForOursThirdPartyReceive(self, inventoryItems, id):
2199 
    self._oprot.writeMessageBegin('scanForOursThirdPartyReceive', TMessageType.CALL, self._seqid)
2200 
    args = scanForOursThirdPartyReceive_args()
2201 
    args.inventoryItems = inventoryItems
2202 
    args.id = id
2203 
    args.write(self._oprot)
2204 
    self._oprot.writeMessageEnd()
2205 
    self._oprot.trans.flush()
2206 
 
2207 
  def recv_scanForOursThirdPartyReceive(self, ):
2208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2209 
    if mtype == TMessageType.EXCEPTION:
2210 
      x = TApplicationException()
2211 
      x.read(self._iprot)
2212 
      self._iprot.readMessageEnd()
2213 
      raise x
2214 
    result = scanForOursThirdPartyReceive_result()
2215 
    result.read(self._iprot)
2216 
    self._iprot.readMessageEnd()
2217 
    if result.wex is not None:
2218 
      raise result.wex
2219 
    return
2220 
 
7574 amar.kumar 2221 
  def getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, itemId, physicalWarehouseId):
2222 
    """
2223 
    Parameters:
2224 
     - itemId
2225 
     - physicalWarehouseId
2226 
    """
2227 
    self.send_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(itemId, physicalWarehouseId)
2228 
    return self.recv_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse()
7459 amar.kumar 2229 
 
7574 amar.kumar 2230 
  def send_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, itemId, physicalWarehouseId):
2231 
    self._oprot.writeMessageBegin('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse', TMessageType.CALL, self._seqid)
2232 
    args = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args()
2233 
    args.itemId = itemId
2234 
    args.physicalWarehouseId = physicalWarehouseId
2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
2239 
  def recv_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, ):
2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
2246 
    result = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result()
2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
2249 
    if result.success is not None:
2250 
      return result.success
2251 
    if result.wex is not None:
2252 
      raise result.wex
2253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse failed: unknown result");
2254 
 
7672 rajveer 2255 
  def getInTransitInventory(self, originWarehouseId):
2256 
    """
2257 
    Parameters:
2258 
     - originWarehouseId
2259 
    """
2260 
    self.send_getInTransitInventory(originWarehouseId)
2261 
    return self.recv_getInTransitInventory()
7574 amar.kumar 2262 
 
7672 rajveer 2263 
  def send_getInTransitInventory(self, originWarehouseId):
2264 
    self._oprot.writeMessageBegin('getInTransitInventory', TMessageType.CALL, self._seqid)
2265 
    args = getInTransitInventory_args()
2266 
    args.originWarehouseId = originWarehouseId
2267 
    args.write(self._oprot)
2268 
    self._oprot.writeMessageEnd()
2269 
    self._oprot.trans.flush()
2270 
 
2271 
  def recv_getInTransitInventory(self, ):
2272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2273 
    if mtype == TMessageType.EXCEPTION:
2274 
      x = TApplicationException()
2275 
      x.read(self._iprot)
2276 
      self._iprot.readMessageEnd()
2277 
      raise x
2278 
    result = getInTransitInventory_result()
2279 
    result.read(self._iprot)
2280 
    self._iprot.readMessageEnd()
2281 
    if result.success is not None:
2282 
      return result.success
2283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInTransitInventory failed: unknown result");
2284 
 
7968 amar.kumar 2285 
  def isItemAvailableForSale(self, itemId, serialNumber, warehouseId):
2286 
    """
2287 
    Parameters:
2288 
     - itemId
2289 
     - serialNumber
2290 
     - warehouseId
2291 
    """
2292 
    self.send_isItemAvailableForSale(itemId, serialNumber, warehouseId)
2293 
    return self.recv_isItemAvailableForSale()
7672 rajveer 2294 
 
7968 amar.kumar 2295 
  def send_isItemAvailableForSale(self, itemId, serialNumber, warehouseId):
2296 
    self._oprot.writeMessageBegin('isItemAvailableForSale', TMessageType.CALL, self._seqid)
2297 
    args = isItemAvailableForSale_args()
2298 
    args.itemId = itemId
2299 
    args.serialNumber = serialNumber
2300 
    args.warehouseId = warehouseId
2301 
    args.write(self._oprot)
2302 
    self._oprot.writeMessageEnd()
2303 
    self._oprot.trans.flush()
2304 
 
2305 
  def recv_isItemAvailableForSale(self, ):
2306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2307 
    if mtype == TMessageType.EXCEPTION:
2308 
      x = TApplicationException()
2309 
      x.read(self._iprot)
2310 
      self._iprot.readMessageEnd()
2311 
      raise x
2312 
    result = isItemAvailableForSale_result()
2313 
    result.read(self._iprot)
2314 
    self._iprot.readMessageEnd()
2315 
    if result.success is not None:
2316 
      return result.success
2317 
    if result.wex is not None:
2318 
      raise result.wex
2319 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "isItemAvailableForSale failed: unknown result");
2320 
 
2321 
  def getHistoricBadInventoryByScans(self, date):
2322 
    """
2323 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
2324 
 
2325 
    Parameters:
2326 
     - date
2327 
    """
2328 
    self.send_getHistoricBadInventoryByScans(date)
2329 
    return self.recv_getHistoricBadInventoryByScans()
2330 
 
2331 
  def send_getHistoricBadInventoryByScans(self, date):
2332 
    self._oprot.writeMessageBegin('getHistoricBadInventoryByScans', TMessageType.CALL, self._seqid)
2333 
    args = getHistoricBadInventoryByScans_args()
2334 
    args.date = date
2335 
    args.write(self._oprot)
2336 
    self._oprot.writeMessageEnd()
2337 
    self._oprot.trans.flush()
2338 
 
2339 
  def recv_getHistoricBadInventoryByScans(self, ):
2340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2341 
    if mtype == TMessageType.EXCEPTION:
2342 
      x = TApplicationException()
2343 
      x.read(self._iprot)
2344 
      self._iprot.readMessageEnd()
2345 
      raise x
2346 
    result = getHistoricBadInventoryByScans_result()
2347 
    result.read(self._iprot)
2348 
    self._iprot.readMessageEnd()
2349 
    if result.success is not None:
2350 
      return result.success
2351 
    if result.wex is not None:
2352 
      raise result.wex
2353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricBadInventoryByScans failed: unknown result");
2354 
 
8717 amar.kumar 2355 
  def scanForBadSale(self, serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
8565 amar.kumar 2356 
    """
2357 
    Parameters:
8717 amar.kumar 2358 
     - serialNumber
2359 
     - itemNumber
2360 
     - itemId
8565 amar.kumar 2361 
     - orderId
8717 amar.kumar 2362 
     - fulfilmentWarehouseId
8565 amar.kumar 2363 
     - quantity
2364 
     - billingWarehouseId
2365 
    """
8717 amar.kumar 2366 
    self.send_scanForBadSale(serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
2367 
    return self.recv_scanForBadSale()
7968 amar.kumar 2368 
 
8717 amar.kumar 2369 
  def send_scanForBadSale(self, serialNumber, itemNumber, itemId, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
8565 amar.kumar 2370 
    self._oprot.writeMessageBegin('scanForBadSale', TMessageType.CALL, self._seqid)
2371 
    args = scanForBadSale_args()
8717 amar.kumar 2372 
    args.serialNumber = serialNumber
2373 
    args.itemNumber = itemNumber
2374 
    args.itemId = itemId
8565 amar.kumar 2375 
    args.orderId = orderId
8717 amar.kumar 2376 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
8565 amar.kumar 2377 
    args.quantity = quantity
2378 
    args.billingWarehouseId = billingWarehouseId
2379 
    args.write(self._oprot)
2380 
    self._oprot.writeMessageEnd()
2381 
    self._oprot.trans.flush()
2382 
 
2383 
  def recv_scanForBadSale(self, ):
2384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2385 
    if mtype == TMessageType.EXCEPTION:
2386 
      x = TApplicationException()
2387 
      x.read(self._iprot)
2388 
      self._iprot.readMessageEnd()
2389 
      raise x
2390 
    result = scanForBadSale_result()
2391 
    result.read(self._iprot)
2392 
    self._iprot.readMessageEnd()
8717 amar.kumar 2393 
    if result.success is not None:
2394 
      return result.success
2395 
    if result.wex is not None:
2396 
      raise result.wex
2397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForBadSale failed: unknown result");
8565 amar.kumar 2398 
 
10120 manish.sha 2399 
  def getTransferLotItemsForMarkReceive(self, transferLotId, scanType):
2400 
    """
2401 
    Parameters:
2402 
     - transferLotId
2403 
     - scanType
2404 
    """
2405 
    self.send_getTransferLotItemsForMarkReceive(transferLotId, scanType)
2406 
    return self.recv_getTransferLotItemsForMarkReceive()
8565 amar.kumar 2407 
 
10120 manish.sha 2408 
  def send_getTransferLotItemsForMarkReceive(self, transferLotId, scanType):
2409 
    self._oprot.writeMessageBegin('getTransferLotItemsForMarkReceive', TMessageType.CALL, self._seqid)
2410 
    args = getTransferLotItemsForMarkReceive_args()
2411 
    args.transferLotId = transferLotId
2412 
    args.scanType = scanType
2413 
    args.write(self._oprot)
2414 
    self._oprot.writeMessageEnd()
2415 
    self._oprot.trans.flush()
2416 
 
2417 
  def recv_getTransferLotItemsForMarkReceive(self, ):
2418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2419 
    if mtype == TMessageType.EXCEPTION:
2420 
      x = TApplicationException()
2421 
      x.read(self._iprot)
2422 
      self._iprot.readMessageEnd()
2423 
      raise x
2424 
    result = getTransferLotItemsForMarkReceive_result()
2425 
    result.read(self._iprot)
2426 
    self._iprot.readMessageEnd()
2427 
    if result.success is not None:
2428 
      return result.success
2429 
    if result.wex is not None:
2430 
      raise result.wex
2431 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransferLotItemsForMarkReceive failed: unknown result");
2432 
 
2433 
  def markItemsAsReceivedForTransferLotPartial(self, inventoryItems, transferLotId):
2434 
    """
2435 
    Parameters:
2436 
     - inventoryItems
2437 
     - transferLotId
2438 
    """
2439 
    self.send_markItemsAsReceivedForTransferLotPartial(inventoryItems, transferLotId)
2440 
    self.recv_markItemsAsReceivedForTransferLotPartial()
2441 
 
2442 
  def send_markItemsAsReceivedForTransferLotPartial(self, inventoryItems, transferLotId):
2443 
    self._oprot.writeMessageBegin('markItemsAsReceivedForTransferLotPartial', TMessageType.CALL, self._seqid)
2444 
    args = markItemsAsReceivedForTransferLotPartial_args()
2445 
    args.inventoryItems = inventoryItems
2446 
    args.transferLotId = transferLotId
2447 
    args.write(self._oprot)
2448 
    self._oprot.writeMessageEnd()
2449 
    self._oprot.trans.flush()
2450 
 
2451 
  def recv_markItemsAsReceivedForTransferLotPartial(self, ):
2452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2453 
    if mtype == TMessageType.EXCEPTION:
2454 
      x = TApplicationException()
2455 
      x.read(self._iprot)
2456 
      self._iprot.readMessageEnd()
2457 
      raise x
2458 
    result = markItemsAsReceivedForTransferLotPartial_result()
2459 
    result.read(self._iprot)
2460 
    self._iprot.readMessageEnd()
2461 
    if result.wex is not None:
2462 
      raise result.wex
2463 
    return
2464 
 
2465 
  def markTransferLotAsReceivedPartial(self, id, remoteTransferRefNumber):
2466 
    """
2467 
    Parameters:
2468 
     - id
2469 
     - remoteTransferRefNumber
2470 
    """
2471 
    self.send_markTransferLotAsReceivedPartial(id, remoteTransferRefNumber)
2472 
    self.recv_markTransferLotAsReceivedPartial()
2473 
 
2474 
  def send_markTransferLotAsReceivedPartial(self, id, remoteTransferRefNumber):
2475 
    self._oprot.writeMessageBegin('markTransferLotAsReceivedPartial', TMessageType.CALL, self._seqid)
2476 
    args = markTransferLotAsReceivedPartial_args()
2477 
    args.id = id
2478 
    args.remoteTransferRefNumber = remoteTransferRefNumber
2479 
    args.write(self._oprot)
2480 
    self._oprot.writeMessageEnd()
2481 
    self._oprot.trans.flush()
2482 
 
2483 
  def recv_markTransferLotAsReceivedPartial(self, ):
2484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2485 
    if mtype == TMessageType.EXCEPTION:
2486 
      x = TApplicationException()
2487 
      x.read(self._iprot)
2488 
      self._iprot.readMessageEnd()
2489 
      raise x
2490 
    result = markTransferLotAsReceivedPartial_result()
2491 
    result.read(self._iprot)
2492 
    self._iprot.readMessageEnd()
2493 
    if result.wex is not None:
2494 
      raise result.wex
2495 
    return
2496 
 
10690 manish.sha 2497 
  def getInventoryItemScannedInForPO(self, itemId, purchaseIds):
2498 
    """
2499 
    Parameters:
2500 
     - itemId
2501 
     - purchaseIds
2502 
    """
2503 
    self.send_getInventoryItemScannedInForPO(itemId, purchaseIds)
2504 
    return self.recv_getInventoryItemScannedInForPO()
10120 manish.sha 2505 
 
10690 manish.sha 2506 
  def send_getInventoryItemScannedInForPO(self, itemId, purchaseIds):
2507 
    self._oprot.writeMessageBegin('getInventoryItemScannedInForPO', TMessageType.CALL, self._seqid)
2508 
    args = getInventoryItemScannedInForPO_args()
2509 
    args.itemId = itemId
2510 
    args.purchaseIds = purchaseIds
2511 
    args.write(self._oprot)
2512 
    self._oprot.writeMessageEnd()
2513 
    self._oprot.trans.flush()
2514 
 
2515 
  def recv_getInventoryItemScannedInForPO(self, ):
2516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2517 
    if mtype == TMessageType.EXCEPTION:
2518 
      x = TApplicationException()
2519 
      x.read(self._iprot)
2520 
      self._iprot.readMessageEnd()
2521 
      raise x
2522 
    result = getInventoryItemScannedInForPO_result()
2523 
    result.read(self._iprot)
2524 
    self._iprot.readMessageEnd()
2525 
    if result.success is not None:
2526 
      return result.success
2527 
    if result.wex is not None:
2528 
      raise result.wex
2529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemScannedInForPO failed: unknown result");
2530 
 
2531 
  def getAmazonTransferredSkuDetails(self, itemIds):
2532 
    """
2533 
    Parameters:
2534 
     - itemIds
2535 
    """
2536 
    self.send_getAmazonTransferredSkuDetails(itemIds)
2537 
    return self.recv_getAmazonTransferredSkuDetails()
2538 
 
2539 
  def send_getAmazonTransferredSkuDetails(self, itemIds):
2540 
    self._oprot.writeMessageBegin('getAmazonTransferredSkuDetails', TMessageType.CALL, self._seqid)
2541 
    args = getAmazonTransferredSkuDetails_args()
2542 
    args.itemIds = itemIds
2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2547 
  def recv_getAmazonTransferredSkuDetails(self, ):
2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2554 
    result = getAmazonTransferredSkuDetails_result()
2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success is not None:
2558 
      return result.success
2559 
    if result.wex is not None:
2560 
      raise result.wex
2561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAmazonTransferredSkuDetails failed: unknown result");
2562 
 
2563 
  def getScansforPurchase(self, purchaseId, scanType):
2564 
    """
2565 
    Parameters:
2566 
     - purchaseId
2567 
     - scanType
2568 
    """
2569 
    self.send_getScansforPurchase(purchaseId, scanType)
2570 
    return self.recv_getScansforPurchase()
2571 
 
2572 
  def send_getScansforPurchase(self, purchaseId, scanType):
2573 
    self._oprot.writeMessageBegin('getScansforPurchase', TMessageType.CALL, self._seqid)
2574 
    args = getScansforPurchase_args()
2575 
    args.purchaseId = purchaseId
2576 
    args.scanType = scanType
2577 
    args.write(self._oprot)
2578 
    self._oprot.writeMessageEnd()
2579 
    self._oprot.trans.flush()
2580 
 
2581 
  def recv_getScansforPurchase(self, ):
2582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2583 
    if mtype == TMessageType.EXCEPTION:
2584 
      x = TApplicationException()
2585 
      x.read(self._iprot)
2586 
      self._iprot.readMessageEnd()
2587 
      raise x
2588 
    result = getScansforPurchase_result()
2589 
    result.read(self._iprot)
2590 
    self._iprot.readMessageEnd()
2591 
    if result.success is not None:
2592 
      return result.success
2593 
    if result.wex is not None:
2594 
      raise result.wex
2595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScansforPurchase failed: unknown result");
2596 
 
10864 manish.sha 2597 
  def getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
2598 
    """
2599 
    Parameters:
2600 
     - itemId
2601 
     - currentWarehouseId
2602 
     - physicalWarehouseId
2603 
    """
2604 
    self.send_getCurrentBadQuantityForItem(itemId, currentWarehouseId, physicalWarehouseId)
2605 
    return self.recv_getCurrentBadQuantityForItem()
10690 manish.sha 2606 
 
10864 manish.sha 2607 
  def send_getCurrentBadQuantityForItem(self, itemId, currentWarehouseId, physicalWarehouseId):
2608 
    self._oprot.writeMessageBegin('getCurrentBadQuantityForItem', TMessageType.CALL, self._seqid)
2609 
    args = getCurrentBadQuantityForItem_args()
2610 
    args.itemId = itemId
2611 
    args.currentWarehouseId = currentWarehouseId
2612 
    args.physicalWarehouseId = physicalWarehouseId
2613 
    args.write(self._oprot)
2614 
    self._oprot.writeMessageEnd()
2615 
    self._oprot.trans.flush()
2616 
 
2617 
  def recv_getCurrentBadQuantityForItem(self, ):
2618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2619 
    if mtype == TMessageType.EXCEPTION:
2620 
      x = TApplicationException()
2621 
      x.read(self._iprot)
2622 
      self._iprot.readMessageEnd()
2623 
      raise x
2624 
    result = getCurrentBadQuantityForItem_result()
2625 
    result.read(self._iprot)
2626 
    self._iprot.readMessageEnd()
2627 
    if result.success is not None:
2628 
      return result.success
2629 
    if result.wex is not None:
2630 
      raise result.wex
2631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentBadQuantityForItem failed: unknown result");
2632 
 
2633 
  def scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
2634 
    """
2635 
    Parameters:
2636 
     - saleReturnItems
2637 
     - vendorId
2638 
     - billingWarehouseId
2639 
    """
2640 
    self.send_scanForBadPurchaseReturn(saleReturnItems, vendorId, billingWarehouseId)
2641 
    return self.recv_scanForBadPurchaseReturn()
2642 
 
2643 
  def send_scanForBadPurchaseReturn(self, saleReturnItems, vendorId, billingWarehouseId):
2644 
    self._oprot.writeMessageBegin('scanForBadPurchaseReturn', TMessageType.CALL, self._seqid)
2645 
    args = scanForBadPurchaseReturn_args()
2646 
    args.saleReturnItems = saleReturnItems
2647 
    args.vendorId = vendorId
2648 
    args.billingWarehouseId = billingWarehouseId
2649 
    args.write(self._oprot)
2650 
    self._oprot.writeMessageEnd()
2651 
    self._oprot.trans.flush()
2652 
 
2653 
  def recv_scanForBadPurchaseReturn(self, ):
2654 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2655 
    if mtype == TMessageType.EXCEPTION:
2656 
      x = TApplicationException()
2657 
      x.read(self._iprot)
2658 
      self._iprot.readMessageEnd()
2659 
      raise x
2660 
    result = scanForBadPurchaseReturn_result()
2661 
    result.read(self._iprot)
2662 
    self._iprot.readMessageEnd()
2663 
    if result.success is not None:
2664 
      return result.success
2665 
    if result.ex is not None:
2666 
      raise result.ex
2667 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForBadPurchaseReturn failed: unknown result");
2668 
 
11751 manish.sha 2669 
  def getItemsInPurchaseReturn(self, purchaseReturnId, type):
10864 manish.sha 2670 
    """
2671 
    Parameters:
2672 
     - purchaseReturnId
11751 manish.sha 2673 
     - type
10864 manish.sha 2674 
    """
11751 manish.sha 2675 
    self.send_getItemsInPurchaseReturn(purchaseReturnId, type)
10864 manish.sha 2676 
    return self.recv_getItemsInPurchaseReturn()
2677 
 
11751 manish.sha 2678 
  def send_getItemsInPurchaseReturn(self, purchaseReturnId, type):
10864 manish.sha 2679 
    self._oprot.writeMessageBegin('getItemsInPurchaseReturn', TMessageType.CALL, self._seqid)
2680 
    args = getItemsInPurchaseReturn_args()
2681 
    args.purchaseReturnId = purchaseReturnId
11751 manish.sha 2682 
    args.type = type
10864 manish.sha 2683 
    args.write(self._oprot)
2684 
    self._oprot.writeMessageEnd()
2685 
    self._oprot.trans.flush()
2686 
 
2687 
  def recv_getItemsInPurchaseReturn(self, ):
2688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2689 
    if mtype == TMessageType.EXCEPTION:
2690 
      x = TApplicationException()
2691 
      x.read(self._iprot)
2692 
      self._iprot.readMessageEnd()
2693 
      raise x
2694 
    result = getItemsInPurchaseReturn_result()
2695 
    result.read(self._iprot)
2696 
    self._iprot.readMessageEnd()
2697 
    if result.success is not None:
2698 
      return result.success
2699 
    if result.ex is not None:
2700 
      raise result.ex
2701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemsInPurchaseReturn failed: unknown result");
2702 
 
10886 manish.sha 2703 
  def getScansForInventoryItem(self, inventoryItemId, type):
2704 
    """
2705 
    Parameters:
2706 
     - inventoryItemId
2707 
     - type
2708 
    """
2709 
    self.send_getScansForInventoryItem(inventoryItemId, type)
2710 
    return self.recv_getScansForInventoryItem()
10864 manish.sha 2711 
 
10886 manish.sha 2712 
  def send_getScansForInventoryItem(self, inventoryItemId, type):
2713 
    self._oprot.writeMessageBegin('getScansForInventoryItem', TMessageType.CALL, self._seqid)
2714 
    args = getScansForInventoryItem_args()
2715 
    args.inventoryItemId = inventoryItemId
2716 
    args.type = type
2717 
    args.write(self._oprot)
2718 
    self._oprot.writeMessageEnd()
2719 
    self._oprot.trans.flush()
2720 
 
2721 
  def recv_getScansForInventoryItem(self, ):
2722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2723 
    if mtype == TMessageType.EXCEPTION:
2724 
      x = TApplicationException()
2725 
      x.read(self._iprot)
2726 
      self._iprot.readMessageEnd()
2727 
      raise x
2728 
    result = getScansForInventoryItem_result()
2729 
    result.read(self._iprot)
2730 
    self._iprot.readMessageEnd()
2731 
    if result.success is not None:
2732 
      return result.success
2733 
    if result.ex is not None:
2734 
      raise result.ex
2735 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScansForInventoryItem failed: unknown result");
2736 
 
12531 manish.sha 2737 
  def checkGrnImeiStatus(self, imeiNos):
2738 
    """
2739 
    Parameters:
2740 
     - imeiNos
2741 
    """
2742 
    self.send_checkGrnImeiStatus(imeiNos)
2743 
    return self.recv_checkGrnImeiStatus()
10886 manish.sha 2744 
 
12531 manish.sha 2745 
  def send_checkGrnImeiStatus(self, imeiNos):
2746 
    self._oprot.writeMessageBegin('checkGrnImeiStatus', TMessageType.CALL, self._seqid)
2747 
    args = checkGrnImeiStatus_args()
2748 
    args.imeiNos = imeiNos
2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_checkGrnImeiStatus(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = checkGrnImeiStatus_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.success is not None:
2764 
      return result.success
2765 
    if result.ex is not None:
2766 
      raise result.ex
2767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkGrnImeiStatus failed: unknown result");
2768 
 
12800 manish.sha 2769 
  def getInventoryAgeConsideredItems(self, itemId):
2770 
    """
2771 
    Parameters:
2772 
     - itemId
2773 
    """
2774 
    self.send_getInventoryAgeConsideredItems(itemId)
2775 
    return self.recv_getInventoryAgeConsideredItems()
12531 manish.sha 2776 
 
12800 manish.sha 2777 
  def send_getInventoryAgeConsideredItems(self, itemId):
2778 
    self._oprot.writeMessageBegin('getInventoryAgeConsideredItems', TMessageType.CALL, self._seqid)
2779 
    args = getInventoryAgeConsideredItems_args()
2780 
    args.itemId = itemId
2781 
    args.write(self._oprot)
2782 
    self._oprot.writeMessageEnd()
2783 
    self._oprot.trans.flush()
2784 
 
2785 
  def recv_getInventoryAgeConsideredItems(self, ):
2786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2787 
    if mtype == TMessageType.EXCEPTION:
2788 
      x = TApplicationException()
2789 
      x.read(self._iprot)
2790 
      self._iprot.readMessageEnd()
2791 
      raise x
2792 
    result = getInventoryAgeConsideredItems_result()
2793 
    result.read(self._iprot)
2794 
    self._iprot.readMessageEnd()
2795 
    if result.success is not None:
2796 
      return result.success
2797 
    if result.ex is not None:
2798 
      raise result.ex
2799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAgeConsideredItems failed: unknown result");
2800 
 
2801 
 
3376 rajveer 2802 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
2821 chandransh 2803 
  def __init__(self, handler):
3376 rajveer 2804 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4501 mandeep.dh 2805 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
5361 mandeep.dh 2806 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
4501 mandeep.dh 2807 
    self._processMap["scan"] = Processor.process_scan
10489 amar.kumar 2808 
    self._processMap["genericScan"] = Processor.process_genericScan
4501 mandeep.dh 2809 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
2810 
    self._processMap["scanForOrder"] = Processor.process_scanForOrder
2811 
    self._processMap["createItemNumberMapping"] = Processor.process_createItemNumberMapping
4620 amit.gupta 2812 
    self._processMap["getItemNumbers"] = Processor.process_getItemNumbers
5110 mandeep.dh 2813 
    self._processMap["getItemIds"] = Processor.process_getItemIds
5185 mandeep.dh 2814 
    self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
2815 
    self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
5372 mandeep.dh 2816 
    self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
7216 amar.kumar 2817 
    self._processMap["getPurchaseScansByGrnDate"] = Processor.process_getPurchaseScansByGrnDate
10407 amar.kumar 2818 
    self._processMap["getEmptyGrnsByDate"] = Processor.process_getEmptyGrnsByDate
5496 mandeep.dh 2819 
    self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
5620 mandeep.dh 2820 
    self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
5711 mandeep.dh 2821 
    self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
6361 rajveer 2822 
    self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
2823 
    self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
6467 amar.kumar 2824 
    self._processMap["scanForPurchaseReturn"] = Processor.process_scanForPurchaseReturn
6630 amar.kumar 2825 
    self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
2826 
    self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
2827 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
6762 amar.kumar 2828 
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
2829 
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
10407 amar.kumar 2830 
    self._processMap["getOurHistoricSerializedInventoryByScans"] = Processor.process_getOurHistoricSerializedInventoryByScans
2831 
    self._processMap["getOurHistoricNonSerializedInventoryByScans"] = Processor.process_getOurHistoricNonSerializedInventoryByScans
6762 amar.kumar 2832 
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
2833 
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
6880 amar.kumar 2834 
    self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
2835 
    self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
7216 amar.kumar 2836 
    self._processMap["getCompleteMovementSerializedInventoryByScans"] = Processor.process_getCompleteMovementSerializedInventoryByScans
2837 
    self._processMap["getCompleteMovementNonSerializedInventoryByScans"] = Processor.process_getCompleteMovementNonSerializedInventoryByScans
7190 amar.kumar 2838 
    self._processMap["scanfreebie"] = Processor.process_scanfreebie
7199 amar.kumar 2839 
    self._processMap["reshipfreebie"] = Processor.process_reshipfreebie
7410 amar.kumar 2840 
    self._processMap["isItemTransferAllowed"] = Processor.process_isItemTransferAllowed
2841 
    self._processMap["createTransferLot"] = Processor.process_createTransferLot
2842 
    self._processMap["getTransferLot"] = Processor.process_getTransferLot
2843 
    self._processMap["markTransferLotAsReceived"] = Processor.process_markTransferLotAsReceived
2844 
    self._processMap["getTransferLotsByDate"] = Processor.process_getTransferLotsByDate
2845 
    self._processMap["getAllowedDestinationWarehousesForTransfer"] = Processor.process_getAllowedDestinationWarehousesForTransfer
2846 
    self._processMap["getItemsInTransferLot"] = Processor.process_getItemsInTransferLot
2847 
    self._processMap["markItemsAsReceivedForTransferLot"] = Processor.process_markItemsAsReceivedForTransferLot
2848 
    self._processMap["updateTransferLotAfterItemReceive"] = Processor.process_updateTransferLotAfterItemReceive
7459 amar.kumar 2849 
    self._processMap["scanForTransferOut"] = Processor.process_scanForTransferOut
2850 
    self._processMap["scanForTransferIn"] = Processor.process_scanForTransferIn
2851 
    self._processMap["scanForOursThirdPartyReceive"] = Processor.process_scanForOursThirdPartyReceive
7574 amar.kumar 2852 
    self._processMap["getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse"] = Processor.process_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse
7672 rajveer 2853 
    self._processMap["getInTransitInventory"] = Processor.process_getInTransitInventory
7968 amar.kumar 2854 
    self._processMap["isItemAvailableForSale"] = Processor.process_isItemAvailableForSale
2855 
    self._processMap["getHistoricBadInventoryByScans"] = Processor.process_getHistoricBadInventoryByScans
8565 amar.kumar 2856 
    self._processMap["scanForBadSale"] = Processor.process_scanForBadSale
10120 manish.sha 2857 
    self._processMap["getTransferLotItemsForMarkReceive"] = Processor.process_getTransferLotItemsForMarkReceive
2858 
    self._processMap["markItemsAsReceivedForTransferLotPartial"] = Processor.process_markItemsAsReceivedForTransferLotPartial
2859 
    self._processMap["markTransferLotAsReceivedPartial"] = Processor.process_markTransferLotAsReceivedPartial
10690 manish.sha 2860 
    self._processMap["getInventoryItemScannedInForPO"] = Processor.process_getInventoryItemScannedInForPO
2861 
    self._processMap["getAmazonTransferredSkuDetails"] = Processor.process_getAmazonTransferredSkuDetails
2862 
    self._processMap["getScansforPurchase"] = Processor.process_getScansforPurchase
10864 manish.sha 2863 
    self._processMap["getCurrentBadQuantityForItem"] = Processor.process_getCurrentBadQuantityForItem
2864 
    self._processMap["scanForBadPurchaseReturn"] = Processor.process_scanForBadPurchaseReturn
2865 
    self._processMap["getItemsInPurchaseReturn"] = Processor.process_getItemsInPurchaseReturn
10886 manish.sha 2866 
    self._processMap["getScansForInventoryItem"] = Processor.process_getScansForInventoryItem
12531 manish.sha 2867 
    self._processMap["checkGrnImeiStatus"] = Processor.process_checkGrnImeiStatus
12800 manish.sha 2868 
    self._processMap["getInventoryAgeConsideredItems"] = Processor.process_getInventoryAgeConsideredItems
2821 chandransh 2869 
 
2870 
  def process(self, iprot, oprot):
2871 
    (name, type, seqid) = iprot.readMessageBegin()
2872 
    if name not in self._processMap:
2873 
      iprot.skip(TType.STRUCT)
2874 
      iprot.readMessageEnd()
2875 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2876 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2877 
      x.write(oprot)
2878 
      oprot.writeMessageEnd()
2879 
      oprot.trans.flush()
2880 
      return
2881 
    else:
2882 
      self._processMap[name](self, seqid, iprot, oprot)
2883 
    return True
2884 
 
4501 mandeep.dh 2885 
  def process_getInventoryItem(self, seqid, iprot, oprot):
2886 
    args = getInventoryItem_args()
2832 chandransh 2887 
    args.read(iprot)
2888 
    iprot.readMessageEnd()
4501 mandeep.dh 2889 
    result = getInventoryItem_result()
4541 mandeep.dh 2890 
    try:
2891 
      result.success = self._handler.getInventoryItem(args.serialNumber)
2892 
    except WarehouseServiceException, wex:
2893 
      result.wex = wex
4501 mandeep.dh 2894 
    oprot.writeMessageBegin("getInventoryItem", TMessageType.REPLY, seqid)
2832 chandransh 2895 
    result.write(oprot)
2896 
    oprot.writeMessageEnd()
2897 
    oprot.trans.flush()
2898 
 
5361 mandeep.dh 2899 
  def process_getNonSeralizedInventoryItem(self, seqid, iprot, oprot):
2900 
    args = getNonSeralizedInventoryItem_args()
2821 chandransh 2901 
    args.read(iprot)
2902 
    iprot.readMessageEnd()
5361 mandeep.dh 2903 
    result = getNonSeralizedInventoryItem_result()
2904 
    try:
8565 amar.kumar 2905 
      result.success = self._handler.getNonSeralizedInventoryItem(args.itemNumber, args.itemId, args.fulfilmentWarehouseId, args.billingWarehouseId)
5361 mandeep.dh 2906 
    except WarehouseServiceException, wex:
2907 
      result.wex = wex
2908 
    oprot.writeMessageBegin("getNonSeralizedInventoryItem", TMessageType.REPLY, seqid)
2821 chandransh 2909 
    result.write(oprot)
2910 
    oprot.writeMessageEnd()
2911 
    oprot.trans.flush()
2912 
 
4501 mandeep.dh 2913 
  def process_scan(self, seqid, iprot, oprot):
2914 
    args = scan_args()
3383 chandransh 2915 
    args.read(iprot)
2916 
    iprot.readMessageEnd()
4501 mandeep.dh 2917 
    result = scan_result()
3383 chandransh 2918 
    try:
7410 amar.kumar 2919 
      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId, args.transferLotId)
3383 chandransh 2920 
    except WarehouseServiceException, wex:
2921 
      result.wex = wex
4501 mandeep.dh 2922 
    oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
3383 chandransh 2923 
    result.write(oprot)
2924 
    oprot.writeMessageEnd()
2925 
    oprot.trans.flush()
2926 
 
10489 amar.kumar 2927 
  def process_genericScan(self, seqid, iprot, oprot):
2928 
    args = genericScan_args()
2929 
    args.read(iprot)
2930 
    iprot.readMessageEnd()
2931 
    result = genericScan_result()
2932 
    try:
2933 
      self._handler.genericScan(args.inventoryItem, args.scan)
2934 
    except WarehouseServiceException, wex:
2935 
      result.wex = wex
2936 
    oprot.writeMessageBegin("genericScan", TMessageType.REPLY, seqid)
2937 
    result.write(oprot)
2938 
    oprot.writeMessageEnd()
2939 
    oprot.trans.flush()
2940 
 
4501 mandeep.dh 2941 
  def process_scanSerializedItemForOrder(self, seqid, iprot, oprot):
2942 
    args = scanSerializedItemForOrder_args()
2821 chandransh 2943 
    args.read(iprot)
2944 
    iprot.readMessageEnd()
4501 mandeep.dh 2945 
    result = scanSerializedItemForOrder_result()
2821 chandransh 2946 
    try:
5110 mandeep.dh 2947 
      result.success = self._handler.scanSerializedItemForOrder(args.serialNumber, args.type, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
2821 chandransh 2948 
    except WarehouseServiceException, wex:
2949 
      result.wex = wex
4501 mandeep.dh 2950 
    oprot.writeMessageBegin("scanSerializedItemForOrder", TMessageType.REPLY, seqid)
2821 chandransh 2951 
    result.write(oprot)
2952 
    oprot.writeMessageEnd()
2953 
    oprot.trans.flush()
2954 
 
4501 mandeep.dh 2955 
  def process_scanForOrder(self, seqid, iprot, oprot):
2956 
    args = scanForOrder_args()
2821 chandransh 2957 
    args.read(iprot)
2958 
    iprot.readMessageEnd()
4501 mandeep.dh 2959 
    result = scanForOrder_result()
2821 chandransh 2960 
    try:
5361 mandeep.dh 2961 
      result.success = self._handler.scanForOrder(args.inventoryItem, args.type, args.quantity, args.orderId, args.fulfilmentWarehouseId, args.billingWarehouseId)
2821 chandransh 2962 
    except WarehouseServiceException, wex:
2963 
      result.wex = wex
4501 mandeep.dh 2964 
    oprot.writeMessageBegin("scanForOrder", TMessageType.REPLY, seqid)
2821 chandransh 2965 
    result.write(oprot)
2966 
    oprot.writeMessageEnd()
2967 
    oprot.trans.flush()
2968 
 
4501 mandeep.dh 2969 
  def process_createItemNumberMapping(self, seqid, iprot, oprot):
2970 
    args = createItemNumberMapping_args()
2971 
    args.read(iprot)
2972 
    iprot.readMessageEnd()
2973 
    result = createItemNumberMapping_result()
2974 
    self._handler.createItemNumberMapping(args.itemNumber, args.itemId)
2975 
    oprot.writeMessageBegin("createItemNumberMapping", TMessageType.REPLY, seqid)
2976 
    result.write(oprot)
2977 
    oprot.writeMessageEnd()
2978 
    oprot.trans.flush()
2821 chandransh 2979 
 
4620 amit.gupta 2980 
  def process_getItemNumbers(self, seqid, iprot, oprot):
2981 
    args = getItemNumbers_args()
2982 
    args.read(iprot)
2983 
    iprot.readMessageEnd()
2984 
    result = getItemNumbers_result()
2985 
    result.success = self._handler.getItemNumbers(args.itemId)
2986 
    oprot.writeMessageBegin("getItemNumbers", TMessageType.REPLY, seqid)
2987 
    result.write(oprot)
2988 
    oprot.writeMessageEnd()
2989 
    oprot.trans.flush()
4501 mandeep.dh 2990 
 
5110 mandeep.dh 2991 
  def process_getItemIds(self, seqid, iprot, oprot):
2992 
    args = getItemIds_args()
2993 
    args.read(iprot)
2994 
    iprot.readMessageEnd()
2995 
    result = getItemIds_result()
2996 
    result.success = self._handler.getItemIds(args.itemNumber)
2997 
    oprot.writeMessageBegin("getItemIds", TMessageType.REPLY, seqid)
2998 
    result.write(oprot)
2999 
    oprot.writeMessageEnd()
3000 
    oprot.trans.flush()
4620 amit.gupta 3001 
 
5185 mandeep.dh 3002 
  def process_getInventoryItemsFromLastScanType(self, seqid, iprot, oprot):
3003 
    args = getInventoryItemsFromLastScanType_args()
3004 
    args.read(iprot)
3005 
    iprot.readMessageEnd()
3006 
    result = getInventoryItemsFromLastScanType_result()
3007 
    try:
3008 
      result.success = self._handler.getInventoryItemsFromLastScanType(args.lastScanType)
3009 
    except WarehouseServiceException, wex:
3010 
      result.wex = wex
3011 
    oprot.writeMessageBegin("getInventoryItemsFromLastScanType", TMessageType.REPLY, seqid)
3012 
    result.write(oprot)
3013 
    oprot.writeMessageEnd()
3014 
    oprot.trans.flush()
5110 mandeep.dh 3015 
 
5185 mandeep.dh 3016 
  def process_getInventoryItemFromId(self, seqid, iprot, oprot):
3017 
    args = getInventoryItemFromId_args()
3018 
    args.read(iprot)
3019 
    iprot.readMessageEnd()
3020 
    result = getInventoryItemFromId_result()
3021 
    try:
3022 
      result.success = self._handler.getInventoryItemFromId(args.inventoryItemId)
3023 
    except WarehouseServiceException, wex:
3024 
      result.wex = wex
3025 
    oprot.writeMessageBegin("getInventoryItemFromId", TMessageType.REPLY, seqid)
3026 
    result.write(oprot)
3027 
    oprot.writeMessageEnd()
3028 
    oprot.trans.flush()
3029 
 
5372 mandeep.dh 3030 
  def process_getPurchaseScans(self, seqid, iprot, oprot):
3031 
    args = getPurchaseScans_args()
3032 
    args.read(iprot)
3033 
    iprot.readMessageEnd()
3034 
    result = getPurchaseScans_result()
3035 
    result.success = self._handler.getPurchaseScans(args.startDate, args.endDate)
3036 
    oprot.writeMessageBegin("getPurchaseScans", TMessageType.REPLY, seqid)
3037 
    result.write(oprot)
3038 
    oprot.writeMessageEnd()
3039 
    oprot.trans.flush()
5185 mandeep.dh 3040 
 
7216 amar.kumar 3041 
  def process_getPurchaseScansByGrnDate(self, seqid, iprot, oprot):
3042 
    args = getPurchaseScansByGrnDate_args()
3043 
    args.read(iprot)
3044 
    iprot.readMessageEnd()
3045 
    result = getPurchaseScansByGrnDate_result()
3046 
    result.success = self._handler.getPurchaseScansByGrnDate(args.startDate, args.endDate)
3047 
    oprot.writeMessageBegin("getPurchaseScansByGrnDate", TMessageType.REPLY, seqid)
3048 
    result.write(oprot)
3049 
    oprot.writeMessageEnd()
3050 
    oprot.trans.flush()
3051 
 
10407 amar.kumar 3052 
  def process_getEmptyGrnsByDate(self, seqid, iprot, oprot):
3053 
    args = getEmptyGrnsByDate_args()
3054 
    args.read(iprot)
3055 
    iprot.readMessageEnd()
3056 
    result = getEmptyGrnsByDate_result()
3057 
    result.success = self._handler.getEmptyGrnsByDate(args.startDate, args.endDate)
3058 
    oprot.writeMessageBegin("getEmptyGrnsByDate", TMessageType.REPLY, seqid)
3059 
    result.write(oprot)
3060 
    oprot.writeMessageEnd()
3061 
    oprot.trans.flush()
3062 
 
5496 mandeep.dh 3063 
  def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
3064 
    args = fetchScansPerInvoiceNumber_args()
3065 
    args.read(iprot)
3066 
    iprot.readMessageEnd()
3067 
    result = fetchScansPerInvoiceNumber_result()
3068 
    result.success = self._handler.fetchScansPerInvoiceNumber(args.date)
3069 
    oprot.writeMessageBegin("fetchScansPerInvoiceNumber", TMessageType.REPLY, seqid)
3070 
    result.write(oprot)
3071 
    oprot.writeMessageEnd()
3072 
    oprot.trans.flush()
5372 mandeep.dh 3073 
 
5620 mandeep.dh 3074 
  def process_getInventoryItemFromOrder(self, seqid, iprot, oprot):
3075 
    args = getInventoryItemFromOrder_args()
3076 
    args.read(iprot)
3077 
    iprot.readMessageEnd()
3078 
    result = getInventoryItemFromOrder_result()
3079 
    try:
3080 
      result.success = self._handler.getInventoryItemFromOrder(args.orderId)
3081 
    except WarehouseServiceException, we:
3082 
      result.we = we
3083 
    oprot.writeMessageBegin("getInventoryItemFromOrder", TMessageType.REPLY, seqid)
3084 
    result.write(oprot)
3085 
    oprot.writeMessageEnd()
3086 
    oprot.trans.flush()
5496 mandeep.dh 3087 
 
5711 mandeep.dh 3088 
  def process_getInventoryAge(self, seqid, iprot, oprot):
3089 
    args = getInventoryAge_args()
3090 
    args.read(iprot)
3091 
    iprot.readMessageEnd()
3092 
    result = getInventoryAge_result()
3093 
    result.success = self._handler.getInventoryAge()
3094 
    oprot.writeMessageBegin("getInventoryAge", TMessageType.REPLY, seqid)
3095 
    result.write(oprot)
3096 
    oprot.writeMessageEnd()
3097 
    oprot.trans.flush()
5620 mandeep.dh 3098 
 
6361 rajveer 3099 
  def process_getInventoryScansForItem(self, seqid, iprot, oprot):
3100 
    args = getInventoryScansForItem_args()
3101 
    args.read(iprot)
3102 
    iprot.readMessageEnd()
3103 
    result = getInventoryScansForItem_result()
3104 
    result.success = self._handler.getInventoryScansForItem(args.itemId, args.fromDate, args.toDate)
3105 
    oprot.writeMessageBegin("getInventoryScansForItem", TMessageType.REPLY, seqid)
3106 
    result.write(oprot)
3107 
    oprot.writeMessageEnd()
3108 
    oprot.trans.flush()
5711 mandeep.dh 3109 
 
6361 rajveer 3110 
  def process_getScanRecordsForSerialNumber(self, seqid, iprot, oprot):
3111 
    args = getScanRecordsForSerialNumber_args()
3112 
    args.read(iprot)
3113 
    iprot.readMessageEnd()
3114 
    result = getScanRecordsForSerialNumber_result()
3115 
    result.success = self._handler.getScanRecordsForSerialNumber(args.serialNumber)
3116 
    oprot.writeMessageBegin("getScanRecordsForSerialNumber", TMessageType.REPLY, seqid)
3117 
    result.write(oprot)
3118 
    oprot.writeMessageEnd()
3119 
    oprot.trans.flush()
3120 
 
6467 amar.kumar 3121 
  def process_scanForPurchaseReturn(self, seqid, iprot, oprot):
3122 
    args = scanForPurchaseReturn_args()
3123 
    args.read(iprot)
3124 
    iprot.readMessageEnd()
3125 
    result = scanForPurchaseReturn_result()
3126 
    try:
10864 manish.sha 3127 
      result.success = self._handler.scanForPurchaseReturn(args.saleReturnItems, args.vendorId, args.billingWarehouseId)
6467 amar.kumar 3128 
    except WarehouseServiceException, ex:
3129 
      result.ex = ex
3130 
    oprot.writeMessageBegin("scanForPurchaseReturn", TMessageType.REPLY, seqid)
3131 
    result.write(oprot)
3132 
    oprot.writeMessageEnd()
3133 
    oprot.trans.flush()
6361 rajveer 3134 
 
6630 amar.kumar 3135 
  def process_scanForLostItem(self, seqid, iprot, oprot):
3136 
    args = scanForLostItem_args()
3137 
    args.read(iprot)
3138 
    iprot.readMessageEnd()
3139 
    result = scanForLostItem_result()
3140 
    try:
7718 amar.kumar 3141 
      self._handler.scanForLostItem(args.lostItems, args.vendorId, args.billingWarehouseId)
6630 amar.kumar 3142 
    except WarehouseServiceException, ex:
3143 
      result.ex = ex
3144 
    oprot.writeMessageBegin("scanForLostItem", TMessageType.REPLY, seqid)
3145 
    result.write(oprot)
3146 
    oprot.writeMessageEnd()
3147 
    oprot.trans.flush()
6467 amar.kumar 3148 
 
6630 amar.kumar 3149 
  def process_getCurrentSerializedInventoryByScans(self, seqid, iprot, oprot):
3150 
    args = getCurrentSerializedInventoryByScans_args()
3151 
    args.read(iprot)
3152 
    iprot.readMessageEnd()
3153 
    result = getCurrentSerializedInventoryByScans_result()
7715 vikram.rag 3154 
    result.success = self._handler.getCurrentSerializedInventoryByScans(args.physicalWarehouseId)
6630 amar.kumar 3155 
    oprot.writeMessageBegin("getCurrentSerializedInventoryByScans", TMessageType.REPLY, seqid)
3156 
    result.write(oprot)
3157 
    oprot.writeMessageEnd()
3158 
    oprot.trans.flush()
3159 
 
3160 
  def process_getCurrentNonSerializedInventoryByScans(self, seqid, iprot, oprot):
3161 
    args = getCurrentNonSerializedInventoryByScans_args()
3162 
    args.read(iprot)
3163 
    iprot.readMessageEnd()
3164 
    result = getCurrentNonSerializedInventoryByScans_result()
7715 vikram.rag 3165 
    result.success = self._handler.getCurrentNonSerializedInventoryByScans(args.physicalWarehouseId)
6630 amar.kumar 3166 
    oprot.writeMessageBegin("getCurrentNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
3167 
    result.write(oprot)
3168 
    oprot.writeMessageEnd()
3169 
    oprot.trans.flush()
3170 
 
6762 amar.kumar 3171 
  def process_getHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
3172 
    args = getHistoricSerializedInventoryByScans_args()
3173 
    args.read(iprot)
3174 
    iprot.readMessageEnd()
3175 
    result = getHistoricSerializedInventoryByScans_result()
3176 
    result.success = self._handler.getHistoricSerializedInventoryByScans(args.date)
3177 
    oprot.writeMessageBegin("getHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
3178 
    result.write(oprot)
3179 
    oprot.writeMessageEnd()
3180 
    oprot.trans.flush()
6630 amar.kumar 3181 
 
6762 amar.kumar 3182 
  def process_getHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
3183 
    args = getHistoricNonSerializedInventoryByScans_args()
3184 
    args.read(iprot)
3185 
    iprot.readMessageEnd()
3186 
    result = getHistoricNonSerializedInventoryByScans_result()
3187 
    result.success = self._handler.getHistoricNonSerializedInventoryByScans(args.date)
3188 
    oprot.writeMessageBegin("getHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
3189 
    result.write(oprot)
3190 
    oprot.writeMessageEnd()
3191 
    oprot.trans.flush()
3192 
 
10407 amar.kumar 3193 
  def process_getOurHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
3194 
    args = getOurHistoricSerializedInventoryByScans_args()
3195 
    args.read(iprot)
3196 
    iprot.readMessageEnd()
3197 
    result = getOurHistoricSerializedInventoryByScans_result()
3198 
    result.success = self._handler.getOurHistoricSerializedInventoryByScans(args.date)
3199 
    oprot.writeMessageBegin("getOurHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
3200 
    result.write(oprot)
3201 
    oprot.writeMessageEnd()
3202 
    oprot.trans.flush()
3203 
 
3204 
  def process_getOurHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
3205 
    args = getOurHistoricNonSerializedInventoryByScans_args()
3206 
    args.read(iprot)
3207 
    iprot.readMessageEnd()
3208 
    result = getOurHistoricNonSerializedInventoryByScans_result()
3209 
    result.success = self._handler.getOurHistoricNonSerializedInventoryByScans(args.date)
3210 
    oprot.writeMessageBegin("getOurHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
3211 
    result.write(oprot)
3212 
    oprot.writeMessageEnd()
3213 
    oprot.trans.flush()
3214 
 
6762 amar.kumar 3215 
  def process_scanForOursExternalSale(self, seqid, iprot, oprot):
3216 
    args = scanForOursExternalSale_args()
3217 
    args.read(iprot)
3218 
    iprot.readMessageEnd()
3219 
    result = scanForOursExternalSale_result()
3220 
    try:
7672 rajveer 3221 
      result.success = self._handler.scanForOursExternalSale(args.itemId, args.serialNumber, args.itemNumber, args.invoiceNumber, args.warehouseId, args.unitPrice, args.nlc, args.orderId)
6762 amar.kumar 3222 
    except WarehouseServiceException, ex:
3223 
      result.ex = ex
3224 
    oprot.writeMessageBegin("scanForOursExternalSale", TMessageType.REPLY, seqid)
3225 
    result.write(oprot)
3226 
    oprot.writeMessageEnd()
3227 
    oprot.trans.flush()
3228 
 
3229 
  def process_scanForOursExternalSaleReturn(self, seqid, iprot, oprot):
3230 
    args = scanForOursExternalSaleReturn_args()
3231 
    args.read(iprot)
3232 
    iprot.readMessageEnd()
3233 
    result = scanForOursExternalSaleReturn_result()
7410 amar.kumar 3234 
    try:
3235 
      self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
3236 
    except WarehouseServiceException, ex:
3237 
      result.ex = ex
6762 amar.kumar 3238 
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
3239 
    result.write(oprot)
3240 
    oprot.writeMessageEnd()
3241 
    oprot.trans.flush()
3242 
 
6880 amar.kumar 3243 
  def process_getMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
3244 
    args = getMovementNonSerializedInventoryByScans_args()
3245 
    args.read(iprot)
3246 
    iprot.readMessageEnd()
3247 
    result = getMovementNonSerializedInventoryByScans_result()
3248 
    result.success = self._handler.getMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
3249 
    oprot.writeMessageBegin("getMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
3250 
    result.write(oprot)
3251 
    oprot.writeMessageEnd()
3252 
    oprot.trans.flush()
6762 amar.kumar 3253 
 
6880 amar.kumar 3254 
  def process_getMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
3255 
    args = getMovementSerializedInventoryByScans_args()
3256 
    args.read(iprot)
3257 
    iprot.readMessageEnd()
3258 
    result = getMovementSerializedInventoryByScans_result()
3259 
    result.success = self._handler.getMovementSerializedInventoryByScans(args.startDate, args.endDate)
3260 
    oprot.writeMessageBegin("getMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
3261 
    result.write(oprot)
3262 
    oprot.writeMessageEnd()
3263 
    oprot.trans.flush()
3264 
 
7216 amar.kumar 3265 
  def process_getCompleteMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
3266 
    args = getCompleteMovementSerializedInventoryByScans_args()
3267 
    args.read(iprot)
3268 
    iprot.readMessageEnd()
3269 
    result = getCompleteMovementSerializedInventoryByScans_result()
3270 
    result.success = self._handler.getCompleteMovementSerializedInventoryByScans(args.startDate, args.endDate)
3271 
    oprot.writeMessageBegin("getCompleteMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
3272 
    result.write(oprot)
3273 
    oprot.writeMessageEnd()
3274 
    oprot.trans.flush()
3275 
 
3276 
  def process_getCompleteMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
3277 
    args = getCompleteMovementNonSerializedInventoryByScans_args()
3278 
    args.read(iprot)
3279 
    iprot.readMessageEnd()
3280 
    result = getCompleteMovementNonSerializedInventoryByScans_result()
3281 
    result.success = self._handler.getCompleteMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
3282 
    oprot.writeMessageBegin("getCompleteMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
3283 
    result.write(oprot)
3284 
    oprot.writeMessageEnd()
3285 
    oprot.trans.flush()
3286 
 
7190 amar.kumar 3287 
  def process_scanfreebie(self, seqid, iprot, oprot):
3288 
    args = scanfreebie_args()
3289 
    args.read(iprot)
3290 
    iprot.readMessageEnd()
3291 
    result = scanfreebie_result()
3292 
    try:
3293 
      result.success = self._handler.scanfreebie(args.orderId, args.freebieItemId, args.freebieWarehouseId, args.scanType)
3294 
    except WarehouseServiceException, wex:
3295 
      result.wex = wex
3296 
    oprot.writeMessageBegin("scanfreebie", TMessageType.REPLY, seqid)
3297 
    result.write(oprot)
3298 
    oprot.writeMessageEnd()
3299 
    oprot.trans.flush()
6880 amar.kumar 3300 
 
7199 amar.kumar 3301 
  def process_reshipfreebie(self, seqid, iprot, oprot):
3302 
    args = reshipfreebie_args()
3303 
    args.read(iprot)
3304 
    iprot.readMessageEnd()
3305 
    result = reshipfreebie_result()
3306 
    try:
3307 
      self._handler.reshipfreebie(args.oldOrderId, args.newOrderId, args.freebieItemId, args.scanType)
3308 
    except WarehouseServiceException, wex:
3309 
      result.wex = wex
3310 
    oprot.writeMessageBegin("reshipfreebie", TMessageType.REPLY, seqid)
3311 
    result.write(oprot)
3312 
    oprot.writeMessageEnd()
3313 
    oprot.trans.flush()
7190 amar.kumar 3314 
 
7410 amar.kumar 3315 
  def process_isItemTransferAllowed(self, seqid, iprot, oprot):
3316 
    args = isItemTransferAllowed_args()
3317 
    args.read(iprot)
3318 
    iprot.readMessageEnd()
3319 
    result = isItemTransferAllowed_result()
3320 
    result.success = self._handler.isItemTransferAllowed(args.warehouseId, args.transferWarehouseId)
3321 
    oprot.writeMessageBegin("isItemTransferAllowed", TMessageType.REPLY, seqid)
3322 
    result.write(oprot)
3323 
    oprot.writeMessageEnd()
3324 
    oprot.trans.flush()
7199 amar.kumar 3325 
 
7410 amar.kumar 3326 
  def process_createTransferLot(self, seqid, iprot, oprot):
3327 
    args = createTransferLot_args()
3328 
    args.read(iprot)
3329 
    iprot.readMessageEnd()
3330 
    result = createTransferLot_result()
3331 
    try:
3332 
      result.success = self._handler.createTransferLot(args.originWarehouseId, args.destWarehouseId)
3333 
    except WarehouseServiceException, wex:
3334 
      result.wex = wex
3335 
    oprot.writeMessageBegin("createTransferLot", TMessageType.REPLY, seqid)
3336 
    result.write(oprot)
3337 
    oprot.writeMessageEnd()
3338 
    oprot.trans.flush()
3339 
 
3340 
  def process_getTransferLot(self, seqid, iprot, oprot):
3341 
    args = getTransferLot_args()
3342 
    args.read(iprot)
3343 
    iprot.readMessageEnd()
3344 
    result = getTransferLot_result()
3345 
    try:
3346 
      result.success = self._handler.getTransferLot(args.transferLotId)
3347 
    except WarehouseServiceException, wex:
3348 
      result.wex = wex
3349 
    oprot.writeMessageBegin("getTransferLot", TMessageType.REPLY, seqid)
3350 
    result.write(oprot)
3351 
    oprot.writeMessageEnd()
3352 
    oprot.trans.flush()
3353 
 
3354 
  def process_markTransferLotAsReceived(self, seqid, iprot, oprot):
3355 
    args = markTransferLotAsReceived_args()
3356 
    args.read(iprot)
3357 
    iprot.readMessageEnd()
3358 
    result = markTransferLotAsReceived_result()
3359 
    try:
3360 
      self._handler.markTransferLotAsReceived(args.id, args.remoteTransferRefNumber)
3361 
    except WarehouseServiceException, wex:
3362 
      result.wex = wex
3363 
    oprot.writeMessageBegin("markTransferLotAsReceived", TMessageType.REPLY, seqid)
3364 
    result.write(oprot)
3365 
    oprot.writeMessageEnd()
3366 
    oprot.trans.flush()
3367 
 
3368 
  def process_getTransferLotsByDate(self, seqid, iprot, oprot):
3369 
    args = getTransferLotsByDate_args()
3370 
    args.read(iprot)
3371 
    iprot.readMessageEnd()
3372 
    result = getTransferLotsByDate_result()
3373 
    try:
3374 
      result.success = self._handler.getTransferLotsByDate(args.fromDate, args.toDate)
3375 
    except WarehouseServiceException, wex:
3376 
      result.wex = wex
3377 
    oprot.writeMessageBegin("getTransferLotsByDate", TMessageType.REPLY, seqid)
3378 
    result.write(oprot)
3379 
    oprot.writeMessageEnd()
3380 
    oprot.trans.flush()
3381 
 
3382 
  def process_getAllowedDestinationWarehousesForTransfer(self, seqid, iprot, oprot):
3383 
    args = getAllowedDestinationWarehousesForTransfer_args()
3384 
    args.read(iprot)
3385 
    iprot.readMessageEnd()
3386 
    result = getAllowedDestinationWarehousesForTransfer_result()
3387 
    result.success = self._handler.getAllowedDestinationWarehousesForTransfer(args.warehouseId)
3388 
    oprot.writeMessageBegin("getAllowedDestinationWarehousesForTransfer", TMessageType.REPLY, seqid)
3389 
    result.write(oprot)
3390 
    oprot.writeMessageEnd()
3391 
    oprot.trans.flush()
3392 
 
3393 
  def process_getItemsInTransferLot(self, seqid, iprot, oprot):
3394 
    args = getItemsInTransferLot_args()
3395 
    args.read(iprot)
3396 
    iprot.readMessageEnd()
3397 
    result = getItemsInTransferLot_result()
3398 
    result.success = self._handler.getItemsInTransferLot(args.transferLotId)
3399 
    oprot.writeMessageBegin("getItemsInTransferLot", TMessageType.REPLY, seqid)
3400 
    result.write(oprot)
3401 
    oprot.writeMessageEnd()
3402 
    oprot.trans.flush()
3403 
 
3404 
  def process_markItemsAsReceivedForTransferLot(self, seqid, iprot, oprot):
3405 
    args = markItemsAsReceivedForTransferLot_args()
3406 
    args.read(iprot)
3407 
    iprot.readMessageEnd()
3408 
    result = markItemsAsReceivedForTransferLot_result()
3409 
    try:
3410 
      self._handler.markItemsAsReceivedForTransferLot(args.id)
3411 
    except WarehouseServiceException, wex:
3412 
      result.wex = wex
3413 
    oprot.writeMessageBegin("markItemsAsReceivedForTransferLot", TMessageType.REPLY, seqid)
3414 
    result.write(oprot)
3415 
    oprot.writeMessageEnd()
3416 
    oprot.trans.flush()
3417 
 
3418 
  def process_updateTransferLotAfterItemReceive(self, seqid, iprot, oprot):
3419 
    args = updateTransferLotAfterItemReceive_args()
3420 
    args.read(iprot)
3421 
    iprot.readMessageEnd()
3422 
    result = updateTransferLotAfterItemReceive_result()
3423 
    try:
3424 
      result.success = self._handler.updateTransferLotAfterItemReceive(args.id)
3425 
    except WarehouseServiceException, wex:
3426 
      result.wex = wex
3427 
    oprot.writeMessageBegin("updateTransferLotAfterItemReceive", TMessageType.REPLY, seqid)
3428 
    result.write(oprot)
3429 
    oprot.writeMessageEnd()
3430 
    oprot.trans.flush()
3431 
 
7459 amar.kumar 3432 
  def process_scanForTransferOut(self, seqid, iprot, oprot):
3433 
    args = scanForTransferOut_args()
7410 amar.kumar 3434 
    args.read(iprot)
3435 
    iprot.readMessageEnd()
7459 amar.kumar 3436 
    result = scanForTransferOut_result()
7410 amar.kumar 3437 
    try:
7459 amar.kumar 3438 
      self._handler.scanForTransferOut(args.inventoryItems, args.type, args.transferLotId)
7410 amar.kumar 3439 
    except WarehouseServiceException, wex:
3440 
      result.wex = wex
7459 amar.kumar 3441 
    oprot.writeMessageBegin("scanForTransferOut", TMessageType.REPLY, seqid)
7410 amar.kumar 3442 
    result.write(oprot)
3443 
    oprot.writeMessageEnd()
3444 
    oprot.trans.flush()
3445 
 
7459 amar.kumar 3446 
  def process_scanForTransferIn(self, seqid, iprot, oprot):
3447 
    args = scanForTransferIn_args()
3448 
    args.read(iprot)
3449 
    iprot.readMessageEnd()
3450 
    result = scanForTransferIn_result()
3451 
    try:
3452 
      self._handler.scanForTransferIn(args.inventoryItems, args.type, args.transferLotId)
3453 
    except WarehouseServiceException, wex:
3454 
      result.wex = wex
3455 
    oprot.writeMessageBegin("scanForTransferIn", TMessageType.REPLY, seqid)
3456 
    result.write(oprot)
3457 
    oprot.writeMessageEnd()
3458 
    oprot.trans.flush()
7410 amar.kumar 3459 
 
7459 amar.kumar 3460 
  def process_scanForOursThirdPartyReceive(self, seqid, iprot, oprot):
3461 
    args = scanForOursThirdPartyReceive_args()
3462 
    args.read(iprot)
3463 
    iprot.readMessageEnd()
3464 
    result = scanForOursThirdPartyReceive_result()
3465 
    try:
3466 
      self._handler.scanForOursThirdPartyReceive(args.inventoryItems, args.id)
3467 
    except WarehouseServiceException, wex:
3468 
      result.wex = wex
3469 
    oprot.writeMessageBegin("scanForOursThirdPartyReceive", TMessageType.REPLY, seqid)
3470 
    result.write(oprot)
3471 
    oprot.writeMessageEnd()
3472 
    oprot.trans.flush()
3473 
 
7574 amar.kumar 3474 
  def process_getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(self, seqid, iprot, oprot):
3475 
    args = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args()
3476 
    args.read(iprot)
3477 
    iprot.readMessageEnd()
3478 
    result = getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result()
3479 
    try:
3480 
      result.success = self._handler.getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(args.itemId, args.physicalWarehouseId)
3481 
    except WarehouseServiceException, wex:
3482 
      result.wex = wex
3483 
    oprot.writeMessageBegin("getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse", TMessageType.REPLY, seqid)
3484 
    result.write(oprot)
3485 
    oprot.writeMessageEnd()
3486 
    oprot.trans.flush()
7459 amar.kumar 3487 
 
7672 rajveer 3488 
  def process_getInTransitInventory(self, seqid, iprot, oprot):
3489 
    args = getInTransitInventory_args()
3490 
    args.read(iprot)
3491 
    iprot.readMessageEnd()
3492 
    result = getInTransitInventory_result()
3493 
    result.success = self._handler.getInTransitInventory(args.originWarehouseId)
3494 
    oprot.writeMessageBegin("getInTransitInventory", TMessageType.REPLY, seqid)
3495 
    result.write(oprot)
3496 
    oprot.writeMessageEnd()
3497 
    oprot.trans.flush()
7574 amar.kumar 3498 
 
7968 amar.kumar 3499 
  def process_isItemAvailableForSale(self, seqid, iprot, oprot):
3500 
    args = isItemAvailableForSale_args()
3501 
    args.read(iprot)
3502 
    iprot.readMessageEnd()
3503 
    result = isItemAvailableForSale_result()
3504 
    try:
3505 
      result.success = self._handler.isItemAvailableForSale(args.itemId, args.serialNumber, args.warehouseId)
3506 
    except WarehouseServiceException, wex:
3507 
      result.wex = wex
3508 
    oprot.writeMessageBegin("isItemAvailableForSale", TMessageType.REPLY, seqid)
3509 
    result.write(oprot)
3510 
    oprot.writeMessageEnd()
3511 
    oprot.trans.flush()
7672 rajveer 3512 
 
7968 amar.kumar 3513 
  def process_getHistoricBadInventoryByScans(self, seqid, iprot, oprot):
3514 
    args = getHistoricBadInventoryByScans_args()
3515 
    args.read(iprot)
3516 
    iprot.readMessageEnd()
3517 
    result = getHistoricBadInventoryByScans_result()
3518 
    try:
3519 
      result.success = self._handler.getHistoricBadInventoryByScans(args.date)
3520 
    except WarehouseServiceException, wex:
3521 
      result.wex = wex
3522 
    oprot.writeMessageBegin("getHistoricBadInventoryByScans", TMessageType.REPLY, seqid)
3523 
    result.write(oprot)
3524 
    oprot.writeMessageEnd()
3525 
    oprot.trans.flush()
3526 
 
8565 amar.kumar 3527 
  def process_scanForBadSale(self, seqid, iprot, oprot):
3528 
    args = scanForBadSale_args()
3529 
    args.read(iprot)
3530 
    iprot.readMessageEnd()
3531 
    result = scanForBadSale_result()
8717 amar.kumar 3532 
    try:
3533 
      result.success = self._handler.scanForBadSale(args.serialNumber, args.itemNumber, args.itemId, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
3534 
    except WarehouseServiceException, wex:
3535 
      result.wex = wex
8565 amar.kumar 3536 
    oprot.writeMessageBegin("scanForBadSale", TMessageType.REPLY, seqid)
3537 
    result.write(oprot)
3538 
    oprot.writeMessageEnd()
3539 
    oprot.trans.flush()
7968 amar.kumar 3540 
 
10120 manish.sha 3541 
  def process_getTransferLotItemsForMarkReceive(self, seqid, iprot, oprot):
3542 
    args = getTransferLotItemsForMarkReceive_args()
3543 
    args.read(iprot)
3544 
    iprot.readMessageEnd()
3545 
    result = getTransferLotItemsForMarkReceive_result()
3546 
    try:
3547 
      result.success = self._handler.getTransferLotItemsForMarkReceive(args.transferLotId, args.scanType)
3548 
    except WarehouseServiceException, wex:
3549 
      result.wex = wex
3550 
    oprot.writeMessageBegin("getTransferLotItemsForMarkReceive", TMessageType.REPLY, seqid)
3551 
    result.write(oprot)
3552 
    oprot.writeMessageEnd()
3553 
    oprot.trans.flush()
8565 amar.kumar 3554 
 
10120 manish.sha 3555 
  def process_markItemsAsReceivedForTransferLotPartial(self, seqid, iprot, oprot):
3556 
    args = markItemsAsReceivedForTransferLotPartial_args()
3557 
    args.read(iprot)
3558 
    iprot.readMessageEnd()
3559 
    result = markItemsAsReceivedForTransferLotPartial_result()
3560 
    try:
3561 
      self._handler.markItemsAsReceivedForTransferLotPartial(args.inventoryItems, args.transferLotId)
3562 
    except WarehouseServiceException, wex:
3563 
      result.wex = wex
3564 
    oprot.writeMessageBegin("markItemsAsReceivedForTransferLotPartial", TMessageType.REPLY, seqid)
3565 
    result.write(oprot)
3566 
    oprot.writeMessageEnd()
3567 
    oprot.trans.flush()
3568 
 
3569 
  def process_markTransferLotAsReceivedPartial(self, seqid, iprot, oprot):
3570 
    args = markTransferLotAsReceivedPartial_args()
3571 
    args.read(iprot)
3572 
    iprot.readMessageEnd()
3573 
    result = markTransferLotAsReceivedPartial_result()
3574 
    try:
3575 
      self._handler.markTransferLotAsReceivedPartial(args.id, args.remoteTransferRefNumber)
3576 
    except WarehouseServiceException, wex:
3577 
      result.wex = wex
3578 
    oprot.writeMessageBegin("markTransferLotAsReceivedPartial", TMessageType.REPLY, seqid)
3579 
    result.write(oprot)
3580 
    oprot.writeMessageEnd()
3581 
    oprot.trans.flush()
3582 
 
10690 manish.sha 3583 
  def process_getInventoryItemScannedInForPO(self, seqid, iprot, oprot):
3584 
    args = getInventoryItemScannedInForPO_args()
3585 
    args.read(iprot)
3586 
    iprot.readMessageEnd()
3587 
    result = getInventoryItemScannedInForPO_result()
3588 
    try:
3589 
      result.success = self._handler.getInventoryItemScannedInForPO(args.itemId, args.purchaseIds)
3590 
    except WarehouseServiceException, wex:
3591 
      result.wex = wex
3592 
    oprot.writeMessageBegin("getInventoryItemScannedInForPO", TMessageType.REPLY, seqid)
3593 
    result.write(oprot)
3594 
    oprot.writeMessageEnd()
3595 
    oprot.trans.flush()
10120 manish.sha 3596 
 
10690 manish.sha 3597 
  def process_getAmazonTransferredSkuDetails(self, seqid, iprot, oprot):
3598 
    args = getAmazonTransferredSkuDetails_args()
3599 
    args.read(iprot)
3600 
    iprot.readMessageEnd()
3601 
    result = getAmazonTransferredSkuDetails_result()
3602 
    try:
3603 
      result.success = self._handler.getAmazonTransferredSkuDetails(args.itemIds)
3604 
    except WarehouseServiceException, wex:
3605 
      result.wex = wex
3606 
    oprot.writeMessageBegin("getAmazonTransferredSkuDetails", TMessageType.REPLY, seqid)
3607 
    result.write(oprot)
3608 
    oprot.writeMessageEnd()
3609 
    oprot.trans.flush()
3610 
 
3611 
  def process_getScansforPurchase(self, seqid, iprot, oprot):
3612 
    args = getScansforPurchase_args()
3613 
    args.read(iprot)
3614 
    iprot.readMessageEnd()
3615 
    result = getScansforPurchase_result()
3616 
    try:
3617 
      result.success = self._handler.getScansforPurchase(args.purchaseId, args.scanType)
3618 
    except WarehouseServiceException, wex:
3619 
      result.wex = wex
3620 
    oprot.writeMessageBegin("getScansforPurchase", TMessageType.REPLY, seqid)
3621 
    result.write(oprot)
3622 
    oprot.writeMessageEnd()
3623 
    oprot.trans.flush()
3624 
 
10864 manish.sha 3625 
  def process_getCurrentBadQuantityForItem(self, seqid, iprot, oprot):
3626 
    args = getCurrentBadQuantityForItem_args()
3627 
    args.read(iprot)
3628 
    iprot.readMessageEnd()
3629 
    result = getCurrentBadQuantityForItem_result()
3630 
    try:
3631 
      result.success = self._handler.getCurrentBadQuantityForItem(args.itemId, args.currentWarehouseId, args.physicalWarehouseId)
3632 
    except WarehouseServiceException, wex:
3633 
      result.wex = wex
3634 
    oprot.writeMessageBegin("getCurrentBadQuantityForItem", TMessageType.REPLY, seqid)
3635 
    result.write(oprot)
3636 
    oprot.writeMessageEnd()
3637 
    oprot.trans.flush()
10690 manish.sha 3638 
 
10864 manish.sha 3639 
  def process_scanForBadPurchaseReturn(self, seqid, iprot, oprot):
3640 
    args = scanForBadPurchaseReturn_args()
3641 
    args.read(iprot)
3642 
    iprot.readMessageEnd()
3643 
    result = scanForBadPurchaseReturn_result()
3644 
    try:
3645 
      result.success = self._handler.scanForBadPurchaseReturn(args.saleReturnItems, args.vendorId, args.billingWarehouseId)
3646 
    except WarehouseServiceException, ex:
3647 
      result.ex = ex
3648 
    oprot.writeMessageBegin("scanForBadPurchaseReturn", TMessageType.REPLY, seqid)
3649 
    result.write(oprot)
3650 
    oprot.writeMessageEnd()
3651 
    oprot.trans.flush()
3652 
 
3653 
  def process_getItemsInPurchaseReturn(self, seqid, iprot, oprot):
3654 
    args = getItemsInPurchaseReturn_args()
3655 
    args.read(iprot)
3656 
    iprot.readMessageEnd()
3657 
    result = getItemsInPurchaseReturn_result()
3658 
    try:
11751 manish.sha 3659 
      result.success = self._handler.getItemsInPurchaseReturn(args.purchaseReturnId, args.type)
10864 manish.sha 3660 
    except WarehouseServiceException, ex:
3661 
      result.ex = ex
3662 
    oprot.writeMessageBegin("getItemsInPurchaseReturn", TMessageType.REPLY, seqid)
3663 
    result.write(oprot)
3664 
    oprot.writeMessageEnd()
3665 
    oprot.trans.flush()
3666 
 
10886 manish.sha 3667 
  def process_getScansForInventoryItem(self, seqid, iprot, oprot):
3668 
    args = getScansForInventoryItem_args()
3669 
    args.read(iprot)
3670 
    iprot.readMessageEnd()
3671 
    result = getScansForInventoryItem_result()
3672 
    try:
3673 
      result.success = self._handler.getScansForInventoryItem(args.inventoryItemId, args.type)
3674 
    except WarehouseServiceException, ex:
3675 
      result.ex = ex
3676 
    oprot.writeMessageBegin("getScansForInventoryItem", TMessageType.REPLY, seqid)
3677 
    result.write(oprot)
3678 
    oprot.writeMessageEnd()
3679 
    oprot.trans.flush()
10864 manish.sha 3680 
 
12531 manish.sha 3681 
  def process_checkGrnImeiStatus(self, seqid, iprot, oprot):
3682 
    args = checkGrnImeiStatus_args()
3683 
    args.read(iprot)
3684 
    iprot.readMessageEnd()
3685 
    result = checkGrnImeiStatus_result()
3686 
    try:
3687 
      result.success = self._handler.checkGrnImeiStatus(args.imeiNos)
3688 
    except WarehouseServiceException, ex:
3689 
      result.ex = ex
3690 
    oprot.writeMessageBegin("checkGrnImeiStatus", TMessageType.REPLY, seqid)
3691 
    result.write(oprot)
3692 
    oprot.writeMessageEnd()
3693 
    oprot.trans.flush()
10886 manish.sha 3694 
 
12800 manish.sha 3695 
  def process_getInventoryAgeConsideredItems(self, seqid, iprot, oprot):
3696 
    args = getInventoryAgeConsideredItems_args()
3697 
    args.read(iprot)
3698 
    iprot.readMessageEnd()
3699 
    result = getInventoryAgeConsideredItems_result()
3700 
    try:
3701 
      result.success = self._handler.getInventoryAgeConsideredItems(args.itemId)
3702 
    except WarehouseServiceException, ex:
3703 
      result.ex = ex
3704 
    oprot.writeMessageBegin("getInventoryAgeConsideredItems", TMessageType.REPLY, seqid)
3705 
    result.write(oprot)
3706 
    oprot.writeMessageEnd()
3707 
    oprot.trans.flush()
12531 manish.sha 3708 
 
12800 manish.sha 3709 
 
2821 chandransh 3710 
# HELPER FUNCTIONS AND STRUCTURES
3711 
 
4501 mandeep.dh 3712 
class getInventoryItem_args:
2832 chandransh 3713 
  """
3714 
  Attributes:
4501 mandeep.dh 3715 
   - serialNumber
2832 chandransh 3716 
  """
3717 
 
3718 
  thrift_spec = (
3719 
    None, # 0
4501 mandeep.dh 3720 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
2832 chandransh 3721 
  )
3722 
 
4501 mandeep.dh 3723 
  def __init__(self, serialNumber=None,):
3724 
    self.serialNumber = serialNumber
2832 chandransh 3725 
 
3726 
  def read(self, iprot):
3727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3729 
      return
3730 
    iprot.readStructBegin()
3731 
    while True:
3732 
      (fname, ftype, fid) = iprot.readFieldBegin()
3733 
      if ftype == TType.STOP:
3734 
        break
3735 
      if fid == 1:
4501 mandeep.dh 3736 
        if ftype == TType.STRING:
3737 
          self.serialNumber = iprot.readString();
2832 chandransh 3738 
        else:
3739 
          iprot.skip(ftype)
3740 
      else:
3741 
        iprot.skip(ftype)
3742 
      iprot.readFieldEnd()
3743 
    iprot.readStructEnd()
3744 
 
3745 
  def write(self, oprot):
3746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3748 
      return
4501 mandeep.dh 3749 
    oprot.writeStructBegin('getInventoryItem_args')
3750 
    if self.serialNumber is not None:
3751 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
3752 
      oprot.writeString(self.serialNumber)
2832 chandransh 3753 
      oprot.writeFieldEnd()
3754 
    oprot.writeFieldStop()
3755 
    oprot.writeStructEnd()
3756 
 
3431 rajveer 3757 
  def validate(self):
3758 
    return
3759 
 
3760 
 
2832 chandransh 3761 
  def __repr__(self):
3762 
    L = ['%s=%r' % (key, value)
3763 
      for key, value in self.__dict__.iteritems()]
3764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3765 
 
3766 
  def __eq__(self, other):
3767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3768 
 
3769 
  def __ne__(self, other):
3770 
    return not (self == other)
3771 
 
4501 mandeep.dh 3772 
class getInventoryItem_result:
2832 chandransh 3773 
  """
3774 
  Attributes:
3775 
   - success
4541 mandeep.dh 3776 
   - wex
2832 chandransh 3777 
  """
3778 
 
3779 
  thrift_spec = (
4501 mandeep.dh 3780 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4541 mandeep.dh 3781 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2832 chandransh 3782 
  )
3783 
 
4541 mandeep.dh 3784 
  def __init__(self, success=None, wex=None,):
2832 chandransh 3785 
    self.success = success
4541 mandeep.dh 3786 
    self.wex = wex
2832 chandransh 3787 
 
3788 
  def read(self, iprot):
3789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3791 
      return
3792 
    iprot.readStructBegin()
3793 
    while True:
3794 
      (fname, ftype, fid) = iprot.readFieldBegin()
3795 
      if ftype == TType.STOP:
3796 
        break
3797 
      if fid == 0:
3798 
        if ftype == TType.STRUCT:
4501 mandeep.dh 3799 
          self.success = InventoryItem()
2832 chandransh 3800 
          self.success.read(iprot)
3801 
        else:
3802 
          iprot.skip(ftype)
4541 mandeep.dh 3803 
      elif fid == 1:
3804 
        if ftype == TType.STRUCT:
3805 
          self.wex = WarehouseServiceException()
3806 
          self.wex.read(iprot)
3807 
        else:
3808 
          iprot.skip(ftype)
2832 chandransh 3809 
      else:
3810 
        iprot.skip(ftype)
3811 
      iprot.readFieldEnd()
3812 
    iprot.readStructEnd()
3813 
 
3814 
  def write(self, oprot):
3815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3817 
      return
4501 mandeep.dh 3818 
    oprot.writeStructBegin('getInventoryItem_result')
3431 rajveer 3819 
    if self.success is not None:
2832 chandransh 3820 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3821 
      self.success.write(oprot)
3822 
      oprot.writeFieldEnd()
4541 mandeep.dh 3823 
    if self.wex is not None:
3824 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
3825 
      self.wex.write(oprot)
3826 
      oprot.writeFieldEnd()
2832 chandransh 3827 
    oprot.writeFieldStop()
3828 
    oprot.writeStructEnd()
3829 
 
3431 rajveer 3830 
  def validate(self):
3831 
    return
3832 
 
3833 
 
2832 chandransh 3834 
  def __repr__(self):
3835 
    L = ['%s=%r' % (key, value)
3836 
      for key, value in self.__dict__.iteritems()]
3837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3838 
 
3839 
  def __eq__(self, other):
3840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3841 
 
3842 
  def __ne__(self, other):
3843 
    return not (self == other)
3844 
 
5361 mandeep.dh 3845 
class getNonSeralizedInventoryItem_args:
2821 chandransh 3846 
  """
3847 
  Attributes:
5530 mandeep.dh 3848 
   - itemNumber
4501 mandeep.dh 3849 
   - itemId
5530 mandeep.dh 3850 
   - fulfilmentWarehouseId
8565 amar.kumar 3851 
   - billingWarehouseId
2821 chandransh 3852 
  """
3853 
 
3854 
  thrift_spec = (
3855 
    None, # 0
5530 mandeep.dh 3856 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
3857 
    (2, TType.I64, 'itemId', None, None, ), # 2
3858 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
8565 amar.kumar 3859 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
2821 chandransh 3860 
  )
3861 
 
8565 amar.kumar 3862 
  def __init__(self, itemNumber=None, itemId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
5530 mandeep.dh 3863 
    self.itemNumber = itemNumber
4501 mandeep.dh 3864 
    self.itemId = itemId
5530 mandeep.dh 3865 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
8565 amar.kumar 3866 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 3867 
 
3868 
  def read(self, iprot):
3869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3871 
      return
3872 
    iprot.readStructBegin()
3873 
    while True:
3874 
      (fname, ftype, fid) = iprot.readFieldBegin()
3875 
      if ftype == TType.STOP:
3876 
        break
3877 
      if fid == 1:
5530 mandeep.dh 3878 
        if ftype == TType.STRING:
3879 
          self.itemNumber = iprot.readString();
3880 
        else:
3881 
          iprot.skip(ftype)
3882 
      elif fid == 2:
2821 chandransh 3883 
        if ftype == TType.I64:
4501 mandeep.dh 3884 
          self.itemId = iprot.readI64();
2821 chandransh 3885 
        else:
3886 
          iprot.skip(ftype)
5530 mandeep.dh 3887 
      elif fid == 3:
4501 mandeep.dh 3888 
        if ftype == TType.I64:
5530 mandeep.dh 3889 
          self.fulfilmentWarehouseId = iprot.readI64();
2821 chandransh 3890 
        else:
3891 
          iprot.skip(ftype)
8565 amar.kumar 3892 
      elif fid == 4:
3893 
        if ftype == TType.I64:
3894 
          self.billingWarehouseId = iprot.readI64();
3895 
        else:
3896 
          iprot.skip(ftype)
2821 chandransh 3897 
      else:
3898 
        iprot.skip(ftype)
3899 
      iprot.readFieldEnd()
3900 
    iprot.readStructEnd()
3901 
 
3902 
  def write(self, oprot):
3903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3905 
      return
5361 mandeep.dh 3906 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_args')
5530 mandeep.dh 3907 
    if self.itemNumber is not None:
3908 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
3909 
      oprot.writeString(self.itemNumber)
3910 
      oprot.writeFieldEnd()
4501 mandeep.dh 3911 
    if self.itemId is not None:
5530 mandeep.dh 3912 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
4501 mandeep.dh 3913 
      oprot.writeI64(self.itemId)
2821 chandransh 3914 
      oprot.writeFieldEnd()
5530 mandeep.dh 3915 
    if self.fulfilmentWarehouseId is not None:
3916 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
3917 
      oprot.writeI64(self.fulfilmentWarehouseId)
2821 chandransh 3918 
      oprot.writeFieldEnd()
8565 amar.kumar 3919 
    if self.billingWarehouseId is not None:
3920 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
3921 
      oprot.writeI64(self.billingWarehouseId)
3922 
      oprot.writeFieldEnd()
2821 chandransh 3923 
    oprot.writeFieldStop()
3924 
    oprot.writeStructEnd()
3925 
 
3431 rajveer 3926 
  def validate(self):
3927 
    return
3928 
 
3929 
 
2821 chandransh 3930 
  def __repr__(self):
3931 
    L = ['%s=%r' % (key, value)
3932 
      for key, value in self.__dict__.iteritems()]
3933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3934 
 
3935 
  def __eq__(self, other):
3936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3937 
 
3938 
  def __ne__(self, other):
3939 
    return not (self == other)
3940 
 
5361 mandeep.dh 3941 
class getNonSeralizedInventoryItem_result:
2821 chandransh 3942 
  """
3943 
  Attributes:
3944 
   - success
5361 mandeep.dh 3945 
   - wex
2821 chandransh 3946 
  """
3947 
 
3948 
  thrift_spec = (
5361 mandeep.dh 3949 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3950 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2821 chandransh 3951 
  )
3952 
 
5361 mandeep.dh 3953 
  def __init__(self, success=None, wex=None,):
2821 chandransh 3954 
    self.success = success
5361 mandeep.dh 3955 
    self.wex = wex
2821 chandransh 3956 
 
3957 
  def read(self, iprot):
3958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3960 
      return
3961 
    iprot.readStructBegin()
3962 
    while True:
3963 
      (fname, ftype, fid) = iprot.readFieldBegin()
3964 
      if ftype == TType.STOP:
3965 
        break
3966 
      if fid == 0:
5361 mandeep.dh 3967 
        if ftype == TType.STRUCT:
3968 
          self.success = InventoryItem()
3969 
          self.success.read(iprot)
2821 chandransh 3970 
        else:
3971 
          iprot.skip(ftype)
5361 mandeep.dh 3972 
      elif fid == 1:
3973 
        if ftype == TType.STRUCT:
3974 
          self.wex = WarehouseServiceException()
3975 
          self.wex.read(iprot)
2821 chandransh 3976 
        else:
3977 
          iprot.skip(ftype)
3978 
      else:
3979 
        iprot.skip(ftype)
3980 
      iprot.readFieldEnd()
3981 
    iprot.readStructEnd()
3982 
 
3983 
  def write(self, oprot):
3984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3986 
      return
5361 mandeep.dh 3987 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_result')
3431 rajveer 3988 
    if self.success is not None:
5361 mandeep.dh 3989 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3990 
      self.success.write(oprot)
2821 chandransh 3991 
      oprot.writeFieldEnd()
5361 mandeep.dh 3992 
    if self.wex is not None:
3993 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
3994 
      self.wex.write(oprot)
3383 chandransh 3995 
      oprot.writeFieldEnd()
3996 
    oprot.writeFieldStop()
3997 
    oprot.writeStructEnd()
3998 
 
3431 rajveer 3999 
  def validate(self):
4000 
    return
4001 
 
4002 
 
3383 chandransh 4003 
  def __repr__(self):
4004 
    L = ['%s=%r' % (key, value)
4005 
      for key, value in self.__dict__.iteritems()]
4006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4007 
 
4008 
  def __eq__(self, other):
4009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4010 
 
4011 
  def __ne__(self, other):
4012 
    return not (self == other)
4013 
 
4501 mandeep.dh 4014 
class scan_args:
2821 chandransh 4015 
  """
4016 
  Attributes:
5361 mandeep.dh 4017 
   - inventoryItem
2821 chandransh 4018 
   - type
4501 mandeep.dh 4019 
   - quantity
5361 mandeep.dh 4020 
   - billingWarehouseId
7410 amar.kumar 4021 
   - transferLotId
2821 chandransh 4022 
  """
4023 
 
4024 
  thrift_spec = (
4025 
    None, # 0
5361 mandeep.dh 4026 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 4027 
    (2, TType.I32, 'type', None, None, ), # 2
4028 
    (3, TType.I64, 'quantity', None, None, ), # 3
5361 mandeep.dh 4029 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
7410 amar.kumar 4030 
    (5, TType.I64, 'transferLotId', None, None, ), # 5
2821 chandransh 4031 
  )
4032 
 
7410 amar.kumar 4033 
  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None, transferLotId=None,):
5361 mandeep.dh 4034 
    self.inventoryItem = inventoryItem
2821 chandransh 4035 
    self.type = type
4501 mandeep.dh 4036 
    self.quantity = quantity
5361 mandeep.dh 4037 
    self.billingWarehouseId = billingWarehouseId
7410 amar.kumar 4038 
    self.transferLotId = transferLotId
2821 chandransh 4039 
 
4040 
  def read(self, iprot):
4041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4043 
      return
4044 
    iprot.readStructBegin()
4045 
    while True:
4046 
      (fname, ftype, fid) = iprot.readFieldBegin()
4047 
      if ftype == TType.STOP:
4048 
        break
4049 
      if fid == 1:
5361 mandeep.dh 4050 
        if ftype == TType.STRUCT:
4051 
          self.inventoryItem = InventoryItem()
4052 
          self.inventoryItem.read(iprot)
2821 chandransh 4053 
        else:
4054 
          iprot.skip(ftype)
4055 
      elif fid == 2:
4501 mandeep.dh 4056 
        if ftype == TType.I32:
4057 
          self.type = iprot.readI32();
2821 chandransh 4058 
        else:
4059 
          iprot.skip(ftype)
3383 chandransh 4060 
      elif fid == 3:
4501 mandeep.dh 4061 
        if ftype == TType.I64:
4062 
          self.quantity = iprot.readI64();
2821 chandransh 4063 
        else:
4064 
          iprot.skip(ftype)
3383 chandransh 4065 
      elif fid == 4:
4501 mandeep.dh 4066 
        if ftype == TType.I64:
5361 mandeep.dh 4067 
          self.billingWarehouseId = iprot.readI64();
2821 chandransh 4068 
        else:
4069 
          iprot.skip(ftype)
7410 amar.kumar 4070 
      elif fid == 5:
4071 
        if ftype == TType.I64:
4072 
          self.transferLotId = iprot.readI64();
4073 
        else:
4074 
          iprot.skip(ftype)
2821 chandransh 4075 
      else:
4076 
        iprot.skip(ftype)
4077 
      iprot.readFieldEnd()
4078 
    iprot.readStructEnd()
4079 
 
4080 
  def write(self, oprot):
4081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4083 
      return
4501 mandeep.dh 4084 
    oprot.writeStructBegin('scan_args')
5361 mandeep.dh 4085 
    if self.inventoryItem is not None:
4086 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
4087 
      self.inventoryItem.write(oprot)
2821 chandransh 4088 
      oprot.writeFieldEnd()
3431 rajveer 4089 
    if self.type is not None:
4501 mandeep.dh 4090 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 4091 
      oprot.writeI32(self.type)
4092 
      oprot.writeFieldEnd()
4501 mandeep.dh 4093 
    if self.quantity is not None:
4094 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
4095 
      oprot.writeI64(self.quantity)
4096 
      oprot.writeFieldEnd()
5361 mandeep.dh 4097 
    if self.billingWarehouseId is not None:
4098 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
4099 
      oprot.writeI64(self.billingWarehouseId)
4501 mandeep.dh 4100 
      oprot.writeFieldEnd()
7410 amar.kumar 4101 
    if self.transferLotId is not None:
4102 
      oprot.writeFieldBegin('transferLotId', TType.I64, 5)
4103 
      oprot.writeI64(self.transferLotId)
4104 
      oprot.writeFieldEnd()
2821 chandransh 4105 
    oprot.writeFieldStop()
4106 
    oprot.writeStructEnd()
4107 
 
3431 rajveer 4108 
  def validate(self):
4109 
    return
4110 
 
4111 
 
2821 chandransh 4112 
  def __repr__(self):
4113 
    L = ['%s=%r' % (key, value)
4114 
      for key, value in self.__dict__.iteritems()]
4115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4116 
 
4117 
  def __eq__(self, other):
4118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4119 
 
4120 
  def __ne__(self, other):
4121 
    return not (self == other)
4122 
 
4501 mandeep.dh 4123 
class scan_result:
2821 chandransh 4124 
  """
4125 
  Attributes:
4126 
   - wex
4127 
  """
4128 
 
4129 
  thrift_spec = (
4130 
    None, # 0
4131 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4132 
  )
4133 
 
4134 
  def __init__(self, wex=None,):
4135 
    self.wex = wex
4136 
 
4137 
  def read(self, iprot):
4138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4140 
      return
4141 
    iprot.readStructBegin()
4142 
    while True:
4143 
      (fname, ftype, fid) = iprot.readFieldBegin()
4144 
      if ftype == TType.STOP:
4145 
        break
4146 
      if fid == 1:
4147 
        if ftype == TType.STRUCT:
4148 
          self.wex = WarehouseServiceException()
4149 
          self.wex.read(iprot)
4150 
        else:
4151 
          iprot.skip(ftype)
4152 
      else:
4153 
        iprot.skip(ftype)
4154 
      iprot.readFieldEnd()
4155 
    iprot.readStructEnd()
4156 
 
4157 
  def write(self, oprot):
4158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4160 
      return
4501 mandeep.dh 4161 
    oprot.writeStructBegin('scan_result')
3431 rajveer 4162 
    if self.wex is not None:
2821 chandransh 4163 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
4164 
      self.wex.write(oprot)
4165 
      oprot.writeFieldEnd()
4166 
    oprot.writeFieldStop()
4167 
    oprot.writeStructEnd()
4168 
 
3431 rajveer 4169 
  def validate(self):
4170 
    return
4171 
 
4172 
 
2821 chandransh 4173 
  def __repr__(self):
4174 
    L = ['%s=%r' % (key, value)
4175 
      for key, value in self.__dict__.iteritems()]
4176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4177 
 
4178 
  def __eq__(self, other):
4179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4180 
 
4181 
  def __ne__(self, other):
4182 
    return not (self == other)
4183 
 
10489 amar.kumar 4184 
class genericScan_args:
4185 
  """
4186 
  Attributes:
4187 
   - inventoryItem
4188 
   - scan
4189 
  """
4190 
 
4191 
  thrift_spec = (
4192 
    None, # 0
4193 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4194 
    (2, TType.STRUCT, 'scan', (Scan, Scan.thrift_spec), None, ), # 2
4195 
  )
4196 
 
4197 
  def __init__(self, inventoryItem=None, scan=None,):
4198 
    self.inventoryItem = inventoryItem
4199 
    self.scan = scan
4200 
 
4201 
  def read(self, iprot):
4202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4204 
      return
4205 
    iprot.readStructBegin()
4206 
    while True:
4207 
      (fname, ftype, fid) = iprot.readFieldBegin()
4208 
      if ftype == TType.STOP:
4209 
        break
4210 
      if fid == 1:
4211 
        if ftype == TType.STRUCT:
4212 
          self.inventoryItem = InventoryItem()
4213 
          self.inventoryItem.read(iprot)
4214 
        else:
4215 
          iprot.skip(ftype)
4216 
      elif fid == 2:
4217 
        if ftype == TType.STRUCT:
4218 
          self.scan = Scan()
4219 
          self.scan.read(iprot)
4220 
        else:
4221 
          iprot.skip(ftype)
4222 
      else:
4223 
        iprot.skip(ftype)
4224 
      iprot.readFieldEnd()
4225 
    iprot.readStructEnd()
4226 
 
4227 
  def write(self, oprot):
4228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4230 
      return
4231 
    oprot.writeStructBegin('genericScan_args')
4232 
    if self.inventoryItem is not None:
4233 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
4234 
      self.inventoryItem.write(oprot)
4235 
      oprot.writeFieldEnd()
4236 
    if self.scan is not None:
4237 
      oprot.writeFieldBegin('scan', TType.STRUCT, 2)
4238 
      self.scan.write(oprot)
4239 
      oprot.writeFieldEnd()
4240 
    oprot.writeFieldStop()
4241 
    oprot.writeStructEnd()
4242 
 
4243 
  def validate(self):
4244 
    return
4245 
 
4246 
 
4247 
  def __repr__(self):
4248 
    L = ['%s=%r' % (key, value)
4249 
      for key, value in self.__dict__.iteritems()]
4250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4251 
 
4252 
  def __eq__(self, other):
4253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4254 
 
4255 
  def __ne__(self, other):
4256 
    return not (self == other)
4257 
 
4258 
class genericScan_result:
4259 
  """
4260 
  Attributes:
4261 
   - wex
4262 
  """
4263 
 
4264 
  thrift_spec = (
4265 
    None, # 0
4266 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4267 
  )
4268 
 
4269 
  def __init__(self, wex=None,):
4270 
    self.wex = wex
4271 
 
4272 
  def read(self, iprot):
4273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4275 
      return
4276 
    iprot.readStructBegin()
4277 
    while True:
4278 
      (fname, ftype, fid) = iprot.readFieldBegin()
4279 
      if ftype == TType.STOP:
4280 
        break
4281 
      if fid == 1:
4282 
        if ftype == TType.STRUCT:
4283 
          self.wex = WarehouseServiceException()
4284 
          self.wex.read(iprot)
4285 
        else:
4286 
          iprot.skip(ftype)
4287 
      else:
4288 
        iprot.skip(ftype)
4289 
      iprot.readFieldEnd()
4290 
    iprot.readStructEnd()
4291 
 
4292 
  def write(self, oprot):
4293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4295 
      return
4296 
    oprot.writeStructBegin('genericScan_result')
4297 
    if self.wex is not None:
4298 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
4299 
      self.wex.write(oprot)
4300 
      oprot.writeFieldEnd()
4301 
    oprot.writeFieldStop()
4302 
    oprot.writeStructEnd()
4303 
 
4304 
  def validate(self):
4305 
    return
4306 
 
4307 
 
4308 
  def __repr__(self):
4309 
    L = ['%s=%r' % (key, value)
4310 
      for key, value in self.__dict__.iteritems()]
4311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4312 
 
4313 
  def __eq__(self, other):
4314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4315 
 
4316 
  def __ne__(self, other):
4317 
    return not (self == other)
4318 
 
4501 mandeep.dh 4319 
class scanSerializedItemForOrder_args:
2821 chandransh 4320 
  """
4321 
  Attributes:
4555 mandeep.dh 4322 
   - serialNumber
2821 chandransh 4323 
   - type
4501 mandeep.dh 4324 
   - orderId
5110 mandeep.dh 4325 
   - fulfilmentWarehouseId
4326 
   - quantity
4327 
   - billingWarehouseId
2821 chandransh 4328 
  """
4329 
 
4330 
  thrift_spec = (
4331 
    None, # 0
4555 mandeep.dh 4332 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
4501 mandeep.dh 4333 
    (2, TType.I32, 'type', None, None, ), # 2
4334 
    (3, TType.I64, 'orderId', None, None, ), # 3
5110 mandeep.dh 4335 
    (4, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 4
4336 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
4337 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
2821 chandransh 4338 
  )
4339 
 
5110 mandeep.dh 4340 
  def __init__(self, serialNumber=None, type=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
4555 mandeep.dh 4341 
    self.serialNumber = serialNumber
2821 chandransh 4342 
    self.type = type
4501 mandeep.dh 4343 
    self.orderId = orderId
5110 mandeep.dh 4344 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4345 
    self.quantity = quantity
4346 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 4347 
 
4348 
  def read(self, iprot):
4349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4351 
      return
4352 
    iprot.readStructBegin()
4353 
    while True:
4354 
      (fname, ftype, fid) = iprot.readFieldBegin()
4355 
      if ftype == TType.STOP:
4356 
        break
4357 
      if fid == 1:
4555 mandeep.dh 4358 
        if ftype == TType.STRING:
4359 
          self.serialNumber = iprot.readString();
2821 chandransh 4360 
        else:
4361 
          iprot.skip(ftype)
4362 
      elif fid == 2:
4501 mandeep.dh 4363 
        if ftype == TType.I32:
4364 
          self.type = iprot.readI32();
2821 chandransh 4365 
        else:
4366 
          iprot.skip(ftype)
4367 
      elif fid == 3:
4501 mandeep.dh 4368 
        if ftype == TType.I64:
4369 
          self.orderId = iprot.readI64();
4370 
        else:
4371 
          iprot.skip(ftype)
4372 
      elif fid == 4:
4373 
        if ftype == TType.I64:
5110 mandeep.dh 4374 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 4375 
        else:
4376 
          iprot.skip(ftype)
5110 mandeep.dh 4377 
      elif fid == 5:
4378 
        if ftype == TType.DOUBLE:
4379 
          self.quantity = iprot.readDouble();
4380 
        else:
4381 
          iprot.skip(ftype)
4382 
      elif fid == 6:
4383 
        if ftype == TType.I64:
4384 
          self.billingWarehouseId = iprot.readI64();
4385 
        else:
4386 
          iprot.skip(ftype)
4501 mandeep.dh 4387 
      else:
4388 
        iprot.skip(ftype)
4389 
      iprot.readFieldEnd()
4390 
    iprot.readStructEnd()
4391 
 
4392 
  def write(self, oprot):
4393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4395 
      return
4396 
    oprot.writeStructBegin('scanSerializedItemForOrder_args')
4555 mandeep.dh 4397 
    if self.serialNumber is not None:
4398 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
4399 
      oprot.writeString(self.serialNumber)
4501 mandeep.dh 4400 
      oprot.writeFieldEnd()
4401 
    if self.type is not None:
4402 
      oprot.writeFieldBegin('type', TType.I32, 2)
4403 
      oprot.writeI32(self.type)
4404 
      oprot.writeFieldEnd()
4405 
    if self.orderId is not None:
4406 
      oprot.writeFieldBegin('orderId', TType.I64, 3)
4407 
      oprot.writeI64(self.orderId)
4408 
      oprot.writeFieldEnd()
5110 mandeep.dh 4409 
    if self.fulfilmentWarehouseId is not None:
4410 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 4)
4411 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 4412 
      oprot.writeFieldEnd()
5110 mandeep.dh 4413 
    if self.quantity is not None:
4414 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
4415 
      oprot.writeDouble(self.quantity)
4416 
      oprot.writeFieldEnd()
4417 
    if self.billingWarehouseId is not None:
4418 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
4419 
      oprot.writeI64(self.billingWarehouseId)
4420 
      oprot.writeFieldEnd()
4501 mandeep.dh 4421 
    oprot.writeFieldStop()
4422 
    oprot.writeStructEnd()
4423 
 
4424 
  def validate(self):
4425 
    return
4426 
 
4427 
 
4428 
  def __repr__(self):
4429 
    L = ['%s=%r' % (key, value)
4430 
      for key, value in self.__dict__.iteritems()]
4431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4432 
 
4433 
  def __eq__(self, other):
4434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4435 
 
4436 
  def __ne__(self, other):
4437 
    return not (self == other)
4438 
 
4439 
class scanSerializedItemForOrder_result:
4440 
  """
4441 
  Attributes:
4442 
   - success
4443 
   - wex
4444 
  """
4445 
 
4446 
  thrift_spec = (
4555 mandeep.dh 4447 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4501 mandeep.dh 4448 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4449 
  )
4450 
 
4451 
  def __init__(self, success=None, wex=None,):
4452 
    self.success = success
4453 
    self.wex = wex
4454 
 
4455 
  def read(self, iprot):
4456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4458 
      return
4459 
    iprot.readStructBegin()
4460 
    while True:
4461 
      (fname, ftype, fid) = iprot.readFieldBegin()
4462 
      if ftype == TType.STOP:
4463 
        break
4464 
      if fid == 0:
4555 mandeep.dh 4465 
        if ftype == TType.STRUCT:
4466 
          self.success = InventoryItem()
4467 
          self.success.read(iprot)
4501 mandeep.dh 4468 
        else:
4469 
          iprot.skip(ftype)
4470 
      elif fid == 1:
4471 
        if ftype == TType.STRUCT:
4472 
          self.wex = WarehouseServiceException()
4473 
          self.wex.read(iprot)
4474 
        else:
4475 
          iprot.skip(ftype)
4476 
      else:
4477 
        iprot.skip(ftype)
4478 
      iprot.readFieldEnd()
4479 
    iprot.readStructEnd()
4480 
 
4481 
  def write(self, oprot):
4482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4484 
      return
4485 
    oprot.writeStructBegin('scanSerializedItemForOrder_result')
4486 
    if self.success is not None:
4555 mandeep.dh 4487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4488 
      self.success.write(oprot)
4501 mandeep.dh 4489 
      oprot.writeFieldEnd()
4490 
    if self.wex is not None:
4491 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
4492 
      self.wex.write(oprot)
4493 
      oprot.writeFieldEnd()
4494 
    oprot.writeFieldStop()
4495 
    oprot.writeStructEnd()
4496 
 
4497 
  def validate(self):
4498 
    return
4499 
 
4500 
 
4501 
  def __repr__(self):
4502 
    L = ['%s=%r' % (key, value)
4503 
      for key, value in self.__dict__.iteritems()]
4504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4505 
 
4506 
  def __eq__(self, other):
4507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4508 
 
4509 
  def __ne__(self, other):
4510 
    return not (self == other)
4511 
 
4512 
class scanForOrder_args:
4513 
  """
4514 
  Attributes:
5361 mandeep.dh 4515 
   - inventoryItem
4501 mandeep.dh 4516 
   - type
4517 
   - quantity
4518 
   - orderId
5110 mandeep.dh 4519 
   - fulfilmentWarehouseId
5361 mandeep.dh 4520 
   - billingWarehouseId
4501 mandeep.dh 4521 
  """
4522 
 
4523 
  thrift_spec = (
4524 
    None, # 0
5361 mandeep.dh 4525 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 4526 
    (2, TType.I32, 'type', None, None, ), # 2
4527 
    (3, TType.I64, 'quantity', None, None, ), # 3
4528 
    (4, TType.I64, 'orderId', None, None, ), # 4
5110 mandeep.dh 4529 
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
5361 mandeep.dh 4530 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
4501 mandeep.dh 4531 
  )
4532 
 
5361 mandeep.dh 4533 
  def __init__(self, inventoryItem=None, type=None, quantity=None, orderId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
4534 
    self.inventoryItem = inventoryItem
4501 mandeep.dh 4535 
    self.type = type
4536 
    self.quantity = quantity
4537 
    self.orderId = orderId
5110 mandeep.dh 4538 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 4539 
    self.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 4540 
 
4541 
  def read(self, iprot):
4542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4544 
      return
4545 
    iprot.readStructBegin()
4546 
    while True:
4547 
      (fname, ftype, fid) = iprot.readFieldBegin()
4548 
      if ftype == TType.STOP:
4549 
        break
4550 
      if fid == 1:
5361 mandeep.dh 4551 
        if ftype == TType.STRUCT:
4552 
          self.inventoryItem = InventoryItem()
4553 
          self.inventoryItem.read(iprot)
4501 mandeep.dh 4554 
        else:
4555 
          iprot.skip(ftype)
4556 
      elif fid == 2:
2821 chandransh 4557 
        if ftype == TType.I32:
4558 
          self.type = iprot.readI32();
4559 
        else:
4560 
          iprot.skip(ftype)
4501 mandeep.dh 4561 
      elif fid == 3:
4562 
        if ftype == TType.I64:
4563 
          self.quantity = iprot.readI64();
4564 
        else:
4565 
          iprot.skip(ftype)
4566 
      elif fid == 4:
4567 
        if ftype == TType.I64:
4568 
          self.orderId = iprot.readI64();
4569 
        else:
4570 
          iprot.skip(ftype)
4571 
      elif fid == 5:
4572 
        if ftype == TType.I64:
5110 mandeep.dh 4573 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 4574 
        else:
4575 
          iprot.skip(ftype)
5361 mandeep.dh 4576 
      elif fid == 6:
4577 
        if ftype == TType.I64:
4578 
          self.billingWarehouseId = iprot.readI64();
4579 
        else:
4580 
          iprot.skip(ftype)
2821 chandransh 4581 
      else:
4582 
        iprot.skip(ftype)
4583 
      iprot.readFieldEnd()
4584 
    iprot.readStructEnd()
4585 
 
4586 
  def write(self, oprot):
4587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4589 
      return
4501 mandeep.dh 4590 
    oprot.writeStructBegin('scanForOrder_args')
5361 mandeep.dh 4591 
    if self.inventoryItem is not None:
4592 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
4593 
      self.inventoryItem.write(oprot)
2821 chandransh 4594 
      oprot.writeFieldEnd()
3431 rajveer 4595 
    if self.type is not None:
4501 mandeep.dh 4596 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 4597 
      oprot.writeI32(self.type)
4598 
      oprot.writeFieldEnd()
4501 mandeep.dh 4599 
    if self.quantity is not None:
4600 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
4601 
      oprot.writeI64(self.quantity)
4602 
      oprot.writeFieldEnd()
4603 
    if self.orderId is not None:
4604 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
4605 
      oprot.writeI64(self.orderId)
4606 
      oprot.writeFieldEnd()
5110 mandeep.dh 4607 
    if self.fulfilmentWarehouseId is not None:
4608 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
4609 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 4610 
      oprot.writeFieldEnd()
5361 mandeep.dh 4611 
    if self.billingWarehouseId is not None:
4612 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
4613 
      oprot.writeI64(self.billingWarehouseId)
4614 
      oprot.writeFieldEnd()
2821 chandransh 4615 
    oprot.writeFieldStop()
4616 
    oprot.writeStructEnd()
4617 
 
3431 rajveer 4618 
  def validate(self):
4619 
    return
4620 
 
4621 
 
2821 chandransh 4622 
  def __repr__(self):
4623 
    L = ['%s=%r' % (key, value)
4624 
      for key, value in self.__dict__.iteritems()]
4625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4626 
 
4627 
  def __eq__(self, other):
4628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4629 
 
4630 
  def __ne__(self, other):
4631 
    return not (self == other)
4632 
 
4501 mandeep.dh 4633 
class scanForOrder_result:
2821 chandransh 4634 
  """
4635 
  Attributes:
5361 mandeep.dh 4636 
   - success
2821 chandransh 4637 
   - wex
4638 
  """
4639 
 
4640 
  thrift_spec = (
5361 mandeep.dh 4641 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2821 chandransh 4642 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4643 
  )
4644 
 
5361 mandeep.dh 4645 
  def __init__(self, success=None, wex=None,):
4646 
    self.success = success
2821 chandransh 4647 
    self.wex = wex
4648 
 
4649 
  def read(self, iprot):
4650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4652 
      return
4653 
    iprot.readStructBegin()
4654 
    while True:
4655 
      (fname, ftype, fid) = iprot.readFieldBegin()
4656 
      if ftype == TType.STOP:
4657 
        break
5361 mandeep.dh 4658 
      if fid == 0:
2821 chandransh 4659 
        if ftype == TType.STRUCT:
5361 mandeep.dh 4660 
          self.success = InventoryItem()
4661 
          self.success.read(iprot)
4662 
        else:
4663 
          iprot.skip(ftype)
4664 
      elif fid == 1:
4665 
        if ftype == TType.STRUCT:
2821 chandransh 4666 
          self.wex = WarehouseServiceException()
4667 
          self.wex.read(iprot)
4668 
        else:
4669 
          iprot.skip(ftype)
4670 
      else:
4671 
        iprot.skip(ftype)
4672 
      iprot.readFieldEnd()
4673 
    iprot.readStructEnd()
4674 
 
4675 
  def write(self, oprot):
4676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4678 
      return
4501 mandeep.dh 4679 
    oprot.writeStructBegin('scanForOrder_result')
5361 mandeep.dh 4680 
    if self.success is not None:
4681 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4682 
      self.success.write(oprot)
4683 
      oprot.writeFieldEnd()
3431 rajveer 4684 
    if self.wex is not None:
2821 chandransh 4685 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
4686 
      self.wex.write(oprot)
4687 
      oprot.writeFieldEnd()
4688 
    oprot.writeFieldStop()
4689 
    oprot.writeStructEnd()
4690 
 
3431 rajveer 4691 
  def validate(self):
4692 
    return
4693 
 
4694 
 
2821 chandransh 4695 
  def __repr__(self):
4696 
    L = ['%s=%r' % (key, value)
4697 
      for key, value in self.__dict__.iteritems()]
4698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4699 
 
4700 
  def __eq__(self, other):
4701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4702 
 
4703 
  def __ne__(self, other):
4704 
    return not (self == other)
4501 mandeep.dh 4705 
 
4706 
class createItemNumberMapping_args:
4707 
  """
4708 
  Attributes:
4709 
   - itemNumber
4710 
   - itemId
4711 
  """
4712 
 
4713 
  thrift_spec = (
4714 
    None, # 0
4715 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
4716 
    (2, TType.I64, 'itemId', None, None, ), # 2
4717 
  )
4718 
 
4719 
  def __init__(self, itemNumber=None, itemId=None,):
4720 
    self.itemNumber = itemNumber
4721 
    self.itemId = itemId
4722 
 
4723 
  def read(self, iprot):
4724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4726 
      return
4727 
    iprot.readStructBegin()
4728 
    while True:
4729 
      (fname, ftype, fid) = iprot.readFieldBegin()
4730 
      if ftype == TType.STOP:
4731 
        break
4732 
      if fid == 1:
4733 
        if ftype == TType.STRING:
4734 
          self.itemNumber = iprot.readString();
4735 
        else:
4736 
          iprot.skip(ftype)
4737 
      elif fid == 2:
4738 
        if ftype == TType.I64:
4739 
          self.itemId = iprot.readI64();
4740 
        else:
4741 
          iprot.skip(ftype)
4742 
      else:
4743 
        iprot.skip(ftype)
4744 
      iprot.readFieldEnd()
4745 
    iprot.readStructEnd()
4746 
 
4747 
  def write(self, oprot):
4748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4750 
      return
4751 
    oprot.writeStructBegin('createItemNumberMapping_args')
4752 
    if self.itemNumber is not None:
4753 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
4754 
      oprot.writeString(self.itemNumber)
4755 
      oprot.writeFieldEnd()
4756 
    if self.itemId is not None:
4757 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
4758 
      oprot.writeI64(self.itemId)
4759 
      oprot.writeFieldEnd()
4760 
    oprot.writeFieldStop()
4761 
    oprot.writeStructEnd()
4762 
 
4763 
  def validate(self):
4764 
    return
4765 
 
4766 
 
4767 
  def __repr__(self):
4768 
    L = ['%s=%r' % (key, value)
4769 
      for key, value in self.__dict__.iteritems()]
4770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4771 
 
4772 
  def __eq__(self, other):
4773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4774 
 
4775 
  def __ne__(self, other):
4776 
    return not (self == other)
4777 
 
4778 
class createItemNumberMapping_result:
4779 
 
4780 
  thrift_spec = (
4781 
  )
4782 
 
4783 
  def read(self, iprot):
4784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4786 
      return
4787 
    iprot.readStructBegin()
4788 
    while True:
4789 
      (fname, ftype, fid) = iprot.readFieldBegin()
4790 
      if ftype == TType.STOP:
4791 
        break
4792 
      else:
4793 
        iprot.skip(ftype)
4794 
      iprot.readFieldEnd()
4795 
    iprot.readStructEnd()
4796 
 
4797 
  def write(self, oprot):
4798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4800 
      return
4801 
    oprot.writeStructBegin('createItemNumberMapping_result')
4802 
    oprot.writeFieldStop()
4803 
    oprot.writeStructEnd()
4804 
 
4805 
  def validate(self):
4806 
    return
4807 
 
4808 
 
4809 
  def __repr__(self):
4810 
    L = ['%s=%r' % (key, value)
4811 
      for key, value in self.__dict__.iteritems()]
4812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4813 
 
4814 
  def __eq__(self, other):
4815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4816 
 
4817 
  def __ne__(self, other):
4818 
    return not (self == other)
4620 amit.gupta 4819 
 
4820 
class getItemNumbers_args:
4821 
  """
4822 
  Attributes:
4823 
   - itemId
4824 
  """
4825 
 
4826 
  thrift_spec = (
4827 
    None, # 0
4828 
    (1, TType.I64, 'itemId', None, None, ), # 1
4829 
  )
4830 
 
4831 
  def __init__(self, itemId=None,):
4832 
    self.itemId = itemId
4833 
 
4834 
  def read(self, iprot):
4835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4837 
      return
4838 
    iprot.readStructBegin()
4839 
    while True:
4840 
      (fname, ftype, fid) = iprot.readFieldBegin()
4841 
      if ftype == TType.STOP:
4842 
        break
4843 
      if fid == 1:
4844 
        if ftype == TType.I64:
4845 
          self.itemId = iprot.readI64();
4846 
        else:
4847 
          iprot.skip(ftype)
4848 
      else:
4849 
        iprot.skip(ftype)
4850 
      iprot.readFieldEnd()
4851 
    iprot.readStructEnd()
4852 
 
4853 
  def write(self, oprot):
4854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4856 
      return
4857 
    oprot.writeStructBegin('getItemNumbers_args')
4858 
    if self.itemId is not None:
4859 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
4860 
      oprot.writeI64(self.itemId)
4861 
      oprot.writeFieldEnd()
4862 
    oprot.writeFieldStop()
4863 
    oprot.writeStructEnd()
4864 
 
4865 
  def validate(self):
4866 
    return
4867 
 
4868 
 
4869 
  def __repr__(self):
4870 
    L = ['%s=%r' % (key, value)
4871 
      for key, value in self.__dict__.iteritems()]
4872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4873 
 
4874 
  def __eq__(self, other):
4875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4876 
 
4877 
  def __ne__(self, other):
4878 
    return not (self == other)
4879 
 
4880 
class getItemNumbers_result:
4881 
  """
4882 
  Attributes:
4883 
   - success
4884 
  """
4885 
 
4886 
  thrift_spec = (
4887 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
4888 
  )
4889 
 
4890 
  def __init__(self, success=None,):
4891 
    self.success = success
4892 
 
4893 
  def read(self, iprot):
4894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4896 
      return
4897 
    iprot.readStructBegin()
4898 
    while True:
4899 
      (fname, ftype, fid) = iprot.readFieldBegin()
4900 
      if ftype == TType.STOP:
4901 
        break
4902 
      if fid == 0:
4903 
        if ftype == TType.LIST:
4904 
          self.success = []
5361 mandeep.dh 4905 
          (_etype3, _size0) = iprot.readListBegin()
4906 
          for _i4 in xrange(_size0):
4907 
            _elem5 = iprot.readString();
4908 
            self.success.append(_elem5)
4620 amit.gupta 4909 
          iprot.readListEnd()
4910 
        else:
4911 
          iprot.skip(ftype)
4912 
      else:
4913 
        iprot.skip(ftype)
4914 
      iprot.readFieldEnd()
4915 
    iprot.readStructEnd()
4916 
 
4917 
  def write(self, oprot):
4918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4920 
      return
4921 
    oprot.writeStructBegin('getItemNumbers_result')
4922 
    if self.success is not None:
4923 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4924 
      oprot.writeListBegin(TType.STRING, len(self.success))
5361 mandeep.dh 4925 
      for iter6 in self.success:
4926 
        oprot.writeString(iter6)
4620 amit.gupta 4927 
      oprot.writeListEnd()
4928 
      oprot.writeFieldEnd()
4929 
    oprot.writeFieldStop()
4930 
    oprot.writeStructEnd()
4931 
 
4932 
  def validate(self):
4933 
    return
4934 
 
4935 
 
4936 
  def __repr__(self):
4937 
    L = ['%s=%r' % (key, value)
4938 
      for key, value in self.__dict__.iteritems()]
4939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4940 
 
4941 
  def __eq__(self, other):
4942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4943 
 
4944 
  def __ne__(self, other):
4945 
    return not (self == other)
5110 mandeep.dh 4946 
 
4947 
class getItemIds_args:
4948 
  """
4949 
  Attributes:
4950 
   - itemNumber
4951 
  """
4952 
 
4953 
  thrift_spec = (
4954 
    None, # 0
4955 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
4956 
  )
4957 
 
4958 
  def __init__(self, itemNumber=None,):
4959 
    self.itemNumber = itemNumber
4960 
 
4961 
  def read(self, iprot):
4962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4964 
      return
4965 
    iprot.readStructBegin()
4966 
    while True:
4967 
      (fname, ftype, fid) = iprot.readFieldBegin()
4968 
      if ftype == TType.STOP:
4969 
        break
4970 
      if fid == 1:
4971 
        if ftype == TType.STRING:
4972 
          self.itemNumber = iprot.readString();
4973 
        else:
4974 
          iprot.skip(ftype)
4975 
      else:
4976 
        iprot.skip(ftype)
4977 
      iprot.readFieldEnd()
4978 
    iprot.readStructEnd()
4979 
 
4980 
  def write(self, oprot):
4981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4983 
      return
4984 
    oprot.writeStructBegin('getItemIds_args')
4985 
    if self.itemNumber is not None:
4986 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
4987 
      oprot.writeString(self.itemNumber)
4988 
      oprot.writeFieldEnd()
4989 
    oprot.writeFieldStop()
4990 
    oprot.writeStructEnd()
4991 
 
4992 
  def validate(self):
4993 
    return
4994 
 
4995 
 
4996 
  def __repr__(self):
4997 
    L = ['%s=%r' % (key, value)
4998 
      for key, value in self.__dict__.iteritems()]
4999 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5000 
 
5001 
  def __eq__(self, other):
5002 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5003 
 
5004 
  def __ne__(self, other):
5005 
    return not (self == other)
5006 
 
5007 
class getItemIds_result:
5008 
  """
5009 
  Attributes:
5010 
   - success
5011 
  """
5012 
 
5013 
  thrift_spec = (
5014 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5015 
  )
5016 
 
5017 
  def __init__(self, success=None,):
5018 
    self.success = success
5019 
 
5020 
  def read(self, iprot):
5021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5023 
      return
5024 
    iprot.readStructBegin()
5025 
    while True:
5026 
      (fname, ftype, fid) = iprot.readFieldBegin()
5027 
      if ftype == TType.STOP:
5028 
        break
5029 
      if fid == 0:
5030 
        if ftype == TType.LIST:
5031 
          self.success = []
5361 mandeep.dh 5032 
          (_etype10, _size7) = iprot.readListBegin()
5033 
          for _i11 in xrange(_size7):
5034 
            _elem12 = iprot.readI64();
5035 
            self.success.append(_elem12)
5110 mandeep.dh 5036 
          iprot.readListEnd()
5037 
        else:
5038 
          iprot.skip(ftype)
5039 
      else:
5040 
        iprot.skip(ftype)
5041 
      iprot.readFieldEnd()
5042 
    iprot.readStructEnd()
5043 
 
5044 
  def write(self, oprot):
5045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5047 
      return
5048 
    oprot.writeStructBegin('getItemIds_result')
5049 
    if self.success is not None:
5050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5051 
      oprot.writeListBegin(TType.I64, len(self.success))
5361 mandeep.dh 5052 
      for iter13 in self.success:
5053 
        oprot.writeI64(iter13)
5110 mandeep.dh 5054 
      oprot.writeListEnd()
5055 
      oprot.writeFieldEnd()
5056 
    oprot.writeFieldStop()
5057 
    oprot.writeStructEnd()
5058 
 
5059 
  def validate(self):
5060 
    return
5061 
 
5062 
 
5063 
  def __repr__(self):
5064 
    L = ['%s=%r' % (key, value)
5065 
      for key, value in self.__dict__.iteritems()]
5066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5067 
 
5068 
  def __eq__(self, other):
5069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5070 
 
5071 
  def __ne__(self, other):
5072 
    return not (self == other)
5185 mandeep.dh 5073 
 
5074 
class getInventoryItemsFromLastScanType_args:
5075 
  """
5076 
  Attributes:
5077 
   - lastScanType
5078 
  """
5079 
 
5080 
  thrift_spec = (
5081 
    None, # 0
5082 
    (1, TType.I32, 'lastScanType', None, None, ), # 1
5083 
  )
5084 
 
5085 
  def __init__(self, lastScanType=None,):
5086 
    self.lastScanType = lastScanType
5087 
 
5088 
  def read(self, iprot):
5089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5091 
      return
5092 
    iprot.readStructBegin()
5093 
    while True:
5094 
      (fname, ftype, fid) = iprot.readFieldBegin()
5095 
      if ftype == TType.STOP:
5096 
        break
5097 
      if fid == 1:
5098 
        if ftype == TType.I32:
5099 
          self.lastScanType = iprot.readI32();
5100 
        else:
5101 
          iprot.skip(ftype)
5102 
      else:
5103 
        iprot.skip(ftype)
5104 
      iprot.readFieldEnd()
5105 
    iprot.readStructEnd()
5106 
 
5107 
  def write(self, oprot):
5108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5110 
      return
5111 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_args')
5112 
    if self.lastScanType is not None:
5113 
      oprot.writeFieldBegin('lastScanType', TType.I32, 1)
5114 
      oprot.writeI32(self.lastScanType)
5115 
      oprot.writeFieldEnd()
5116 
    oprot.writeFieldStop()
5117 
    oprot.writeStructEnd()
5118 
 
5119 
  def validate(self):
5120 
    return
5121 
 
5122 
 
5123 
  def __repr__(self):
5124 
    L = ['%s=%r' % (key, value)
5125 
      for key, value in self.__dict__.iteritems()]
5126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5127 
 
5128 
  def __eq__(self, other):
5129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5130 
 
5131 
  def __ne__(self, other):
5132 
    return not (self == other)
5133 
 
5134 
class getInventoryItemsFromLastScanType_result:
5135 
  """
5136 
  Attributes:
5137 
   - success
5138 
   - wex
5139 
  """
5140 
 
5141 
  thrift_spec = (
5142 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
5143 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5144 
  )
5145 
 
5146 
  def __init__(self, success=None, wex=None,):
5147 
    self.success = success
5148 
    self.wex = wex
5149 
 
5150 
  def read(self, iprot):
5151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5153 
      return
5154 
    iprot.readStructBegin()
5155 
    while True:
5156 
      (fname, ftype, fid) = iprot.readFieldBegin()
5157 
      if ftype == TType.STOP:
5158 
        break
5159 
      if fid == 0:
5160 
        if ftype == TType.LIST:
5161 
          self.success = []
5361 mandeep.dh 5162 
          (_etype17, _size14) = iprot.readListBegin()
5163 
          for _i18 in xrange(_size14):
5164 
            _elem19 = InventoryItem()
5165 
            _elem19.read(iprot)
5166 
            self.success.append(_elem19)
5185 mandeep.dh 5167 
          iprot.readListEnd()
5168 
        else:
5169 
          iprot.skip(ftype)
5170 
      elif fid == 1:
5171 
        if ftype == TType.STRUCT:
5172 
          self.wex = WarehouseServiceException()
5173 
          self.wex.read(iprot)
5174 
        else:
5175 
          iprot.skip(ftype)
5176 
      else:
5177 
        iprot.skip(ftype)
5178 
      iprot.readFieldEnd()
5179 
    iprot.readStructEnd()
5180 
 
5181 
  def write(self, oprot):
5182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5184 
      return
5185 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_result')
5186 
    if self.success is not None:
5187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5361 mandeep.dh 5189 
      for iter20 in self.success:
5190 
        iter20.write(oprot)
5185 mandeep.dh 5191 
      oprot.writeListEnd()
5192 
      oprot.writeFieldEnd()
5193 
    if self.wex is not None:
5194 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
5195 
      self.wex.write(oprot)
5196 
      oprot.writeFieldEnd()
5197 
    oprot.writeFieldStop()
5198 
    oprot.writeStructEnd()
5199 
 
5200 
  def validate(self):
5201 
    return
5202 
 
5203 
 
5204 
  def __repr__(self):
5205 
    L = ['%s=%r' % (key, value)
5206 
      for key, value in self.__dict__.iteritems()]
5207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5208 
 
5209 
  def __eq__(self, other):
5210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5211 
 
5212 
  def __ne__(self, other):
5213 
    return not (self == other)
5214 
 
5215 
class getInventoryItemFromId_args:
5216 
  """
5217 
  Attributes:
5218 
   - inventoryItemId
5219 
  """
5220 
 
5221 
  thrift_spec = (
5222 
    None, # 0
5223 
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
5224 
  )
5225 
 
5226 
  def __init__(self, inventoryItemId=None,):
5227 
    self.inventoryItemId = inventoryItemId
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 == 1:
5239 
        if ftype == TType.I64:
5240 
          self.inventoryItemId = iprot.readI64();
5241 
        else:
5242 
          iprot.skip(ftype)
5243 
      else:
5244 
        iprot.skip(ftype)
5245 
      iprot.readFieldEnd()
5246 
    iprot.readStructEnd()
5247 
 
5248 
  def write(self, oprot):
5249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5251 
      return
5252 
    oprot.writeStructBegin('getInventoryItemFromId_args')
5253 
    if self.inventoryItemId is not None:
5254 
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
5255 
      oprot.writeI64(self.inventoryItemId)
5256 
      oprot.writeFieldEnd()
5257 
    oprot.writeFieldStop()
5258 
    oprot.writeStructEnd()
5259 
 
5260 
  def validate(self):
5261 
    return
5262 
 
5263 
 
5264 
  def __repr__(self):
5265 
    L = ['%s=%r' % (key, value)
5266 
      for key, value in self.__dict__.iteritems()]
5267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5268 
 
5269 
  def __eq__(self, other):
5270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5271 
 
5272 
  def __ne__(self, other):
5273 
    return not (self == other)
5274 
 
5275 
class getInventoryItemFromId_result:
5276 
  """
5277 
  Attributes:
5278 
   - success
5279 
   - wex
5280 
  """
5281 
 
5282 
  thrift_spec = (
5283 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
5284 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5285 
  )
5286 
 
5287 
  def __init__(self, success=None, wex=None,):
5288 
    self.success = success
5289 
    self.wex = wex
5290 
 
5291 
  def read(self, iprot):
5292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5294 
      return
5295 
    iprot.readStructBegin()
5296 
    while True:
5297 
      (fname, ftype, fid) = iprot.readFieldBegin()
5298 
      if ftype == TType.STOP:
5299 
        break
5300 
      if fid == 0:
5301 
        if ftype == TType.STRUCT:
5302 
          self.success = InventoryItem()
5303 
          self.success.read(iprot)
5304 
        else:
5305 
          iprot.skip(ftype)
5306 
      elif fid == 1:
5307 
        if ftype == TType.STRUCT:
5308 
          self.wex = WarehouseServiceException()
5309 
          self.wex.read(iprot)
5310 
        else:
5311 
          iprot.skip(ftype)
5312 
      else:
5313 
        iprot.skip(ftype)
5314 
      iprot.readFieldEnd()
5315 
    iprot.readStructEnd()
5316 
 
5317 
  def write(self, oprot):
5318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5320 
      return
5321 
    oprot.writeStructBegin('getInventoryItemFromId_result')
5322 
    if self.success is not None:
5323 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5324 
      self.success.write(oprot)
5325 
      oprot.writeFieldEnd()
5326 
    if self.wex is not None:
5327 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
5328 
      self.wex.write(oprot)
5329 
      oprot.writeFieldEnd()
5330 
    oprot.writeFieldStop()
5331 
    oprot.writeStructEnd()
5332 
 
5333 
  def validate(self):
5334 
    return
5335 
 
5336 
 
5337 
  def __repr__(self):
5338 
    L = ['%s=%r' % (key, value)
5339 
      for key, value in self.__dict__.iteritems()]
5340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5341 
 
5342 
  def __eq__(self, other):
5343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5344 
 
5345 
  def __ne__(self, other):
5346 
    return not (self == other)
5372 mandeep.dh 5347 
 
5348 
class getPurchaseScans_args:
5349 
  """
5350 
  Attributes:
5351 
   - startDate
5352 
   - endDate
5353 
  """
5354 
 
5355 
  thrift_spec = (
5356 
    None, # 0
5357 
    (1, TType.I64, 'startDate', None, None, ), # 1
5358 
    (2, TType.I64, 'endDate', None, None, ), # 2
5359 
  )
5360 
 
5361 
  def __init__(self, startDate=None, endDate=None,):
5362 
    self.startDate = startDate
5363 
    self.endDate = endDate
5364 
 
5365 
  def read(self, iprot):
5366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5368 
      return
5369 
    iprot.readStructBegin()
5370 
    while True:
5371 
      (fname, ftype, fid) = iprot.readFieldBegin()
5372 
      if ftype == TType.STOP:
5373 
        break
5374 
      if fid == 1:
5375 
        if ftype == TType.I64:
5376 
          self.startDate = iprot.readI64();
5377 
        else:
5378 
          iprot.skip(ftype)
5379 
      elif fid == 2:
5380 
        if ftype == TType.I64:
5381 
          self.endDate = iprot.readI64();
5382 
        else:
5383 
          iprot.skip(ftype)
5384 
      else:
5385 
        iprot.skip(ftype)
5386 
      iprot.readFieldEnd()
5387 
    iprot.readStructEnd()
5388 
 
5389 
  def write(self, oprot):
5390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5392 
      return
5393 
    oprot.writeStructBegin('getPurchaseScans_args')
5394 
    if self.startDate is not None:
5395 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5396 
      oprot.writeI64(self.startDate)
5397 
      oprot.writeFieldEnd()
5398 
    if self.endDate is not None:
5399 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5400 
      oprot.writeI64(self.endDate)
5401 
      oprot.writeFieldEnd()
5402 
    oprot.writeFieldStop()
5403 
    oprot.writeStructEnd()
5404 
 
5405 
  def validate(self):
5406 
    return
5407 
 
5408 
 
5409 
  def __repr__(self):
5410 
    L = ['%s=%r' % (key, value)
5411 
      for key, value in self.__dict__.iteritems()]
5412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5413 
 
5414 
  def __eq__(self, other):
5415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5416 
 
5417 
  def __ne__(self, other):
5418 
    return not (self == other)
5419 
 
5420 
class getPurchaseScans_result:
5421 
  """
5422 
  Attributes:
5423 
   - success
5424 
  """
5425 
 
5426 
  thrift_spec = (
5427 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
5428 
  )
5429 
 
5430 
  def __init__(self, success=None,):
5431 
    self.success = success
5432 
 
5433 
  def read(self, iprot):
5434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5436 
      return
5437 
    iprot.readStructBegin()
5438 
    while True:
5439 
      (fname, ftype, fid) = iprot.readFieldBegin()
5440 
      if ftype == TType.STOP:
5441 
        break
5442 
      if fid == 0:
5443 
        if ftype == TType.LIST:
5444 
          self.success = []
5445 
          (_etype24, _size21) = iprot.readListBegin()
5446 
          for _i25 in xrange(_size21):
5447 
            _elem26 = DetailedPurchaseScan()
5448 
            _elem26.read(iprot)
5449 
            self.success.append(_elem26)
5450 
          iprot.readListEnd()
5451 
        else:
5452 
          iprot.skip(ftype)
5453 
      else:
5454 
        iprot.skip(ftype)
5455 
      iprot.readFieldEnd()
5456 
    iprot.readStructEnd()
5457 
 
5458 
  def write(self, oprot):
5459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5461 
      return
5462 
    oprot.writeStructBegin('getPurchaseScans_result')
5463 
    if self.success is not None:
5464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5466 
      for iter27 in self.success:
5467 
        iter27.write(oprot)
5468 
      oprot.writeListEnd()
5469 
      oprot.writeFieldEnd()
5470 
    oprot.writeFieldStop()
5471 
    oprot.writeStructEnd()
5472 
 
5473 
  def validate(self):
5474 
    return
5475 
 
5476 
 
5477 
  def __repr__(self):
5478 
    L = ['%s=%r' % (key, value)
5479 
      for key, value in self.__dict__.iteritems()]
5480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5481 
 
5482 
  def __eq__(self, other):
5483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5484 
 
5485 
  def __ne__(self, other):
5486 
    return not (self == other)
5496 mandeep.dh 5487 
 
7216 amar.kumar 5488 
class getPurchaseScansByGrnDate_args:
5489 
  """
5490 
  Attributes:
5491 
   - startDate
5492 
   - endDate
5493 
  """
5494 
 
5495 
  thrift_spec = (
5496 
    None, # 0
5497 
    (1, TType.I64, 'startDate', None, None, ), # 1
5498 
    (2, TType.I64, 'endDate', None, None, ), # 2
5499 
  )
5500 
 
5501 
  def __init__(self, startDate=None, endDate=None,):
5502 
    self.startDate = startDate
5503 
    self.endDate = endDate
5504 
 
5505 
  def read(self, iprot):
5506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5508 
      return
5509 
    iprot.readStructBegin()
5510 
    while True:
5511 
      (fname, ftype, fid) = iprot.readFieldBegin()
5512 
      if ftype == TType.STOP:
5513 
        break
5514 
      if fid == 1:
5515 
        if ftype == TType.I64:
5516 
          self.startDate = iprot.readI64();
5517 
        else:
5518 
          iprot.skip(ftype)
5519 
      elif fid == 2:
5520 
        if ftype == TType.I64:
5521 
          self.endDate = iprot.readI64();
5522 
        else:
5523 
          iprot.skip(ftype)
5524 
      else:
5525 
        iprot.skip(ftype)
5526 
      iprot.readFieldEnd()
5527 
    iprot.readStructEnd()
5528 
 
5529 
  def write(self, oprot):
5530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5532 
      return
5533 
    oprot.writeStructBegin('getPurchaseScansByGrnDate_args')
5534 
    if self.startDate is not None:
5535 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5536 
      oprot.writeI64(self.startDate)
5537 
      oprot.writeFieldEnd()
5538 
    if self.endDate is not None:
5539 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5540 
      oprot.writeI64(self.endDate)
5541 
      oprot.writeFieldEnd()
5542 
    oprot.writeFieldStop()
5543 
    oprot.writeStructEnd()
5544 
 
5545 
  def validate(self):
5546 
    return
5547 
 
5548 
 
5549 
  def __repr__(self):
5550 
    L = ['%s=%r' % (key, value)
5551 
      for key, value in self.__dict__.iteritems()]
5552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5553 
 
5554 
  def __eq__(self, other):
5555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5556 
 
5557 
  def __ne__(self, other):
5558 
    return not (self == other)
5559 
 
5560 
class getPurchaseScansByGrnDate_result:
5561 
  """
5562 
  Attributes:
5563 
   - success
5564 
  """
5565 
 
5566 
  thrift_spec = (
5567 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
5568 
  )
5569 
 
5570 
  def __init__(self, success=None,):
5571 
    self.success = success
5572 
 
5573 
  def read(self, iprot):
5574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5576 
      return
5577 
    iprot.readStructBegin()
5578 
    while True:
5579 
      (fname, ftype, fid) = iprot.readFieldBegin()
5580 
      if ftype == TType.STOP:
5581 
        break
5582 
      if fid == 0:
5583 
        if ftype == TType.LIST:
5584 
          self.success = []
5585 
          (_etype31, _size28) = iprot.readListBegin()
5586 
          for _i32 in xrange(_size28):
5587 
            _elem33 = DetailedPurchaseScan()
5588 
            _elem33.read(iprot)
5589 
            self.success.append(_elem33)
5590 
          iprot.readListEnd()
5591 
        else:
5592 
          iprot.skip(ftype)
5593 
      else:
5594 
        iprot.skip(ftype)
5595 
      iprot.readFieldEnd()
5596 
    iprot.readStructEnd()
5597 
 
5598 
  def write(self, oprot):
5599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5601 
      return
5602 
    oprot.writeStructBegin('getPurchaseScansByGrnDate_result')
5603 
    if self.success is not None:
5604 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5605 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5606 
      for iter34 in self.success:
5607 
        iter34.write(oprot)
5608 
      oprot.writeListEnd()
5609 
      oprot.writeFieldEnd()
5610 
    oprot.writeFieldStop()
5611 
    oprot.writeStructEnd()
5612 
 
5613 
  def validate(self):
5614 
    return
5615 
 
5616 
 
5617 
  def __repr__(self):
5618 
    L = ['%s=%r' % (key, value)
5619 
      for key, value in self.__dict__.iteritems()]
5620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5621 
 
5622 
  def __eq__(self, other):
5623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5624 
 
5625 
  def __ne__(self, other):
5626 
    return not (self == other)
5627 
 
10407 amar.kumar 5628 
class getEmptyGrnsByDate_args:
5629 
  """
5630 
  Attributes:
5631 
   - startDate
5632 
   - endDate
5633 
  """
5634 
 
5635 
  thrift_spec = (
5636 
    None, # 0
5637 
    (1, TType.I64, 'startDate', None, None, ), # 1
5638 
    (2, TType.I64, 'endDate', None, None, ), # 2
5639 
  )
5640 
 
5641 
  def __init__(self, startDate=None, endDate=None,):
5642 
    self.startDate = startDate
5643 
    self.endDate = endDate
5644 
 
5645 
  def read(self, iprot):
5646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5648 
      return
5649 
    iprot.readStructBegin()
5650 
    while True:
5651 
      (fname, ftype, fid) = iprot.readFieldBegin()
5652 
      if ftype == TType.STOP:
5653 
        break
5654 
      if fid == 1:
5655 
        if ftype == TType.I64:
5656 
          self.startDate = iprot.readI64();
5657 
        else:
5658 
          iprot.skip(ftype)
5659 
      elif fid == 2:
5660 
        if ftype == TType.I64:
5661 
          self.endDate = iprot.readI64();
5662 
        else:
5663 
          iprot.skip(ftype)
5664 
      else:
5665 
        iprot.skip(ftype)
5666 
      iprot.readFieldEnd()
5667 
    iprot.readStructEnd()
5668 
 
5669 
  def write(self, oprot):
5670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5672 
      return
5673 
    oprot.writeStructBegin('getEmptyGrnsByDate_args')
5674 
    if self.startDate is not None:
5675 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5676 
      oprot.writeI64(self.startDate)
5677 
      oprot.writeFieldEnd()
5678 
    if self.endDate is not None:
5679 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5680 
      oprot.writeI64(self.endDate)
5681 
      oprot.writeFieldEnd()
5682 
    oprot.writeFieldStop()
5683 
    oprot.writeStructEnd()
5684 
 
5685 
  def validate(self):
5686 
    return
5687 
 
5688 
 
5689 
  def __repr__(self):
5690 
    L = ['%s=%r' % (key, value)
5691 
      for key, value in self.__dict__.iteritems()]
5692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5693 
 
5694 
  def __eq__(self, other):
5695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5696 
 
5697 
  def __ne__(self, other):
5698 
    return not (self == other)
5699 
 
5700 
class getEmptyGrnsByDate_result:
5701 
  """
5702 
  Attributes:
5703 
   - success
5704 
  """
5705 
 
5706 
  thrift_spec = (
5707 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
5708 
  )
5709 
 
5710 
  def __init__(self, success=None,):
5711 
    self.success = success
5712 
 
5713 
  def read(self, iprot):
5714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5716 
      return
5717 
    iprot.readStructBegin()
5718 
    while True:
5719 
      (fname, ftype, fid) = iprot.readFieldBegin()
5720 
      if ftype == TType.STOP:
5721 
        break
5722 
      if fid == 0:
5723 
        if ftype == TType.LIST:
5724 
          self.success = []
5725 
          (_etype38, _size35) = iprot.readListBegin()
5726 
          for _i39 in xrange(_size35):
5727 
            _elem40 = iprot.readI64();
5728 
            self.success.append(_elem40)
5729 
          iprot.readListEnd()
5730 
        else:
5731 
          iprot.skip(ftype)
5732 
      else:
5733 
        iprot.skip(ftype)
5734 
      iprot.readFieldEnd()
5735 
    iprot.readStructEnd()
5736 
 
5737 
  def write(self, oprot):
5738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5740 
      return
5741 
    oprot.writeStructBegin('getEmptyGrnsByDate_result')
5742 
    if self.success is not None:
5743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5744 
      oprot.writeListBegin(TType.I64, len(self.success))
5745 
      for iter41 in self.success:
5746 
        oprot.writeI64(iter41)
5747 
      oprot.writeListEnd()
5748 
      oprot.writeFieldEnd()
5749 
    oprot.writeFieldStop()
5750 
    oprot.writeStructEnd()
5751 
 
5752 
  def validate(self):
5753 
    return
5754 
 
5755 
 
5756 
  def __repr__(self):
5757 
    L = ['%s=%r' % (key, value)
5758 
      for key, value in self.__dict__.iteritems()]
5759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5760 
 
5761 
  def __eq__(self, other):
5762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5763 
 
5764 
  def __ne__(self, other):
5765 
    return not (self == other)
5766 
 
5496 mandeep.dh 5767 
class fetchScansPerInvoiceNumber_args:
5768 
  """
5769 
  Attributes:
5770 
   - date
5771 
  """
5772 
 
5773 
  thrift_spec = (
5774 
    None, # 0
5775 
    (1, TType.I64, 'date', None, None, ), # 1
5776 
  )
5777 
 
5778 
  def __init__(self, date=None,):
5779 
    self.date = date
5780 
 
5781 
  def read(self, iprot):
5782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5784 
      return
5785 
    iprot.readStructBegin()
5786 
    while True:
5787 
      (fname, ftype, fid) = iprot.readFieldBegin()
5788 
      if ftype == TType.STOP:
5789 
        break
5790 
      if fid == 1:
5791 
        if ftype == TType.I64:
5792 
          self.date = iprot.readI64();
5793 
        else:
5794 
          iprot.skip(ftype)
5795 
      else:
5796 
        iprot.skip(ftype)
5797 
      iprot.readFieldEnd()
5798 
    iprot.readStructEnd()
5799 
 
5800 
  def write(self, oprot):
5801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5803 
      return
5804 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_args')
5805 
    if self.date is not None:
5806 
      oprot.writeFieldBegin('date', TType.I64, 1)
5807 
      oprot.writeI64(self.date)
5808 
      oprot.writeFieldEnd()
5809 
    oprot.writeFieldStop()
5810 
    oprot.writeStructEnd()
5811 
 
5812 
  def validate(self):
5813 
    return
5814 
 
5815 
 
5816 
  def __repr__(self):
5817 
    L = ['%s=%r' % (key, value)
5818 
      for key, value in self.__dict__.iteritems()]
5819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5820 
 
5821 
  def __eq__(self, other):
5822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5823 
 
5824 
  def __ne__(self, other):
5825 
    return not (self == other)
5826 
 
5827 
class fetchScansPerInvoiceNumber_result:
5828 
  """
5829 
  Attributes:
5830 
   - success
5831 
  """
5832 
 
5833 
  thrift_spec = (
5834 
    (0, TType.LIST, 'success', (TType.STRUCT,(InvoiceScan, InvoiceScan.thrift_spec)), None, ), # 0
5835 
  )
5836 
 
5837 
  def __init__(self, success=None,):
5838 
    self.success = success
5839 
 
5840 
  def read(self, iprot):
5841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5843 
      return
5844 
    iprot.readStructBegin()
5845 
    while True:
5846 
      (fname, ftype, fid) = iprot.readFieldBegin()
5847 
      if ftype == TType.STOP:
5848 
        break
5849 
      if fid == 0:
5850 
        if ftype == TType.LIST:
5851 
          self.success = []
10407 amar.kumar 5852 
          (_etype45, _size42) = iprot.readListBegin()
5853 
          for _i46 in xrange(_size42):
5854 
            _elem47 = InvoiceScan()
5855 
            _elem47.read(iprot)
5856 
            self.success.append(_elem47)
5496 mandeep.dh 5857 
          iprot.readListEnd()
5858 
        else:
5859 
          iprot.skip(ftype)
5860 
      else:
5861 
        iprot.skip(ftype)
5862 
      iprot.readFieldEnd()
5863 
    iprot.readStructEnd()
5864 
 
5865 
  def write(self, oprot):
5866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5868 
      return
5869 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_result')
5870 
    if self.success is not None:
5871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 5873 
      for iter48 in self.success:
5874 
        iter48.write(oprot)
5496 mandeep.dh 5875 
      oprot.writeListEnd()
5876 
      oprot.writeFieldEnd()
5877 
    oprot.writeFieldStop()
5878 
    oprot.writeStructEnd()
5879 
 
5880 
  def validate(self):
5881 
    return
5882 
 
5883 
 
5884 
  def __repr__(self):
5885 
    L = ['%s=%r' % (key, value)
5886 
      for key, value in self.__dict__.iteritems()]
5887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5888 
 
5889 
  def __eq__(self, other):
5890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5891 
 
5892 
  def __ne__(self, other):
5893 
    return not (self == other)
5620 mandeep.dh 5894 
 
5895 
class getInventoryItemFromOrder_args:
5896 
  """
5897 
  Attributes:
5898 
   - orderId
5899 
  """
5900 
 
5901 
  thrift_spec = (
5902 
    None, # 0
5903 
    (1, TType.I64, 'orderId', None, None, ), # 1
5904 
  )
5905 
 
5906 
  def __init__(self, orderId=None,):
5907 
    self.orderId = orderId
5908 
 
5909 
  def read(self, iprot):
5910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5912 
      return
5913 
    iprot.readStructBegin()
5914 
    while True:
5915 
      (fname, ftype, fid) = iprot.readFieldBegin()
5916 
      if ftype == TType.STOP:
5917 
        break
5918 
      if fid == 1:
5919 
        if ftype == TType.I64:
5920 
          self.orderId = iprot.readI64();
5921 
        else:
5922 
          iprot.skip(ftype)
5923 
      else:
5924 
        iprot.skip(ftype)
5925 
      iprot.readFieldEnd()
5926 
    iprot.readStructEnd()
5927 
 
5928 
  def write(self, oprot):
5929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5931 
      return
5932 
    oprot.writeStructBegin('getInventoryItemFromOrder_args')
5933 
    if self.orderId is not None:
5934 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5935 
      oprot.writeI64(self.orderId)
5936 
      oprot.writeFieldEnd()
5937 
    oprot.writeFieldStop()
5938 
    oprot.writeStructEnd()
5939 
 
5940 
  def validate(self):
5941 
    return
5942 
 
5943 
 
5944 
  def __repr__(self):
5945 
    L = ['%s=%r' % (key, value)
5946 
      for key, value in self.__dict__.iteritems()]
5947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5948 
 
5949 
  def __eq__(self, other):
5950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5951 
 
5952 
  def __ne__(self, other):
5953 
    return not (self == other)
5954 
 
5955 
class getInventoryItemFromOrder_result:
5956 
  """
5957 
  Attributes:
5958 
   - success
5959 
   - we
5960 
  """
5961 
 
5962 
  thrift_spec = (
5963 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
5964 
    (1, TType.STRUCT, 'we', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5965 
  )
5966 
 
5967 
  def __init__(self, success=None, we=None,):
5968 
    self.success = success
5969 
    self.we = we
5970 
 
5971 
  def read(self, iprot):
5972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5974 
      return
5975 
    iprot.readStructBegin()
5976 
    while True:
5977 
      (fname, ftype, fid) = iprot.readFieldBegin()
5978 
      if ftype == TType.STOP:
5979 
        break
5980 
      if fid == 0:
5981 
        if ftype == TType.STRUCT:
5982 
          self.success = InventoryItem()
5983 
          self.success.read(iprot)
5984 
        else:
5985 
          iprot.skip(ftype)
5986 
      elif fid == 1:
5987 
        if ftype == TType.STRUCT:
5988 
          self.we = WarehouseServiceException()
5989 
          self.we.read(iprot)
5990 
        else:
5991 
          iprot.skip(ftype)
5992 
      else:
5993 
        iprot.skip(ftype)
5994 
      iprot.readFieldEnd()
5995 
    iprot.readStructEnd()
5996 
 
5997 
  def write(self, oprot):
5998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6000 
      return
6001 
    oprot.writeStructBegin('getInventoryItemFromOrder_result')
6002 
    if self.success is not None:
6003 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6004 
      self.success.write(oprot)
6005 
      oprot.writeFieldEnd()
6006 
    if self.we is not None:
6007 
      oprot.writeFieldBegin('we', TType.STRUCT, 1)
6008 
      self.we.write(oprot)
6009 
      oprot.writeFieldEnd()
6010 
    oprot.writeFieldStop()
6011 
    oprot.writeStructEnd()
6012 
 
6013 
  def validate(self):
6014 
    return
6015 
 
6016 
 
6017 
  def __repr__(self):
6018 
    L = ['%s=%r' % (key, value)
6019 
      for key, value in self.__dict__.iteritems()]
6020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6021 
 
6022 
  def __eq__(self, other):
6023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6024 
 
6025 
  def __ne__(self, other):
6026 
    return not (self == other)
5711 mandeep.dh 6027 
 
6028 
class getInventoryAge_args:
6029 
 
6030 
  thrift_spec = (
6031 
  )
6032 
 
6033 
  def read(self, iprot):
6034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6036 
      return
6037 
    iprot.readStructBegin()
6038 
    while True:
6039 
      (fname, ftype, fid) = iprot.readFieldBegin()
6040 
      if ftype == TType.STOP:
6041 
        break
6042 
      else:
6043 
        iprot.skip(ftype)
6044 
      iprot.readFieldEnd()
6045 
    iprot.readStructEnd()
6046 
 
6047 
  def write(self, oprot):
6048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6050 
      return
6051 
    oprot.writeStructBegin('getInventoryAge_args')
6052 
    oprot.writeFieldStop()
6053 
    oprot.writeStructEnd()
6054 
 
6055 
  def validate(self):
6056 
    return
6057 
 
6058 
 
6059 
  def __repr__(self):
6060 
    L = ['%s=%r' % (key, value)
6061 
      for key, value in self.__dict__.iteritems()]
6062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6063 
 
6064 
  def __eq__(self, other):
6065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6066 
 
6067 
  def __ne__(self, other):
6068 
    return not (self == other)
6069 
 
6070 
class getInventoryAge_result:
6071 
  """
6072 
  Attributes:
6073 
   - success
6074 
  """
6075 
 
6076 
  thrift_spec = (
6077 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAge, InventoryAge.thrift_spec)), None, ), # 0
6078 
  )
6079 
 
6080 
  def __init__(self, success=None,):
6081 
    self.success = success
6082 
 
6083 
  def read(self, iprot):
6084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6086 
      return
6087 
    iprot.readStructBegin()
6088 
    while True:
6089 
      (fname, ftype, fid) = iprot.readFieldBegin()
6090 
      if ftype == TType.STOP:
6091 
        break
6092 
      if fid == 0:
6093 
        if ftype == TType.LIST:
6094 
          self.success = []
10407 amar.kumar 6095 
          (_etype52, _size49) = iprot.readListBegin()
6096 
          for _i53 in xrange(_size49):
6097 
            _elem54 = InventoryAge()
6098 
            _elem54.read(iprot)
6099 
            self.success.append(_elem54)
5711 mandeep.dh 6100 
          iprot.readListEnd()
6101 
        else:
6102 
          iprot.skip(ftype)
6103 
      else:
6104 
        iprot.skip(ftype)
6105 
      iprot.readFieldEnd()
6106 
    iprot.readStructEnd()
6107 
 
6108 
  def write(self, oprot):
6109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6111 
      return
6112 
    oprot.writeStructBegin('getInventoryAge_result')
6113 
    if self.success is not None:
6114 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6115 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 6116 
      for iter55 in self.success:
6117 
        iter55.write(oprot)
5711 mandeep.dh 6118 
      oprot.writeListEnd()
6119 
      oprot.writeFieldEnd()
6120 
    oprot.writeFieldStop()
6121 
    oprot.writeStructEnd()
6122 
 
6123 
  def validate(self):
6124 
    return
6125 
 
6126 
 
6127 
  def __repr__(self):
6128 
    L = ['%s=%r' % (key, value)
6129 
      for key, value in self.__dict__.iteritems()]
6130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6131 
 
6132 
  def __eq__(self, other):
6133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6134 
 
6135 
  def __ne__(self, other):
6136 
    return not (self == other)
6361 rajveer 6137 
 
6138 
class getInventoryScansForItem_args:
6139 
  """
6140 
  Attributes:
6141 
   - itemId
6142 
   - fromDate
6143 
   - toDate
6144 
  """
6145 
 
6146 
  thrift_spec = (
6147 
    None, # 0
6148 
    (1, TType.I64, 'itemId', None, None, ), # 1
6149 
    (2, TType.I64, 'fromDate', None, None, ), # 2
6150 
    (3, TType.I64, 'toDate', None, None, ), # 3
6151 
  )
6152 
 
6153 
  def __init__(self, itemId=None, fromDate=None, toDate=None,):
6154 
    self.itemId = itemId
6155 
    self.fromDate = fromDate
6156 
    self.toDate = toDate
6157 
 
6158 
  def read(self, iprot):
6159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6161 
      return
6162 
    iprot.readStructBegin()
6163 
    while True:
6164 
      (fname, ftype, fid) = iprot.readFieldBegin()
6165 
      if ftype == TType.STOP:
6166 
        break
6167 
      if fid == 1:
6168 
        if ftype == TType.I64:
6169 
          self.itemId = iprot.readI64();
6170 
        else:
6171 
          iprot.skip(ftype)
6172 
      elif fid == 2:
6173 
        if ftype == TType.I64:
6174 
          self.fromDate = iprot.readI64();
6175 
        else:
6176 
          iprot.skip(ftype)
6177 
      elif fid == 3:
6178 
        if ftype == TType.I64:
6179 
          self.toDate = iprot.readI64();
6180 
        else:
6181 
          iprot.skip(ftype)
6182 
      else:
6183 
        iprot.skip(ftype)
6184 
      iprot.readFieldEnd()
6185 
    iprot.readStructEnd()
6186 
 
6187 
  def write(self, oprot):
6188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6190 
      return
6191 
    oprot.writeStructBegin('getInventoryScansForItem_args')
6192 
    if self.itemId is not None:
6193 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
6194 
      oprot.writeI64(self.itemId)
6195 
      oprot.writeFieldEnd()
6196 
    if self.fromDate is not None:
6197 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
6198 
      oprot.writeI64(self.fromDate)
6199 
      oprot.writeFieldEnd()
6200 
    if self.toDate is not None:
6201 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
6202 
      oprot.writeI64(self.toDate)
6203 
      oprot.writeFieldEnd()
6204 
    oprot.writeFieldStop()
6205 
    oprot.writeStructEnd()
6206 
 
6207 
  def validate(self):
6208 
    return
6209 
 
6210 
 
6211 
  def __repr__(self):
6212 
    L = ['%s=%r' % (key, value)
6213 
      for key, value in self.__dict__.iteritems()]
6214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6215 
 
6216 
  def __eq__(self, other):
6217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6218 
 
6219 
  def __ne__(self, other):
6220 
    return not (self == other)
6221 
 
6222 
class getInventoryScansForItem_result:
6223 
  """
6224 
  Attributes:
6225 
   - success
6226 
  """
6227 
 
6228 
  thrift_spec = (
6229 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
6230 
  )
6231 
 
6232 
  def __init__(self, success=None,):
6233 
    self.success = success
6234 
 
6235 
  def read(self, iprot):
6236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6238 
      return
6239 
    iprot.readStructBegin()
6240 
    while True:
6241 
      (fname, ftype, fid) = iprot.readFieldBegin()
6242 
      if ftype == TType.STOP:
6243 
        break
6244 
      if fid == 0:
6245 
        if ftype == TType.LIST:
6246 
          self.success = []
10407 amar.kumar 6247 
          (_etype59, _size56) = iprot.readListBegin()
6248 
          for _i60 in xrange(_size56):
6249 
            _elem61 = Scan()
6250 
            _elem61.read(iprot)
6251 
            self.success.append(_elem61)
6361 rajveer 6252 
          iprot.readListEnd()
6253 
        else:
6254 
          iprot.skip(ftype)
6255 
      else:
6256 
        iprot.skip(ftype)
6257 
      iprot.readFieldEnd()
6258 
    iprot.readStructEnd()
6259 
 
6260 
  def write(self, oprot):
6261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6263 
      return
6264 
    oprot.writeStructBegin('getInventoryScansForItem_result')
6265 
    if self.success is not None:
6266 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6267 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 6268 
      for iter62 in self.success:
6269 
        iter62.write(oprot)
6361 rajveer 6270 
      oprot.writeListEnd()
6271 
      oprot.writeFieldEnd()
6272 
    oprot.writeFieldStop()
6273 
    oprot.writeStructEnd()
6274 
 
6275 
  def validate(self):
6276 
    return
6277 
 
6278 
 
6279 
  def __repr__(self):
6280 
    L = ['%s=%r' % (key, value)
6281 
      for key, value in self.__dict__.iteritems()]
6282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6283 
 
6284 
  def __eq__(self, other):
6285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6286 
 
6287 
  def __ne__(self, other):
6288 
    return not (self == other)
6289 
 
6290 
class getScanRecordsForSerialNumber_args:
6291 
  """
6292 
  Attributes:
6293 
   - serialNumber
6294 
  """
6295 
 
6296 
  thrift_spec = (
6297 
    None, # 0
7410 amar.kumar 6298 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
6361 rajveer 6299 
  )
6300 
 
6301 
  def __init__(self, serialNumber=None,):
6302 
    self.serialNumber = serialNumber
6303 
 
6304 
  def read(self, iprot):
6305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6307 
      return
6308 
    iprot.readStructBegin()
6309 
    while True:
6310 
      (fname, ftype, fid) = iprot.readFieldBegin()
6311 
      if ftype == TType.STOP:
6312 
        break
6313 
      if fid == 1:
7410 amar.kumar 6314 
        if ftype == TType.STRING:
6315 
          self.serialNumber = iprot.readString();
6361 rajveer 6316 
        else:
6317 
          iprot.skip(ftype)
6318 
      else:
6319 
        iprot.skip(ftype)
6320 
      iprot.readFieldEnd()
6321 
    iprot.readStructEnd()
6322 
 
6323 
  def write(self, oprot):
6324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6326 
      return
6327 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_args')
6328 
    if self.serialNumber is not None:
7410 amar.kumar 6329 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
6330 
      oprot.writeString(self.serialNumber)
6361 rajveer 6331 
      oprot.writeFieldEnd()
6332 
    oprot.writeFieldStop()
6333 
    oprot.writeStructEnd()
6334 
 
6335 
  def validate(self):
6336 
    return
6337 
 
6338 
 
6339 
  def __repr__(self):
6340 
    L = ['%s=%r' % (key, value)
6341 
      for key, value in self.__dict__.iteritems()]
6342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6343 
 
6344 
  def __eq__(self, other):
6345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6346 
 
6347 
  def __ne__(self, other):
6348 
    return not (self == other)
6349 
 
6350 
class getScanRecordsForSerialNumber_result:
6351 
  """
6352 
  Attributes:
6353 
   - success
6354 
  """
6355 
 
6356 
  thrift_spec = (
6357 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
6358 
  )
6359 
 
6360 
  def __init__(self, success=None,):
6361 
    self.success = success
6362 
 
6363 
  def read(self, iprot):
6364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6366 
      return
6367 
    iprot.readStructBegin()
6368 
    while True:
6369 
      (fname, ftype, fid) = iprot.readFieldBegin()
6370 
      if ftype == TType.STOP:
6371 
        break
6372 
      if fid == 0:
6373 
        if ftype == TType.LIST:
6374 
          self.success = []
10407 amar.kumar 6375 
          (_etype66, _size63) = iprot.readListBegin()
6376 
          for _i67 in xrange(_size63):
6377 
            _elem68 = Scan()
6378 
            _elem68.read(iprot)
6379 
            self.success.append(_elem68)
6361 rajveer 6380 
          iprot.readListEnd()
6381 
        else:
6382 
          iprot.skip(ftype)
6383 
      else:
6384 
        iprot.skip(ftype)
6385 
      iprot.readFieldEnd()
6386 
    iprot.readStructEnd()
6387 
 
6388 
  def write(self, oprot):
6389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6391 
      return
6392 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_result')
6393 
    if self.success is not None:
6394 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6395 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 6396 
      for iter69 in self.success:
6397 
        iter69.write(oprot)
6361 rajveer 6398 
      oprot.writeListEnd()
6399 
      oprot.writeFieldEnd()
6400 
    oprot.writeFieldStop()
6401 
    oprot.writeStructEnd()
6402 
 
6403 
  def validate(self):
6404 
    return
6405 
 
6406 
 
6407 
  def __repr__(self):
6408 
    L = ['%s=%r' % (key, value)
6409 
      for key, value in self.__dict__.iteritems()]
6410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6411 
 
6412 
  def __eq__(self, other):
6413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6414 
 
6415 
  def __ne__(self, other):
6416 
    return not (self == other)
6467 amar.kumar 6417 
 
6418 
class scanForPurchaseReturn_args:
6419 
  """
6420 
  Attributes:
6421 
   - saleReturnItems
6422 
   - vendorId
7718 amar.kumar 6423 
   - billingWarehouseId
6467 amar.kumar 6424 
  """
6425 
 
6426 
  thrift_spec = (
6427 
    None, # 0
6428 
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
6429 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7718 amar.kumar 6430 
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
6467 amar.kumar 6431 
  )
6432 
 
7718 amar.kumar 6433 
  def __init__(self, saleReturnItems=None, vendorId=None, billingWarehouseId=None,):
6467 amar.kumar 6434 
    self.saleReturnItems = saleReturnItems
6435 
    self.vendorId = vendorId
7718 amar.kumar 6436 
    self.billingWarehouseId = billingWarehouseId
6467 amar.kumar 6437 
 
6438 
  def read(self, iprot):
6439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6441 
      return
6442 
    iprot.readStructBegin()
6443 
    while True:
6444 
      (fname, ftype, fid) = iprot.readFieldBegin()
6445 
      if ftype == TType.STOP:
6446 
        break
6447 
      if fid == 1:
6448 
        if ftype == TType.LIST:
6449 
          self.saleReturnItems = []
10407 amar.kumar 6450 
          (_etype73, _size70) = iprot.readListBegin()
6451 
          for _i74 in xrange(_size70):
6452 
            _elem75 = InventoryItem()
6453 
            _elem75.read(iprot)
6454 
            self.saleReturnItems.append(_elem75)
6467 amar.kumar 6455 
          iprot.readListEnd()
6456 
        else:
6457 
          iprot.skip(ftype)
6458 
      elif fid == 2:
6459 
        if ftype == TType.I64:
6460 
          self.vendorId = iprot.readI64();
6461 
        else:
6462 
          iprot.skip(ftype)
7718 amar.kumar 6463 
      elif fid == 3:
6464 
        if ftype == TType.I64:
6465 
          self.billingWarehouseId = iprot.readI64();
6466 
        else:
6467 
          iprot.skip(ftype)
6467 amar.kumar 6468 
      else:
6469 
        iprot.skip(ftype)
6470 
      iprot.readFieldEnd()
6471 
    iprot.readStructEnd()
6472 
 
6473 
  def write(self, oprot):
6474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6476 
      return
6477 
    oprot.writeStructBegin('scanForPurchaseReturn_args')
6478 
    if self.saleReturnItems is not None:
6479 
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
6480 
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
10407 amar.kumar 6481 
      for iter76 in self.saleReturnItems:
6482 
        iter76.write(oprot)
6467 amar.kumar 6483 
      oprot.writeListEnd()
6484 
      oprot.writeFieldEnd()
6485 
    if self.vendorId is not None:
6486 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
6487 
      oprot.writeI64(self.vendorId)
6488 
      oprot.writeFieldEnd()
7718 amar.kumar 6489 
    if self.billingWarehouseId is not None:
6490 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
6491 
      oprot.writeI64(self.billingWarehouseId)
6492 
      oprot.writeFieldEnd()
6467 amar.kumar 6493 
    oprot.writeFieldStop()
6494 
    oprot.writeStructEnd()
6495 
 
6496 
  def validate(self):
6497 
    return
6498 
 
6499 
 
6500 
  def __repr__(self):
6501 
    L = ['%s=%r' % (key, value)
6502 
      for key, value in self.__dict__.iteritems()]
6503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6504 
 
6505 
  def __eq__(self, other):
6506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6507 
 
6508 
  def __ne__(self, other):
6509 
    return not (self == other)
6510 
 
6511 
class scanForPurchaseReturn_result:
6512 
  """
6513 
  Attributes:
10864 manish.sha 6514 
   - success
6467 amar.kumar 6515 
   - ex
6516 
  """
6517 
 
6518 
  thrift_spec = (
10864 manish.sha 6519 
    (0, TType.I64, 'success', None, None, ), # 0
6467 amar.kumar 6520 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
6521 
  )
6522 
 
10864 manish.sha 6523 
  def __init__(self, success=None, ex=None,):
6524 
    self.success = success
6467 amar.kumar 6525 
    self.ex = ex
6526 
 
6527 
  def read(self, iprot):
6528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6530 
      return
6531 
    iprot.readStructBegin()
6532 
    while True:
6533 
      (fname, ftype, fid) = iprot.readFieldBegin()
6534 
      if ftype == TType.STOP:
6535 
        break
10864 manish.sha 6536 
      if fid == 0:
6537 
        if ftype == TType.I64:
6538 
          self.success = iprot.readI64();
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      elif fid == 1:
6467 amar.kumar 6542 
        if ftype == TType.STRUCT:
6543 
          self.ex = WarehouseServiceException()
6544 
          self.ex.read(iprot)
6545 
        else:
6546 
          iprot.skip(ftype)
6547 
      else:
6548 
        iprot.skip(ftype)
6549 
      iprot.readFieldEnd()
6550 
    iprot.readStructEnd()
6551 
 
6552 
  def write(self, oprot):
6553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6555 
      return
6556 
    oprot.writeStructBegin('scanForPurchaseReturn_result')
10864 manish.sha 6557 
    if self.success is not None:
6558 
      oprot.writeFieldBegin('success', TType.I64, 0)
6559 
      oprot.writeI64(self.success)
6560 
      oprot.writeFieldEnd()
6467 amar.kumar 6561 
    if self.ex is not None:
6562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6563 
      self.ex.write(oprot)
6564 
      oprot.writeFieldEnd()
6565 
    oprot.writeFieldStop()
6566 
    oprot.writeStructEnd()
6567 
 
6568 
  def validate(self):
6569 
    return
6570 
 
6571 
 
6572 
  def __repr__(self):
6573 
    L = ['%s=%r' % (key, value)
6574 
      for key, value in self.__dict__.iteritems()]
6575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6576 
 
6577 
  def __eq__(self, other):
6578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6579 
 
6580 
  def __ne__(self, other):
6581 
    return not (self == other)
6630 amar.kumar 6582 
 
6583 
class scanForLostItem_args:
6584 
  """
6585 
  Attributes:
6586 
   - lostItems
6587 
   - vendorId
7718 amar.kumar 6588 
   - billingWarehouseId
6630 amar.kumar 6589 
  """
6590 
 
6591 
  thrift_spec = (
6592 
    None, # 0
6593 
    (1, TType.LIST, 'lostItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
6594 
    (2, TType.I64, 'vendorId', None, None, ), # 2
7718 amar.kumar 6595 
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
6630 amar.kumar 6596 
  )
6597 
 
7718 amar.kumar 6598 
  def __init__(self, lostItems=None, vendorId=None, billingWarehouseId=None,):
6630 amar.kumar 6599 
    self.lostItems = lostItems
6600 
    self.vendorId = vendorId
7718 amar.kumar 6601 
    self.billingWarehouseId = billingWarehouseId
6630 amar.kumar 6602 
 
6603 
  def read(self, iprot):
6604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6606 
      return
6607 
    iprot.readStructBegin()
6608 
    while True:
6609 
      (fname, ftype, fid) = iprot.readFieldBegin()
6610 
      if ftype == TType.STOP:
6611 
        break
6612 
      if fid == 1:
6613 
        if ftype == TType.LIST:
6614 
          self.lostItems = []
10407 amar.kumar 6615 
          (_etype80, _size77) = iprot.readListBegin()
6616 
          for _i81 in xrange(_size77):
6617 
            _elem82 = InventoryItem()
6618 
            _elem82.read(iprot)
6619 
            self.lostItems.append(_elem82)
6630 amar.kumar 6620 
          iprot.readListEnd()
6621 
        else:
6622 
          iprot.skip(ftype)
6623 
      elif fid == 2:
6624 
        if ftype == TType.I64:
6625 
          self.vendorId = iprot.readI64();
6626 
        else:
6627 
          iprot.skip(ftype)
7718 amar.kumar 6628 
      elif fid == 3:
6629 
        if ftype == TType.I64:
6630 
          self.billingWarehouseId = iprot.readI64();
6631 
        else:
6632 
          iprot.skip(ftype)
6630 amar.kumar 6633 
      else:
6634 
        iprot.skip(ftype)
6635 
      iprot.readFieldEnd()
6636 
    iprot.readStructEnd()
6637 
 
6638 
  def write(self, oprot):
6639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6641 
      return
6642 
    oprot.writeStructBegin('scanForLostItem_args')
6643 
    if self.lostItems is not None:
6644 
      oprot.writeFieldBegin('lostItems', TType.LIST, 1)
6645 
      oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
10407 amar.kumar 6646 
      for iter83 in self.lostItems:
6647 
        iter83.write(oprot)
6630 amar.kumar 6648 
      oprot.writeListEnd()
6649 
      oprot.writeFieldEnd()
6650 
    if self.vendorId is not None:
6651 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
6652 
      oprot.writeI64(self.vendorId)
6653 
      oprot.writeFieldEnd()
7718 amar.kumar 6654 
    if self.billingWarehouseId is not None:
6655 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
6656 
      oprot.writeI64(self.billingWarehouseId)
6657 
      oprot.writeFieldEnd()
6630 amar.kumar 6658 
    oprot.writeFieldStop()
6659 
    oprot.writeStructEnd()
6660 
 
6661 
  def validate(self):
6662 
    return
6663 
 
6664 
 
6665 
  def __repr__(self):
6666 
    L = ['%s=%r' % (key, value)
6667 
      for key, value in self.__dict__.iteritems()]
6668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6669 
 
6670 
  def __eq__(self, other):
6671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6672 
 
6673 
  def __ne__(self, other):
6674 
    return not (self == other)
6675 
 
6676 
class scanForLostItem_result:
6677 
  """
6678 
  Attributes:
6679 
   - ex
6680 
  """
6681 
 
6682 
  thrift_spec = (
6683 
    None, # 0
6684 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
6685 
  )
6686 
 
6687 
  def __init__(self, ex=None,):
6688 
    self.ex = ex
6689 
 
6690 
  def read(self, iprot):
6691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6693 
      return
6694 
    iprot.readStructBegin()
6695 
    while True:
6696 
      (fname, ftype, fid) = iprot.readFieldBegin()
6697 
      if ftype == TType.STOP:
6698 
        break
6699 
      if fid == 1:
6700 
        if ftype == TType.STRUCT:
6701 
          self.ex = WarehouseServiceException()
6702 
          self.ex.read(iprot)
6703 
        else:
6704 
          iprot.skip(ftype)
6705 
      else:
6706 
        iprot.skip(ftype)
6707 
      iprot.readFieldEnd()
6708 
    iprot.readStructEnd()
6709 
 
6710 
  def write(self, oprot):
6711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6713 
      return
6714 
    oprot.writeStructBegin('scanForLostItem_result')
6715 
    if self.ex is not None:
6716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6717 
      self.ex.write(oprot)
6718 
      oprot.writeFieldEnd()
6719 
    oprot.writeFieldStop()
6720 
    oprot.writeStructEnd()
6721 
 
6722 
  def validate(self):
6723 
    return
6724 
 
6725 
 
6726 
  def __repr__(self):
6727 
    L = ['%s=%r' % (key, value)
6728 
      for key, value in self.__dict__.iteritems()]
6729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6730 
 
6731 
  def __eq__(self, other):
6732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6733 
 
6734 
  def __ne__(self, other):
6735 
    return not (self == other)
6736 
 
6737 
class getCurrentSerializedInventoryByScans_args:
7715 vikram.rag 6738 
  """
6739 
  Attributes:
6740 
   - physicalWarehouseId
6741 
  """
6630 amar.kumar 6742 
 
6743 
  thrift_spec = (
7715 vikram.rag 6744 
    None, # 0
6745 
    (1, TType.I64, 'physicalWarehouseId', None, None, ), # 1
6630 amar.kumar 6746 
  )
6747 
 
7715 vikram.rag 6748 
  def __init__(self, physicalWarehouseId=None,):
6749 
    self.physicalWarehouseId = physicalWarehouseId
6750 
 
6630 amar.kumar 6751 
  def read(self, iprot):
6752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6754 
      return
6755 
    iprot.readStructBegin()
6756 
    while True:
6757 
      (fname, ftype, fid) = iprot.readFieldBegin()
6758 
      if ftype == TType.STOP:
6759 
        break
7715 vikram.rag 6760 
      if fid == 1:
6761 
        if ftype == TType.I64:
6762 
          self.physicalWarehouseId = iprot.readI64();
6763 
        else:
6764 
          iprot.skip(ftype)
6630 amar.kumar 6765 
      else:
6766 
        iprot.skip(ftype)
6767 
      iprot.readFieldEnd()
6768 
    iprot.readStructEnd()
6769 
 
6770 
  def write(self, oprot):
6771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6773 
      return
6774 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_args')
7715 vikram.rag 6775 
    if self.physicalWarehouseId is not None:
6776 
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 1)
6777 
      oprot.writeI64(self.physicalWarehouseId)
6778 
      oprot.writeFieldEnd()
6630 amar.kumar 6779 
    oprot.writeFieldStop()
6780 
    oprot.writeStructEnd()
6781 
 
6782 
  def validate(self):
6783 
    return
6784 
 
6785 
 
6786 
  def __repr__(self):
6787 
    L = ['%s=%r' % (key, value)
6788 
      for key, value in self.__dict__.iteritems()]
6789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6790 
 
6791 
  def __eq__(self, other):
6792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6793 
 
6794 
  def __ne__(self, other):
6795 
    return not (self == other)
6796 
 
6797 
class getCurrentSerializedInventoryByScans_result:
6798 
  """
6799 
  Attributes:
6800 
   - success
6801 
  """
6802 
 
6803 
  thrift_spec = (
6804 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
6805 
  )
6806 
 
6807 
  def __init__(self, success=None,):
6808 
    self.success = success
6809 
 
6810 
  def read(self, iprot):
6811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6813 
      return
6814 
    iprot.readStructBegin()
6815 
    while True:
6816 
      (fname, ftype, fid) = iprot.readFieldBegin()
6817 
      if ftype == TType.STOP:
6818 
        break
6819 
      if fid == 0:
6820 
        if ftype == TType.LIST:
6821 
          self.success = []
10407 amar.kumar 6822 
          (_etype87, _size84) = iprot.readListBegin()
6823 
          for _i88 in xrange(_size84):
6824 
            _elem89 = InventoryAvailability()
6825 
            _elem89.read(iprot)
6826 
            self.success.append(_elem89)
6630 amar.kumar 6827 
          iprot.readListEnd()
6828 
        else:
6829 
          iprot.skip(ftype)
6830 
      else:
6831 
        iprot.skip(ftype)
6832 
      iprot.readFieldEnd()
6833 
    iprot.readStructEnd()
6834 
 
6835 
  def write(self, oprot):
6836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6838 
      return
6839 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_result')
6840 
    if self.success is not None:
6841 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6842 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 6843 
      for iter90 in self.success:
6844 
        iter90.write(oprot)
6630 amar.kumar 6845 
      oprot.writeListEnd()
6846 
      oprot.writeFieldEnd()
6847 
    oprot.writeFieldStop()
6848 
    oprot.writeStructEnd()
6849 
 
6850 
  def validate(self):
6851 
    return
6852 
 
6853 
 
6854 
  def __repr__(self):
6855 
    L = ['%s=%r' % (key, value)
6856 
      for key, value in self.__dict__.iteritems()]
6857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6858 
 
6859 
  def __eq__(self, other):
6860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6861 
 
6862 
  def __ne__(self, other):
6863 
    return not (self == other)
6864 
 
6865 
class getCurrentNonSerializedInventoryByScans_args:
7715 vikram.rag 6866 
  """
6867 
  Attributes:
6868 
   - physicalWarehouseId
6869 
  """
6630 amar.kumar 6870 
 
6871 
  thrift_spec = (
7715 vikram.rag 6872 
    None, # 0
6873 
    (1, TType.I64, 'physicalWarehouseId', None, None, ), # 1
6630 amar.kumar 6874 
  )
6875 
 
7715 vikram.rag 6876 
  def __init__(self, physicalWarehouseId=None,):
6877 
    self.physicalWarehouseId = physicalWarehouseId
6878 
 
6630 amar.kumar 6879 
  def read(self, iprot):
6880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6882 
      return
6883 
    iprot.readStructBegin()
6884 
    while True:
6885 
      (fname, ftype, fid) = iprot.readFieldBegin()
6886 
      if ftype == TType.STOP:
6887 
        break
7715 vikram.rag 6888 
      if fid == 1:
6889 
        if ftype == TType.I64:
6890 
          self.physicalWarehouseId = iprot.readI64();
6891 
        else:
6892 
          iprot.skip(ftype)
6630 amar.kumar 6893 
      else:
6894 
        iprot.skip(ftype)
6895 
      iprot.readFieldEnd()
6896 
    iprot.readStructEnd()
6897 
 
6898 
  def write(self, oprot):
6899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6901 
      return
6902 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_args')
7715 vikram.rag 6903 
    if self.physicalWarehouseId is not None:
6904 
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 1)
6905 
      oprot.writeI64(self.physicalWarehouseId)
6906 
      oprot.writeFieldEnd()
6630 amar.kumar 6907 
    oprot.writeFieldStop()
6908 
    oprot.writeStructEnd()
6909 
 
6910 
  def validate(self):
6911 
    return
6912 
 
6913 
 
6914 
  def __repr__(self):
6915 
    L = ['%s=%r' % (key, value)
6916 
      for key, value in self.__dict__.iteritems()]
6917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6918 
 
6919 
  def __eq__(self, other):
6920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6921 
 
6922 
  def __ne__(self, other):
6923 
    return not (self == other)
6924 
 
6925 
class getCurrentNonSerializedInventoryByScans_result:
6926 
  """
6927 
  Attributes:
6928 
   - success
6929 
  """
6930 
 
6931 
  thrift_spec = (
6932 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
6933 
  )
6934 
 
6935 
  def __init__(self, success=None,):
6936 
    self.success = success
6937 
 
6938 
  def read(self, iprot):
6939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6941 
      return
6942 
    iprot.readStructBegin()
6943 
    while True:
6944 
      (fname, ftype, fid) = iprot.readFieldBegin()
6945 
      if ftype == TType.STOP:
6946 
        break
6947 
      if fid == 0:
6948 
        if ftype == TType.LIST:
6949 
          self.success = []
10407 amar.kumar 6950 
          (_etype94, _size91) = iprot.readListBegin()
6951 
          for _i95 in xrange(_size91):
6952 
            _elem96 = InventoryAvailability()
6953 
            _elem96.read(iprot)
6954 
            self.success.append(_elem96)
6630 amar.kumar 6955 
          iprot.readListEnd()
6956 
        else:
6957 
          iprot.skip(ftype)
6958 
      else:
6959 
        iprot.skip(ftype)
6960 
      iprot.readFieldEnd()
6961 
    iprot.readStructEnd()
6962 
 
6963 
  def write(self, oprot):
6964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6966 
      return
6967 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_result')
6968 
    if self.success is not None:
6969 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6970 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 6971 
      for iter97 in self.success:
6972 
        iter97.write(oprot)
6630 amar.kumar 6973 
      oprot.writeListEnd()
6974 
      oprot.writeFieldEnd()
6975 
    oprot.writeFieldStop()
6976 
    oprot.writeStructEnd()
6977 
 
6978 
  def validate(self):
6979 
    return
6980 
 
6981 
 
6982 
  def __repr__(self):
6983 
    L = ['%s=%r' % (key, value)
6984 
      for key, value in self.__dict__.iteritems()]
6985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6986 
 
6987 
  def __eq__(self, other):
6988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6989 
 
6990 
  def __ne__(self, other):
6991 
    return not (self == other)
6762 amar.kumar 6992 
 
6993 
class getHistoricSerializedInventoryByScans_args:
6994 
  """
6995 
  Attributes:
6996 
   - date
6997 
  """
6998 
 
6999 
  thrift_spec = (
7000 
    None, # 0
7001 
    (1, TType.I64, 'date', None, None, ), # 1
7002 
  )
7003 
 
7004 
  def __init__(self, date=None,):
7005 
    self.date = date
7006 
 
7007 
  def read(self, iprot):
7008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7010 
      return
7011 
    iprot.readStructBegin()
7012 
    while True:
7013 
      (fname, ftype, fid) = iprot.readFieldBegin()
7014 
      if ftype == TType.STOP:
7015 
        break
7016 
      if fid == 1:
7017 
        if ftype == TType.I64:
7018 
          self.date = iprot.readI64();
7019 
        else:
7020 
          iprot.skip(ftype)
7021 
      else:
7022 
        iprot.skip(ftype)
7023 
      iprot.readFieldEnd()
7024 
    iprot.readStructEnd()
7025 
 
7026 
  def write(self, oprot):
7027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7029 
      return
7030 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_args')
7031 
    if self.date is not None:
7032 
      oprot.writeFieldBegin('date', TType.I64, 1)
7033 
      oprot.writeI64(self.date)
7034 
      oprot.writeFieldEnd()
7035 
    oprot.writeFieldStop()
7036 
    oprot.writeStructEnd()
7037 
 
7038 
  def validate(self):
7039 
    return
7040 
 
7041 
 
7042 
  def __repr__(self):
7043 
    L = ['%s=%r' % (key, value)
7044 
      for key, value in self.__dict__.iteritems()]
7045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7046 
 
7047 
  def __eq__(self, other):
7048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7049 
 
7050 
  def __ne__(self, other):
7051 
    return not (self == other)
7052 
 
7053 
class getHistoricSerializedInventoryByScans_result:
7054 
  """
7055 
  Attributes:
7056 
   - success
7057 
  """
7058 
 
7059 
  thrift_spec = (
7060 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
7061 
  )
7062 
 
7063 
  def __init__(self, success=None,):
7064 
    self.success = success
7065 
 
7066 
  def read(self, iprot):
7067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7069 
      return
7070 
    iprot.readStructBegin()
7071 
    while True:
7072 
      (fname, ftype, fid) = iprot.readFieldBegin()
7073 
      if ftype == TType.STOP:
7074 
        break
7075 
      if fid == 0:
7076 
        if ftype == TType.LIST:
7077 
          self.success = []
10407 amar.kumar 7078 
          (_etype101, _size98) = iprot.readListBegin()
7079 
          for _i102 in xrange(_size98):
7080 
            _elem103 = InventoryAvailability()
7081 
            _elem103.read(iprot)
7082 
            self.success.append(_elem103)
6762 amar.kumar 7083 
          iprot.readListEnd()
7084 
        else:
7085 
          iprot.skip(ftype)
7086 
      else:
7087 
        iprot.skip(ftype)
7088 
      iprot.readFieldEnd()
7089 
    iprot.readStructEnd()
7090 
 
7091 
  def write(self, oprot):
7092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7094 
      return
7095 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_result')
7096 
    if self.success is not None:
7097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7098 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 7099 
      for iter104 in self.success:
7100 
        iter104.write(oprot)
6762 amar.kumar 7101 
      oprot.writeListEnd()
7102 
      oprot.writeFieldEnd()
7103 
    oprot.writeFieldStop()
7104 
    oprot.writeStructEnd()
7105 
 
7106 
  def validate(self):
7107 
    return
7108 
 
7109 
 
7110 
  def __repr__(self):
7111 
    L = ['%s=%r' % (key, value)
7112 
      for key, value in self.__dict__.iteritems()]
7113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7114 
 
7115 
  def __eq__(self, other):
7116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7117 
 
7118 
  def __ne__(self, other):
7119 
    return not (self == other)
7120 
 
7121 
class getHistoricNonSerializedInventoryByScans_args:
7122 
  """
7123 
  Attributes:
7124 
   - date
7125 
  """
7126 
 
7127 
  thrift_spec = (
7128 
    None, # 0
7129 
    (1, TType.I64, 'date', None, None, ), # 1
7130 
  )
7131 
 
7132 
  def __init__(self, date=None,):
7133 
    self.date = date
7134 
 
7135 
  def read(self, iprot):
7136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7138 
      return
7139 
    iprot.readStructBegin()
7140 
    while True:
7141 
      (fname, ftype, fid) = iprot.readFieldBegin()
7142 
      if ftype == TType.STOP:
7143 
        break
7144 
      if fid == 1:
7145 
        if ftype == TType.I64:
7146 
          self.date = iprot.readI64();
7147 
        else:
7148 
          iprot.skip(ftype)
7149 
      else:
7150 
        iprot.skip(ftype)
7151 
      iprot.readFieldEnd()
7152 
    iprot.readStructEnd()
7153 
 
7154 
  def write(self, oprot):
7155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7157 
      return
7158 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_args')
7159 
    if self.date is not None:
7160 
      oprot.writeFieldBegin('date', TType.I64, 1)
7161 
      oprot.writeI64(self.date)
7162 
      oprot.writeFieldEnd()
7163 
    oprot.writeFieldStop()
7164 
    oprot.writeStructEnd()
7165 
 
7166 
  def validate(self):
7167 
    return
7168 
 
7169 
 
7170 
  def __repr__(self):
7171 
    L = ['%s=%r' % (key, value)
7172 
      for key, value in self.__dict__.iteritems()]
7173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7174 
 
7175 
  def __eq__(self, other):
7176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7177 
 
7178 
  def __ne__(self, other):
7179 
    return not (self == other)
7180 
 
7181 
class getHistoricNonSerializedInventoryByScans_result:
7182 
  """
7183 
  Attributes:
7184 
   - success
7185 
  """
7186 
 
7187 
  thrift_spec = (
7188 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
7189 
  )
7190 
 
7191 
  def __init__(self, success=None,):
7192 
    self.success = success
7193 
 
7194 
  def read(self, iprot):
7195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7197 
      return
7198 
    iprot.readStructBegin()
7199 
    while True:
7200 
      (fname, ftype, fid) = iprot.readFieldBegin()
7201 
      if ftype == TType.STOP:
7202 
        break
7203 
      if fid == 0:
7204 
        if ftype == TType.LIST:
7205 
          self.success = []
10407 amar.kumar 7206 
          (_etype108, _size105) = iprot.readListBegin()
7207 
          for _i109 in xrange(_size105):
7208 
            _elem110 = InventoryAvailability()
7209 
            _elem110.read(iprot)
7210 
            self.success.append(_elem110)
6762 amar.kumar 7211 
          iprot.readListEnd()
7212 
        else:
7213 
          iprot.skip(ftype)
7214 
      else:
7215 
        iprot.skip(ftype)
7216 
      iprot.readFieldEnd()
7217 
    iprot.readStructEnd()
7218 
 
7219 
  def write(self, oprot):
7220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7222 
      return
7223 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_result')
7224 
    if self.success is not None:
7225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 7227 
      for iter111 in self.success:
7228 
        iter111.write(oprot)
6762 amar.kumar 7229 
      oprot.writeListEnd()
7230 
      oprot.writeFieldEnd()
7231 
    oprot.writeFieldStop()
7232 
    oprot.writeStructEnd()
7233 
 
7234 
  def validate(self):
7235 
    return
7236 
 
7237 
 
7238 
  def __repr__(self):
7239 
    L = ['%s=%r' % (key, value)
7240 
      for key, value in self.__dict__.iteritems()]
7241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7242 
 
7243 
  def __eq__(self, other):
7244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7245 
 
7246 
  def __ne__(self, other):
7247 
    return not (self == other)
7248 
 
10407 amar.kumar 7249 
class getOurHistoricSerializedInventoryByScans_args:
7250 
  """
7251 
  Attributes:
7252 
   - date
7253 
  """
7254 
 
7255 
  thrift_spec = (
7256 
    None, # 0
7257 
    (1, TType.I64, 'date', None, None, ), # 1
7258 
  )
7259 
 
7260 
  def __init__(self, date=None,):
7261 
    self.date = date
7262 
 
7263 
  def read(self, iprot):
7264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7266 
      return
7267 
    iprot.readStructBegin()
7268 
    while True:
7269 
      (fname, ftype, fid) = iprot.readFieldBegin()
7270 
      if ftype == TType.STOP:
7271 
        break
7272 
      if fid == 1:
7273 
        if ftype == TType.I64:
7274 
          self.date = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      else:
7278 
        iprot.skip(ftype)
7279 
      iprot.readFieldEnd()
7280 
    iprot.readStructEnd()
7281 
 
7282 
  def write(self, oprot):
7283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7285 
      return
7286 
    oprot.writeStructBegin('getOurHistoricSerializedInventoryByScans_args')
7287 
    if self.date is not None:
7288 
      oprot.writeFieldBegin('date', TType.I64, 1)
7289 
      oprot.writeI64(self.date)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
7294 
  def validate(self):
7295 
    return
7296 
 
7297 
 
7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
7309 
class getOurHistoricSerializedInventoryByScans_result:
7310 
  """
7311 
  Attributes:
7312 
   - success
7313 
  """
7314 
 
7315 
  thrift_spec = (
7316 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
7317 
  )
7318 
 
7319 
  def __init__(self, success=None,):
7320 
    self.success = success
7321 
 
7322 
  def read(self, iprot):
7323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7325 
      return
7326 
    iprot.readStructBegin()
7327 
    while True:
7328 
      (fname, ftype, fid) = iprot.readFieldBegin()
7329 
      if ftype == TType.STOP:
7330 
        break
7331 
      if fid == 0:
7332 
        if ftype == TType.LIST:
7333 
          self.success = []
7334 
          (_etype115, _size112) = iprot.readListBegin()
7335 
          for _i116 in xrange(_size112):
7336 
            _elem117 = InventoryAvailability()
7337 
            _elem117.read(iprot)
7338 
            self.success.append(_elem117)
7339 
          iprot.readListEnd()
7340 
        else:
7341 
          iprot.skip(ftype)
7342 
      else:
7343 
        iprot.skip(ftype)
7344 
      iprot.readFieldEnd()
7345 
    iprot.readStructEnd()
7346 
 
7347 
  def write(self, oprot):
7348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7350 
      return
7351 
    oprot.writeStructBegin('getOurHistoricSerializedInventoryByScans_result')
7352 
    if self.success is not None:
7353 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7354 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7355 
      for iter118 in self.success:
7356 
        iter118.write(oprot)
7357 
      oprot.writeListEnd()
7358 
      oprot.writeFieldEnd()
7359 
    oprot.writeFieldStop()
7360 
    oprot.writeStructEnd()
7361 
 
7362 
  def validate(self):
7363 
    return
7364 
 
7365 
 
7366 
  def __repr__(self):
7367 
    L = ['%s=%r' % (key, value)
7368 
      for key, value in self.__dict__.iteritems()]
7369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7370 
 
7371 
  def __eq__(self, other):
7372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7373 
 
7374 
  def __ne__(self, other):
7375 
    return not (self == other)
7376 
 
7377 
class getOurHistoricNonSerializedInventoryByScans_args:
7378 
  """
7379 
  Attributes:
7380 
   - date
7381 
  """
7382 
 
7383 
  thrift_spec = (
7384 
    None, # 0
7385 
    (1, TType.I64, 'date', None, None, ), # 1
7386 
  )
7387 
 
7388 
  def __init__(self, date=None,):
7389 
    self.date = date
7390 
 
7391 
  def read(self, iprot):
7392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7394 
      return
7395 
    iprot.readStructBegin()
7396 
    while True:
7397 
      (fname, ftype, fid) = iprot.readFieldBegin()
7398 
      if ftype == TType.STOP:
7399 
        break
7400 
      if fid == 1:
7401 
        if ftype == TType.I64:
7402 
          self.date = iprot.readI64();
7403 
        else:
7404 
          iprot.skip(ftype)
7405 
      else:
7406 
        iprot.skip(ftype)
7407 
      iprot.readFieldEnd()
7408 
    iprot.readStructEnd()
7409 
 
7410 
  def write(self, oprot):
7411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7413 
      return
7414 
    oprot.writeStructBegin('getOurHistoricNonSerializedInventoryByScans_args')
7415 
    if self.date is not None:
7416 
      oprot.writeFieldBegin('date', TType.I64, 1)
7417 
      oprot.writeI64(self.date)
7418 
      oprot.writeFieldEnd()
7419 
    oprot.writeFieldStop()
7420 
    oprot.writeStructEnd()
7421 
 
7422 
  def validate(self):
7423 
    return
7424 
 
7425 
 
7426 
  def __repr__(self):
7427 
    L = ['%s=%r' % (key, value)
7428 
      for key, value in self.__dict__.iteritems()]
7429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7430 
 
7431 
  def __eq__(self, other):
7432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7433 
 
7434 
  def __ne__(self, other):
7435 
    return not (self == other)
7436 
 
7437 
class getOurHistoricNonSerializedInventoryByScans_result:
7438 
  """
7439 
  Attributes:
7440 
   - success
7441 
  """
7442 
 
7443 
  thrift_spec = (
7444 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
7445 
  )
7446 
 
7447 
  def __init__(self, success=None,):
7448 
    self.success = success
7449 
 
7450 
  def read(self, iprot):
7451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7453 
      return
7454 
    iprot.readStructBegin()
7455 
    while True:
7456 
      (fname, ftype, fid) = iprot.readFieldBegin()
7457 
      if ftype == TType.STOP:
7458 
        break
7459 
      if fid == 0:
7460 
        if ftype == TType.LIST:
7461 
          self.success = []
7462 
          (_etype122, _size119) = iprot.readListBegin()
7463 
          for _i123 in xrange(_size119):
7464 
            _elem124 = InventoryAvailability()
7465 
            _elem124.read(iprot)
7466 
            self.success.append(_elem124)
7467 
          iprot.readListEnd()
7468 
        else:
7469 
          iprot.skip(ftype)
7470 
      else:
7471 
        iprot.skip(ftype)
7472 
      iprot.readFieldEnd()
7473 
    iprot.readStructEnd()
7474 
 
7475 
  def write(self, oprot):
7476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7478 
      return
7479 
    oprot.writeStructBegin('getOurHistoricNonSerializedInventoryByScans_result')
7480 
    if self.success is not None:
7481 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7482 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7483 
      for iter125 in self.success:
7484 
        iter125.write(oprot)
7485 
      oprot.writeListEnd()
7486 
      oprot.writeFieldEnd()
7487 
    oprot.writeFieldStop()
7488 
    oprot.writeStructEnd()
7489 
 
7490 
  def validate(self):
7491 
    return
7492 
 
7493 
 
7494 
  def __repr__(self):
7495 
    L = ['%s=%r' % (key, value)
7496 
      for key, value in self.__dict__.iteritems()]
7497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7498 
 
7499 
  def __eq__(self, other):
7500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7501 
 
7502 
  def __ne__(self, other):
7503 
    return not (self == other)
7504 
 
6762 amar.kumar 7505 
class scanForOursExternalSale_args:
7506 
  """
7507 
  Attributes:
7508 
   - itemId
7509 
   - serialNumber
7510 
   - itemNumber
7511 
   - invoiceNumber
7512 
   - warehouseId
7513 
   - unitPrice
7672 rajveer 7514 
   - nlc
6762 amar.kumar 7515 
   - orderId
7516 
  """
7517 
 
7518 
  thrift_spec = (
7519 
    None, # 0
7520 
    (1, TType.I64, 'itemId', None, None, ), # 1
7521 
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
7522 
    (3, TType.STRING, 'itemNumber', None, None, ), # 3
7523 
    (4, TType.STRING, 'invoiceNumber', None, None, ), # 4
7524 
    (5, TType.I64, 'warehouseId', None, None, ), # 5
7525 
    (6, TType.DOUBLE, 'unitPrice', None, None, ), # 6
7672 rajveer 7526 
    (7, TType.DOUBLE, 'nlc', None, None, ), # 7
7527 
    (8, TType.I64, 'orderId', None, None, ), # 8
6762 amar.kumar 7528 
  )
7529 
 
7672 rajveer 7530 
  def __init__(self, itemId=None, serialNumber=None, itemNumber=None, invoiceNumber=None, warehouseId=None, unitPrice=None, nlc=None, orderId=None,):
6762 amar.kumar 7531 
    self.itemId = itemId
7532 
    self.serialNumber = serialNumber
7533 
    self.itemNumber = itemNumber
7534 
    self.invoiceNumber = invoiceNumber
7535 
    self.warehouseId = warehouseId
7536 
    self.unitPrice = unitPrice
7672 rajveer 7537 
    self.nlc = nlc
6762 amar.kumar 7538 
    self.orderId = orderId
7539 
 
7540 
  def read(self, iprot):
7541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7543 
      return
7544 
    iprot.readStructBegin()
7545 
    while True:
7546 
      (fname, ftype, fid) = iprot.readFieldBegin()
7547 
      if ftype == TType.STOP:
7548 
        break
7549 
      if fid == 1:
7550 
        if ftype == TType.I64:
7551 
          self.itemId = iprot.readI64();
7552 
        else:
7553 
          iprot.skip(ftype)
7554 
      elif fid == 2:
7555 
        if ftype == TType.STRING:
7556 
          self.serialNumber = iprot.readString();
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      elif fid == 3:
7560 
        if ftype == TType.STRING:
7561 
          self.itemNumber = iprot.readString();
7562 
        else:
7563 
          iprot.skip(ftype)
7564 
      elif fid == 4:
7565 
        if ftype == TType.STRING:
7566 
          self.invoiceNumber = iprot.readString();
7567 
        else:
7568 
          iprot.skip(ftype)
7569 
      elif fid == 5:
7570 
        if ftype == TType.I64:
7571 
          self.warehouseId = iprot.readI64();
7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      elif fid == 6:
7575 
        if ftype == TType.DOUBLE:
7576 
          self.unitPrice = iprot.readDouble();
7577 
        else:
7578 
          iprot.skip(ftype)
7579 
      elif fid == 7:
7672 rajveer 7580 
        if ftype == TType.DOUBLE:
7581 
          self.nlc = iprot.readDouble();
7582 
        else:
7583 
          iprot.skip(ftype)
7584 
      elif fid == 8:
6762 amar.kumar 7585 
        if ftype == TType.I64:
7586 
          self.orderId = iprot.readI64();
7587 
        else:
7588 
          iprot.skip(ftype)
7589 
      else:
7590 
        iprot.skip(ftype)
7591 
      iprot.readFieldEnd()
7592 
    iprot.readStructEnd()
7593 
 
7594 
  def write(self, oprot):
7595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7597 
      return
7598 
    oprot.writeStructBegin('scanForOursExternalSale_args')
7599 
    if self.itemId is not None:
7600 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
7601 
      oprot.writeI64(self.itemId)
7602 
      oprot.writeFieldEnd()
7603 
    if self.serialNumber is not None:
7604 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
7605 
      oprot.writeString(self.serialNumber)
7606 
      oprot.writeFieldEnd()
7607 
    if self.itemNumber is not None:
7608 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 3)
7609 
      oprot.writeString(self.itemNumber)
7610 
      oprot.writeFieldEnd()
7611 
    if self.invoiceNumber is not None:
7612 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 4)
7613 
      oprot.writeString(self.invoiceNumber)
7614 
      oprot.writeFieldEnd()
7615 
    if self.warehouseId is not None:
7616 
      oprot.writeFieldBegin('warehouseId', TType.I64, 5)
7617 
      oprot.writeI64(self.warehouseId)
7618 
      oprot.writeFieldEnd()
7619 
    if self.unitPrice is not None:
7620 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 6)
7621 
      oprot.writeDouble(self.unitPrice)
7622 
      oprot.writeFieldEnd()
7672 rajveer 7623 
    if self.nlc is not None:
7624 
      oprot.writeFieldBegin('nlc', TType.DOUBLE, 7)
7625 
      oprot.writeDouble(self.nlc)
7626 
      oprot.writeFieldEnd()
6762 amar.kumar 7627 
    if self.orderId is not None:
7672 rajveer 7628 
      oprot.writeFieldBegin('orderId', TType.I64, 8)
6762 amar.kumar 7629 
      oprot.writeI64(self.orderId)
7630 
      oprot.writeFieldEnd()
7631 
    oprot.writeFieldStop()
7632 
    oprot.writeStructEnd()
7633 
 
7634 
  def validate(self):
7635 
    return
7636 
 
7637 
 
7638 
  def __repr__(self):
7639 
    L = ['%s=%r' % (key, value)
7640 
      for key, value in self.__dict__.iteritems()]
7641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7642 
 
7643 
  def __eq__(self, other):
7644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7645 
 
7646 
  def __ne__(self, other):
7647 
    return not (self == other)
7648 
 
7649 
class scanForOursExternalSale_result:
7650 
  """
7651 
  Attributes:
7652 
   - success
7653 
   - ex
7654 
  """
7655 
 
7656 
  thrift_spec = (
7657 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
7658 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
7659 
  )
7660 
 
7661 
  def __init__(self, success=None, ex=None,):
7662 
    self.success = success
7663 
    self.ex = ex
7664 
 
7665 
  def read(self, iprot):
7666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7668 
      return
7669 
    iprot.readStructBegin()
7670 
    while True:
7671 
      (fname, ftype, fid) = iprot.readFieldBegin()
7672 
      if ftype == TType.STOP:
7673 
        break
7674 
      if fid == 0:
7675 
        if ftype == TType.STRUCT:
7676 
          self.success = InventoryItem()
7677 
          self.success.read(iprot)
7678 
        else:
7679 
          iprot.skip(ftype)
7680 
      elif fid == 1:
7681 
        if ftype == TType.STRUCT:
7682 
          self.ex = WarehouseServiceException()
7683 
          self.ex.read(iprot)
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      else:
7687 
        iprot.skip(ftype)
7688 
      iprot.readFieldEnd()
7689 
    iprot.readStructEnd()
7690 
 
7691 
  def write(self, oprot):
7692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7694 
      return
7695 
    oprot.writeStructBegin('scanForOursExternalSale_result')
7696 
    if self.success is not None:
7697 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7698 
      self.success.write(oprot)
7699 
      oprot.writeFieldEnd()
7700 
    if self.ex is not None:
7701 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7702 
      self.ex.write(oprot)
7703 
      oprot.writeFieldEnd()
7704 
    oprot.writeFieldStop()
7705 
    oprot.writeStructEnd()
7706 
 
7707 
  def validate(self):
7708 
    return
7709 
 
7710 
 
7711 
  def __repr__(self):
7712 
    L = ['%s=%r' % (key, value)
7713 
      for key, value in self.__dict__.iteritems()]
7714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7715 
 
7716 
  def __eq__(self, other):
7717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7718 
 
7719 
  def __ne__(self, other):
7720 
    return not (self == other)
7721 
 
7722 
class scanForOursExternalSaleReturn_args:
7723 
  """
7724 
  Attributes:
7725 
   - orderId
7726 
   - unitPrice
7727 
  """
7728 
 
7729 
  thrift_spec = (
7730 
    None, # 0
7731 
    (1, TType.I64, 'orderId', None, None, ), # 1
7732 
    (2, TType.DOUBLE, 'unitPrice', None, None, ), # 2
7733 
  )
7734 
 
7735 
  def __init__(self, orderId=None, unitPrice=None,):
7736 
    self.orderId = orderId
7737 
    self.unitPrice = unitPrice
7738 
 
7739 
  def read(self, iprot):
7740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7742 
      return
7743 
    iprot.readStructBegin()
7744 
    while True:
7745 
      (fname, ftype, fid) = iprot.readFieldBegin()
7746 
      if ftype == TType.STOP:
7747 
        break
7748 
      if fid == 1:
7749 
        if ftype == TType.I64:
7750 
          self.orderId = iprot.readI64();
7751 
        else:
7752 
          iprot.skip(ftype)
7753 
      elif fid == 2:
7754 
        if ftype == TType.DOUBLE:
7755 
          self.unitPrice = iprot.readDouble();
7756 
        else:
7757 
          iprot.skip(ftype)
7758 
      else:
7759 
        iprot.skip(ftype)
7760 
      iprot.readFieldEnd()
7761 
    iprot.readStructEnd()
7762 
 
7763 
  def write(self, oprot):
7764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7766 
      return
7767 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_args')
7768 
    if self.orderId is not None:
7769 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7770 
      oprot.writeI64(self.orderId)
7771 
      oprot.writeFieldEnd()
7772 
    if self.unitPrice is not None:
7773 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 2)
7774 
      oprot.writeDouble(self.unitPrice)
7775 
      oprot.writeFieldEnd()
7776 
    oprot.writeFieldStop()
7777 
    oprot.writeStructEnd()
7778 
 
7779 
  def validate(self):
7780 
    return
7781 
 
7782 
 
7783 
  def __repr__(self):
7784 
    L = ['%s=%r' % (key, value)
7785 
      for key, value in self.__dict__.iteritems()]
7786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7787 
 
7788 
  def __eq__(self, other):
7789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7790 
 
7791 
  def __ne__(self, other):
7792 
    return not (self == other)
7793 
 
7794 
class scanForOursExternalSaleReturn_result:
7410 amar.kumar 7795 
  """
7796 
  Attributes:
7797 
   - ex
7798 
  """
6762 amar.kumar 7799 
 
7800 
  thrift_spec = (
7410 amar.kumar 7801 
    None, # 0
7802 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
6762 amar.kumar 7803 
  )
7804 
 
7410 amar.kumar 7805 
  def __init__(self, ex=None,):
7806 
    self.ex = ex
7807 
 
6762 amar.kumar 7808 
  def read(self, iprot):
7809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7811 
      return
7812 
    iprot.readStructBegin()
7813 
    while True:
7814 
      (fname, ftype, fid) = iprot.readFieldBegin()
7815 
      if ftype == TType.STOP:
7816 
        break
7410 amar.kumar 7817 
      if fid == 1:
7818 
        if ftype == TType.STRUCT:
7819 
          self.ex = WarehouseServiceException()
7820 
          self.ex.read(iprot)
7821 
        else:
7822 
          iprot.skip(ftype)
6762 amar.kumar 7823 
      else:
7824 
        iprot.skip(ftype)
7825 
      iprot.readFieldEnd()
7826 
    iprot.readStructEnd()
7827 
 
7828 
  def write(self, oprot):
7829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7831 
      return
7832 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_result')
7410 amar.kumar 7833 
    if self.ex is not None:
7834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7835 
      self.ex.write(oprot)
7836 
      oprot.writeFieldEnd()
6762 amar.kumar 7837 
    oprot.writeFieldStop()
7838 
    oprot.writeStructEnd()
7839 
 
7840 
  def validate(self):
7841 
    return
7842 
 
7843 
 
7844 
  def __repr__(self):
7845 
    L = ['%s=%r' % (key, value)
7846 
      for key, value in self.__dict__.iteritems()]
7847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7848 
 
7849 
  def __eq__(self, other):
7850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7851 
 
7852 
  def __ne__(self, other):
7853 
    return not (self == other)
6880 amar.kumar 7854 
 
7855 
class getMovementNonSerializedInventoryByScans_args:
7856 
  """
7857 
  Attributes:
7858 
   - startDate
7859 
   - endDate
7860 
  """
7861 
 
7862 
  thrift_spec = (
7863 
    None, # 0
7864 
    (1, TType.I64, 'startDate', None, None, ), # 1
7865 
    (2, TType.I64, 'endDate', None, None, ), # 2
7866 
  )
7867 
 
7868 
  def __init__(self, startDate=None, endDate=None,):
7869 
    self.startDate = startDate
7870 
    self.endDate = endDate
7871 
 
7872 
  def read(self, iprot):
7873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7875 
      return
7876 
    iprot.readStructBegin()
7877 
    while True:
7878 
      (fname, ftype, fid) = iprot.readFieldBegin()
7879 
      if ftype == TType.STOP:
7880 
        break
7881 
      if fid == 1:
7882 
        if ftype == TType.I64:
7883 
          self.startDate = iprot.readI64();
7884 
        else:
7885 
          iprot.skip(ftype)
7886 
      elif fid == 2:
7887 
        if ftype == TType.I64:
7888 
          self.endDate = iprot.readI64();
7889 
        else:
7890 
          iprot.skip(ftype)
7891 
      else:
7892 
        iprot.skip(ftype)
7893 
      iprot.readFieldEnd()
7894 
    iprot.readStructEnd()
7895 
 
7896 
  def write(self, oprot):
7897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7899 
      return
7900 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_args')
7901 
    if self.startDate is not None:
7902 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
7903 
      oprot.writeI64(self.startDate)
7904 
      oprot.writeFieldEnd()
7905 
    if self.endDate is not None:
7906 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
7907 
      oprot.writeI64(self.endDate)
7908 
      oprot.writeFieldEnd()
7909 
    oprot.writeFieldStop()
7910 
    oprot.writeStructEnd()
7911 
 
7912 
  def validate(self):
7913 
    return
7914 
 
7915 
 
7916 
  def __repr__(self):
7917 
    L = ['%s=%r' % (key, value)
7918 
      for key, value in self.__dict__.iteritems()]
7919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7920 
 
7921 
  def __eq__(self, other):
7922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7923 
 
7924 
  def __ne__(self, other):
7925 
    return not (self == other)
7926 
 
7927 
class getMovementNonSerializedInventoryByScans_result:
7928 
  """
7929 
  Attributes:
7930 
   - success
7931 
  """
7932 
 
7933 
  thrift_spec = (
7934 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
7935 
  )
7936 
 
7937 
  def __init__(self, success=None,):
7938 
    self.success = success
7939 
 
7940 
  def read(self, iprot):
7941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7943 
      return
7944 
    iprot.readStructBegin()
7945 
    while True:
7946 
      (fname, ftype, fid) = iprot.readFieldBegin()
7947 
      if ftype == TType.STOP:
7948 
        break
7949 
      if fid == 0:
7950 
        if ftype == TType.LIST:
7951 
          self.success = []
10407 amar.kumar 7952 
          (_etype129, _size126) = iprot.readListBegin()
7953 
          for _i130 in xrange(_size126):
7954 
            _elem131 = InventoryMovement()
7955 
            _elem131.read(iprot)
7956 
            self.success.append(_elem131)
6880 amar.kumar 7957 
          iprot.readListEnd()
7958 
        else:
7959 
          iprot.skip(ftype)
7960 
      else:
7961 
        iprot.skip(ftype)
7962 
      iprot.readFieldEnd()
7963 
    iprot.readStructEnd()
7964 
 
7965 
  def write(self, oprot):
7966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7968 
      return
7969 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_result')
7970 
    if self.success is not None:
7971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 7973 
      for iter132 in self.success:
7974 
        iter132.write(oprot)
6880 amar.kumar 7975 
      oprot.writeListEnd()
7976 
      oprot.writeFieldEnd()
7977 
    oprot.writeFieldStop()
7978 
    oprot.writeStructEnd()
7979 
 
7980 
  def validate(self):
7981 
    return
7982 
 
7983 
 
7984 
  def __repr__(self):
7985 
    L = ['%s=%r' % (key, value)
7986 
      for key, value in self.__dict__.iteritems()]
7987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7988 
 
7989 
  def __eq__(self, other):
7990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7991 
 
7992 
  def __ne__(self, other):
7993 
    return not (self == other)
7994 
 
7995 
class getMovementSerializedInventoryByScans_args:
7996 
  """
7997 
  Attributes:
7998 
   - startDate
7999 
   - endDate
8000 
  """
8001 
 
8002 
  thrift_spec = (
8003 
    None, # 0
8004 
    (1, TType.I64, 'startDate', None, None, ), # 1
8005 
    (2, TType.I64, 'endDate', None, None, ), # 2
8006 
  )
8007 
 
8008 
  def __init__(self, startDate=None, endDate=None,):
8009 
    self.startDate = startDate
8010 
    self.endDate = endDate
8011 
 
8012 
  def read(self, iprot):
8013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8015 
      return
8016 
    iprot.readStructBegin()
8017 
    while True:
8018 
      (fname, ftype, fid) = iprot.readFieldBegin()
8019 
      if ftype == TType.STOP:
8020 
        break
8021 
      if fid == 1:
8022 
        if ftype == TType.I64:
8023 
          self.startDate = iprot.readI64();
8024 
        else:
8025 
          iprot.skip(ftype)
8026 
      elif fid == 2:
8027 
        if ftype == TType.I64:
8028 
          self.endDate = iprot.readI64();
8029 
        else:
8030 
          iprot.skip(ftype)
8031 
      else:
8032 
        iprot.skip(ftype)
8033 
      iprot.readFieldEnd()
8034 
    iprot.readStructEnd()
8035 
 
8036 
  def write(self, oprot):
8037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8039 
      return
8040 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_args')
8041 
    if self.startDate is not None:
8042 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
8043 
      oprot.writeI64(self.startDate)
8044 
      oprot.writeFieldEnd()
8045 
    if self.endDate is not None:
8046 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
8047 
      oprot.writeI64(self.endDate)
8048 
      oprot.writeFieldEnd()
8049 
    oprot.writeFieldStop()
8050 
    oprot.writeStructEnd()
8051 
 
8052 
  def validate(self):
8053 
    return
8054 
 
8055 
 
8056 
  def __repr__(self):
8057 
    L = ['%s=%r' % (key, value)
8058 
      for key, value in self.__dict__.iteritems()]
8059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8060 
 
8061 
  def __eq__(self, other):
8062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8063 
 
8064 
  def __ne__(self, other):
8065 
    return not (self == other)
8066 
 
8067 
class getMovementSerializedInventoryByScans_result:
8068 
  """
8069 
  Attributes:
8070 
   - success
8071 
  """
8072 
 
8073 
  thrift_spec = (
8074 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
8075 
  )
8076 
 
8077 
  def __init__(self, success=None,):
8078 
    self.success = success
8079 
 
8080 
  def read(self, iprot):
8081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8083 
      return
8084 
    iprot.readStructBegin()
8085 
    while True:
8086 
      (fname, ftype, fid) = iprot.readFieldBegin()
8087 
      if ftype == TType.STOP:
8088 
        break
8089 
      if fid == 0:
8090 
        if ftype == TType.LIST:
8091 
          self.success = []
10407 amar.kumar 8092 
          (_etype136, _size133) = iprot.readListBegin()
8093 
          for _i137 in xrange(_size133):
8094 
            _elem138 = InventoryMovement()
8095 
            _elem138.read(iprot)
8096 
            self.success.append(_elem138)
6880 amar.kumar 8097 
          iprot.readListEnd()
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      else:
8101 
        iprot.skip(ftype)
8102 
      iprot.readFieldEnd()
8103 
    iprot.readStructEnd()
8104 
 
8105 
  def write(self, oprot):
8106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8108 
      return
8109 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_result')
8110 
    if self.success is not None:
8111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8112 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 8113 
      for iter139 in self.success:
8114 
        iter139.write(oprot)
6880 amar.kumar 8115 
      oprot.writeListEnd()
8116 
      oprot.writeFieldEnd()
8117 
    oprot.writeFieldStop()
8118 
    oprot.writeStructEnd()
8119 
 
8120 
  def validate(self):
8121 
    return
8122 
 
8123 
 
8124 
  def __repr__(self):
8125 
    L = ['%s=%r' % (key, value)
8126 
      for key, value in self.__dict__.iteritems()]
8127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8128 
 
8129 
  def __eq__(self, other):
8130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8131 
 
8132 
  def __ne__(self, other):
8133 
    return not (self == other)
7190 amar.kumar 8134 
 
7216 amar.kumar 8135 
class getCompleteMovementSerializedInventoryByScans_args:
8136 
  """
8137 
  Attributes:
8138 
   - startDate
8139 
   - endDate
8140 
  """
8141 
 
8142 
  thrift_spec = (
8143 
    None, # 0
8144 
    (1, TType.I64, 'startDate', None, None, ), # 1
8145 
    (2, TType.I64, 'endDate', None, None, ), # 2
8146 
  )
8147 
 
8148 
  def __init__(self, startDate=None, endDate=None,):
8149 
    self.startDate = startDate
8150 
    self.endDate = endDate
8151 
 
8152 
  def read(self, iprot):
8153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8155 
      return
8156 
    iprot.readStructBegin()
8157 
    while True:
8158 
      (fname, ftype, fid) = iprot.readFieldBegin()
8159 
      if ftype == TType.STOP:
8160 
        break
8161 
      if fid == 1:
8162 
        if ftype == TType.I64:
8163 
          self.startDate = iprot.readI64();
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      elif fid == 2:
8167 
        if ftype == TType.I64:
8168 
          self.endDate = iprot.readI64();
8169 
        else:
8170 
          iprot.skip(ftype)
8171 
      else:
8172 
        iprot.skip(ftype)
8173 
      iprot.readFieldEnd()
8174 
    iprot.readStructEnd()
8175 
 
8176 
  def write(self, oprot):
8177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8179 
      return
8180 
    oprot.writeStructBegin('getCompleteMovementSerializedInventoryByScans_args')
8181 
    if self.startDate is not None:
8182 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
8183 
      oprot.writeI64(self.startDate)
8184 
      oprot.writeFieldEnd()
8185 
    if self.endDate is not None:
8186 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
8187 
      oprot.writeI64(self.endDate)
8188 
      oprot.writeFieldEnd()
8189 
    oprot.writeFieldStop()
8190 
    oprot.writeStructEnd()
8191 
 
8192 
  def validate(self):
8193 
    return
8194 
 
8195 
 
8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
8207 
class getCompleteMovementSerializedInventoryByScans_result:
8208 
  """
8209 
  Attributes:
8210 
   - success
8211 
  """
8212 
 
8213 
  thrift_spec = (
8214 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
8215 
  )
8216 
 
8217 
  def __init__(self, success=None,):
8218 
    self.success = success
8219 
 
8220 
  def read(self, iprot):
8221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8223 
      return
8224 
    iprot.readStructBegin()
8225 
    while True:
8226 
      (fname, ftype, fid) = iprot.readFieldBegin()
8227 
      if ftype == TType.STOP:
8228 
        break
8229 
      if fid == 0:
8230 
        if ftype == TType.LIST:
8231 
          self.success = []
10407 amar.kumar 8232 
          (_etype143, _size140) = iprot.readListBegin()
8233 
          for _i144 in xrange(_size140):
8234 
            _elem145 = InventoryMovement()
8235 
            _elem145.read(iprot)
8236 
            self.success.append(_elem145)
7216 amar.kumar 8237 
          iprot.readListEnd()
8238 
        else:
8239 
          iprot.skip(ftype)
8240 
      else:
8241 
        iprot.skip(ftype)
8242 
      iprot.readFieldEnd()
8243 
    iprot.readStructEnd()
8244 
 
8245 
  def write(self, oprot):
8246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8248 
      return
8249 
    oprot.writeStructBegin('getCompleteMovementSerializedInventoryByScans_result')
8250 
    if self.success is not None:
8251 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8252 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 8253 
      for iter146 in self.success:
8254 
        iter146.write(oprot)
7216 amar.kumar 8255 
      oprot.writeListEnd()
8256 
      oprot.writeFieldEnd()
8257 
    oprot.writeFieldStop()
8258 
    oprot.writeStructEnd()
8259 
 
8260 
  def validate(self):
8261 
    return
8262 
 
8263 
 
8264 
  def __repr__(self):
8265 
    L = ['%s=%r' % (key, value)
8266 
      for key, value in self.__dict__.iteritems()]
8267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8268 
 
8269 
  def __eq__(self, other):
8270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8271 
 
8272 
  def __ne__(self, other):
8273 
    return not (self == other)
8274 
 
8275 
class getCompleteMovementNonSerializedInventoryByScans_args:
8276 
  """
8277 
  Attributes:
8278 
   - startDate
8279 
   - endDate
8280 
  """
8281 
 
8282 
  thrift_spec = (
8283 
    None, # 0
8284 
    (1, TType.I64, 'startDate', None, None, ), # 1
8285 
    (2, TType.I64, 'endDate', None, None, ), # 2
8286 
  )
8287 
 
8288 
  def __init__(self, startDate=None, endDate=None,):
8289 
    self.startDate = startDate
8290 
    self.endDate = endDate
8291 
 
8292 
  def read(self, iprot):
8293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8295 
      return
8296 
    iprot.readStructBegin()
8297 
    while True:
8298 
      (fname, ftype, fid) = iprot.readFieldBegin()
8299 
      if ftype == TType.STOP:
8300 
        break
8301 
      if fid == 1:
8302 
        if ftype == TType.I64:
8303 
          self.startDate = iprot.readI64();
8304 
        else:
8305 
          iprot.skip(ftype)
8306 
      elif fid == 2:
8307 
        if ftype == TType.I64:
8308 
          self.endDate = iprot.readI64();
8309 
        else:
8310 
          iprot.skip(ftype)
8311 
      else:
8312 
        iprot.skip(ftype)
8313 
      iprot.readFieldEnd()
8314 
    iprot.readStructEnd()
8315 
 
8316 
  def write(self, oprot):
8317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8319 
      return
8320 
    oprot.writeStructBegin('getCompleteMovementNonSerializedInventoryByScans_args')
8321 
    if self.startDate is not None:
8322 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
8323 
      oprot.writeI64(self.startDate)
8324 
      oprot.writeFieldEnd()
8325 
    if self.endDate is not None:
8326 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
8327 
      oprot.writeI64(self.endDate)
8328 
      oprot.writeFieldEnd()
8329 
    oprot.writeFieldStop()
8330 
    oprot.writeStructEnd()
8331 
 
8332 
  def validate(self):
8333 
    return
8334 
 
8335 
 
8336 
  def __repr__(self):
8337 
    L = ['%s=%r' % (key, value)
8338 
      for key, value in self.__dict__.iteritems()]
8339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8340 
 
8341 
  def __eq__(self, other):
8342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8343 
 
8344 
  def __ne__(self, other):
8345 
    return not (self == other)
8346 
 
8347 
class getCompleteMovementNonSerializedInventoryByScans_result:
8348 
  """
8349 
  Attributes:
8350 
   - success
8351 
  """
8352 
 
8353 
  thrift_spec = (
8354 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
8355 
  )
8356 
 
8357 
  def __init__(self, success=None,):
8358 
    self.success = success
8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      if fid == 0:
8370 
        if ftype == TType.LIST:
8371 
          self.success = []
10407 amar.kumar 8372 
          (_etype150, _size147) = iprot.readListBegin()
8373 
          for _i151 in xrange(_size147):
8374 
            _elem152 = InventoryMovement()
8375 
            _elem152.read(iprot)
8376 
            self.success.append(_elem152)
7216 amar.kumar 8377 
          iprot.readListEnd()
8378 
        else:
8379 
          iprot.skip(ftype)
8380 
      else:
8381 
        iprot.skip(ftype)
8382 
      iprot.readFieldEnd()
8383 
    iprot.readStructEnd()
8384 
 
8385 
  def write(self, oprot):
8386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8388 
      return
8389 
    oprot.writeStructBegin('getCompleteMovementNonSerializedInventoryByScans_result')
8390 
    if self.success is not None:
8391 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8392 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 8393 
      for iter153 in self.success:
8394 
        iter153.write(oprot)
7216 amar.kumar 8395 
      oprot.writeListEnd()
8396 
      oprot.writeFieldEnd()
8397 
    oprot.writeFieldStop()
8398 
    oprot.writeStructEnd()
8399 
 
8400 
  def validate(self):
8401 
    return
8402 
 
8403 
 
8404 
  def __repr__(self):
8405 
    L = ['%s=%r' % (key, value)
8406 
      for key, value in self.__dict__.iteritems()]
8407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8408 
 
8409 
  def __eq__(self, other):
8410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8411 
 
8412 
  def __ne__(self, other):
8413 
    return not (self == other)
8414 
 
7190 amar.kumar 8415 
class scanfreebie_args:
8416 
  """
8417 
  Attributes:
8418 
   - orderId
8419 
   - freebieItemId
8420 
   - freebieWarehouseId
8421 
   - scanType
8422 
  """
8423 
 
8424 
  thrift_spec = (
8425 
    None, # 0
8426 
    (1, TType.I64, 'orderId', None, None, ), # 1
8427 
    (2, TType.I64, 'freebieItemId', None, None, ), # 2
8428 
    (3, TType.I64, 'freebieWarehouseId', None, None, ), # 3
8429 
    (4, TType.I32, 'scanType', None, None, ), # 4
8430 
  )
8431 
 
8432 
  def __init__(self, orderId=None, freebieItemId=None, freebieWarehouseId=None, scanType=None,):
8433 
    self.orderId = orderId
8434 
    self.freebieItemId = freebieItemId
8435 
    self.freebieWarehouseId = freebieWarehouseId
8436 
    self.scanType = scanType
8437 
 
8438 
  def read(self, iprot):
8439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8441 
      return
8442 
    iprot.readStructBegin()
8443 
    while True:
8444 
      (fname, ftype, fid) = iprot.readFieldBegin()
8445 
      if ftype == TType.STOP:
8446 
        break
8447 
      if fid == 1:
8448 
        if ftype == TType.I64:
8449 
          self.orderId = iprot.readI64();
8450 
        else:
8451 
          iprot.skip(ftype)
8452 
      elif fid == 2:
8453 
        if ftype == TType.I64:
8454 
          self.freebieItemId = iprot.readI64();
8455 
        else:
8456 
          iprot.skip(ftype)
8457 
      elif fid == 3:
8458 
        if ftype == TType.I64:
8459 
          self.freebieWarehouseId = iprot.readI64();
8460 
        else:
8461 
          iprot.skip(ftype)
8462 
      elif fid == 4:
8463 
        if ftype == TType.I32:
8464 
          self.scanType = iprot.readI32();
8465 
        else:
8466 
          iprot.skip(ftype)
8467 
      else:
8468 
        iprot.skip(ftype)
8469 
      iprot.readFieldEnd()
8470 
    iprot.readStructEnd()
8471 
 
8472 
  def write(self, oprot):
8473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8475 
      return
8476 
    oprot.writeStructBegin('scanfreebie_args')
8477 
    if self.orderId is not None:
8478 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8479 
      oprot.writeI64(self.orderId)
8480 
      oprot.writeFieldEnd()
8481 
    if self.freebieItemId is not None:
8482 
      oprot.writeFieldBegin('freebieItemId', TType.I64, 2)
8483 
      oprot.writeI64(self.freebieItemId)
8484 
      oprot.writeFieldEnd()
8485 
    if self.freebieWarehouseId is not None:
8486 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 3)
8487 
      oprot.writeI64(self.freebieWarehouseId)
8488 
      oprot.writeFieldEnd()
8489 
    if self.scanType is not None:
8490 
      oprot.writeFieldBegin('scanType', TType.I32, 4)
8491 
      oprot.writeI32(self.scanType)
8492 
      oprot.writeFieldEnd()
8493 
    oprot.writeFieldStop()
8494 
    oprot.writeStructEnd()
8495 
 
8496 
  def validate(self):
8497 
    return
8498 
 
8499 
 
8500 
  def __repr__(self):
8501 
    L = ['%s=%r' % (key, value)
8502 
      for key, value in self.__dict__.iteritems()]
8503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8504 
 
8505 
  def __eq__(self, other):
8506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8507 
 
8508 
  def __ne__(self, other):
8509 
    return not (self == other)
8510 
 
8511 
class scanfreebie_result:
8512 
  """
8513 
  Attributes:
8514 
   - success
8515 
   - wex
8516 
  """
8517 
 
8518 
  thrift_spec = (
8519 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
8520 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
8521 
  )
8522 
 
8523 
  def __init__(self, success=None, wex=None,):
8524 
    self.success = success
8525 
    self.wex = wex
8526 
 
8527 
  def read(self, iprot):
8528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8530 
      return
8531 
    iprot.readStructBegin()
8532 
    while True:
8533 
      (fname, ftype, fid) = iprot.readFieldBegin()
8534 
      if ftype == TType.STOP:
8535 
        break
8536 
      if fid == 0:
8537 
        if ftype == TType.STRUCT:
8538 
          self.success = InventoryItem()
8539 
          self.success.read(iprot)
8540 
        else:
8541 
          iprot.skip(ftype)
8542 
      elif fid == 1:
8543 
        if ftype == TType.STRUCT:
8544 
          self.wex = WarehouseServiceException()
8545 
          self.wex.read(iprot)
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      else:
8549 
        iprot.skip(ftype)
8550 
      iprot.readFieldEnd()
8551 
    iprot.readStructEnd()
8552 
 
8553 
  def write(self, oprot):
8554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8556 
      return
8557 
    oprot.writeStructBegin('scanfreebie_result')
8558 
    if self.success is not None:
8559 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8560 
      self.success.write(oprot)
8561 
      oprot.writeFieldEnd()
8562 
    if self.wex is not None:
8563 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
8564 
      self.wex.write(oprot)
8565 
      oprot.writeFieldEnd()
8566 
    oprot.writeFieldStop()
8567 
    oprot.writeStructEnd()
8568 
 
8569 
  def validate(self):
8570 
    return
8571 
 
8572 
 
8573 
  def __repr__(self):
8574 
    L = ['%s=%r' % (key, value)
8575 
      for key, value in self.__dict__.iteritems()]
8576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8577 
 
8578 
  def __eq__(self, other):
8579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8580 
 
8581 
  def __ne__(self, other):
8582 
    return not (self == other)
7199 amar.kumar 8583 
 
8584 
class reshipfreebie_args:
8585 
  """
8586 
  Attributes:
8587 
   - oldOrderId
8588 
   - newOrderId
8589 
   - freebieItemId
8590 
   - scanType
8591 
  """
8592 
 
8593 
  thrift_spec = (
8594 
    None, # 0
8595 
    (1, TType.I64, 'oldOrderId', None, None, ), # 1
8596 
    (2, TType.I64, 'newOrderId', None, None, ), # 2
8597 
    (3, TType.I64, 'freebieItemId', None, None, ), # 3
8598 
    (4, TType.I32, 'scanType', None, None, ), # 4
8599 
  )
8600 
 
8601 
  def __init__(self, oldOrderId=None, newOrderId=None, freebieItemId=None, scanType=None,):
8602 
    self.oldOrderId = oldOrderId
8603 
    self.newOrderId = newOrderId
8604 
    self.freebieItemId = freebieItemId
8605 
    self.scanType = scanType
8606 
 
8607 
  def read(self, iprot):
8608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8610 
      return
8611 
    iprot.readStructBegin()
8612 
    while True:
8613 
      (fname, ftype, fid) = iprot.readFieldBegin()
8614 
      if ftype == TType.STOP:
8615 
        break
8616 
      if fid == 1:
8617 
        if ftype == TType.I64:
8618 
          self.oldOrderId = iprot.readI64();
8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      elif fid == 2:
8622 
        if ftype == TType.I64:
8623 
          self.newOrderId = iprot.readI64();
8624 
        else:
8625 
          iprot.skip(ftype)
8626 
      elif fid == 3:
8627 
        if ftype == TType.I64:
8628 
          self.freebieItemId = iprot.readI64();
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      elif fid == 4:
8632 
        if ftype == TType.I32:
8633 
          self.scanType = iprot.readI32();
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      else:
8637 
        iprot.skip(ftype)
8638 
      iprot.readFieldEnd()
8639 
    iprot.readStructEnd()
8640 
 
8641 
  def write(self, oprot):
8642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8644 
      return
8645 
    oprot.writeStructBegin('reshipfreebie_args')
8646 
    if self.oldOrderId is not None:
8647 
      oprot.writeFieldBegin('oldOrderId', TType.I64, 1)
8648 
      oprot.writeI64(self.oldOrderId)
8649 
      oprot.writeFieldEnd()
8650 
    if self.newOrderId is not None:
8651 
      oprot.writeFieldBegin('newOrderId', TType.I64, 2)
8652 
      oprot.writeI64(self.newOrderId)
8653 
      oprot.writeFieldEnd()
8654 
    if self.freebieItemId is not None:
8655 
      oprot.writeFieldBegin('freebieItemId', TType.I64, 3)
8656 
      oprot.writeI64(self.freebieItemId)
8657 
      oprot.writeFieldEnd()
8658 
    if self.scanType is not None:
8659 
      oprot.writeFieldBegin('scanType', TType.I32, 4)
8660 
      oprot.writeI32(self.scanType)
8661 
      oprot.writeFieldEnd()
8662 
    oprot.writeFieldStop()
8663 
    oprot.writeStructEnd()
8664 
 
8665 
  def validate(self):
8666 
    return
8667 
 
8668 
 
8669 
  def __repr__(self):
8670 
    L = ['%s=%r' % (key, value)
8671 
      for key, value in self.__dict__.iteritems()]
8672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8673 
 
8674 
  def __eq__(self, other):
8675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8676 
 
8677 
  def __ne__(self, other):
8678 
    return not (self == other)
8679 
 
8680 
class reshipfreebie_result:
8681 
  """
8682 
  Attributes:
8683 
   - wex
8684 
  """
8685 
 
8686 
  thrift_spec = (
8687 
    None, # 0
8688 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
8689 
  )
8690 
 
8691 
  def __init__(self, wex=None,):
8692 
    self.wex = wex
8693 
 
8694 
  def read(self, iprot):
8695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8697 
      return
8698 
    iprot.readStructBegin()
8699 
    while True:
8700 
      (fname, ftype, fid) = iprot.readFieldBegin()
8701 
      if ftype == TType.STOP:
8702 
        break
8703 
      if fid == 1:
8704 
        if ftype == TType.STRUCT:
8705 
          self.wex = WarehouseServiceException()
8706 
          self.wex.read(iprot)
8707 
        else:
8708 
          iprot.skip(ftype)
8709 
      else:
8710 
        iprot.skip(ftype)
8711 
      iprot.readFieldEnd()
8712 
    iprot.readStructEnd()
8713 
 
8714 
  def write(self, oprot):
8715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8717 
      return
8718 
    oprot.writeStructBegin('reshipfreebie_result')
8719 
    if self.wex is not None:
8720 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
8721 
      self.wex.write(oprot)
8722 
      oprot.writeFieldEnd()
8723 
    oprot.writeFieldStop()
8724 
    oprot.writeStructEnd()
8725 
 
8726 
  def validate(self):
8727 
    return
8728 
 
8729 
 
8730 
  def __repr__(self):
8731 
    L = ['%s=%r' % (key, value)
8732 
      for key, value in self.__dict__.iteritems()]
8733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8734 
 
8735 
  def __eq__(self, other):
8736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8737 
 
8738 
  def __ne__(self, other):
8739 
    return not (self == other)
7410 amar.kumar 8740 
 
8741 
class isItemTransferAllowed_args:
8742 
  """
8743 
  Attributes:
8744 
   - warehouseId
8745 
   - transferWarehouseId
8746 
  """
8747 
 
8748 
  thrift_spec = (
8749 
    None, # 0
8750 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8751 
    (2, TType.I64, 'transferWarehouseId', None, None, ), # 2
8752 
  )
8753 
 
8754 
  def __init__(self, warehouseId=None, transferWarehouseId=None,):
8755 
    self.warehouseId = warehouseId
8756 
    self.transferWarehouseId = transferWarehouseId
8757 
 
8758 
  def read(self, iprot):
8759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8761 
      return
8762 
    iprot.readStructBegin()
8763 
    while True:
8764 
      (fname, ftype, fid) = iprot.readFieldBegin()
8765 
      if ftype == TType.STOP:
8766 
        break
8767 
      if fid == 1:
8768 
        if ftype == TType.I64:
8769 
          self.warehouseId = iprot.readI64();
8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      elif fid == 2:
8773 
        if ftype == TType.I64:
8774 
          self.transferWarehouseId = iprot.readI64();
8775 
        else:
8776 
          iprot.skip(ftype)
8777 
      else:
8778 
        iprot.skip(ftype)
8779 
      iprot.readFieldEnd()
8780 
    iprot.readStructEnd()
8781 
 
8782 
  def write(self, oprot):
8783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8785 
      return
8786 
    oprot.writeStructBegin('isItemTransferAllowed_args')
8787 
    if self.warehouseId is not None:
8788 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8789 
      oprot.writeI64(self.warehouseId)
8790 
      oprot.writeFieldEnd()
8791 
    if self.transferWarehouseId is not None:
8792 
      oprot.writeFieldBegin('transferWarehouseId', TType.I64, 2)
8793 
      oprot.writeI64(self.transferWarehouseId)
8794 
      oprot.writeFieldEnd()
8795 
    oprot.writeFieldStop()
8796 
    oprot.writeStructEnd()
8797 
 
8798 
  def validate(self):
8799 
    return
8800 
 
8801 
 
8802 
  def __repr__(self):
8803 
    L = ['%s=%r' % (key, value)
8804 
      for key, value in self.__dict__.iteritems()]
8805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8806 
 
8807 
  def __eq__(self, other):
8808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8809 
 
8810 
  def __ne__(self, other):
8811 
    return not (self == other)
8812 
 
8813 
class isItemTransferAllowed_result:
8814 
  """
8815 
  Attributes:
8816 
   - success
8817 
  """
8818 
 
8819 
  thrift_spec = (
8820 
    (0, TType.BOOL, 'success', None, None, ), # 0
8821 
  )
8822 
 
8823 
  def __init__(self, success=None,):
8824 
    self.success = success
8825 
 
8826 
  def read(self, iprot):
8827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8829 
      return
8830 
    iprot.readStructBegin()
8831 
    while True:
8832 
      (fname, ftype, fid) = iprot.readFieldBegin()
8833 
      if ftype == TType.STOP:
8834 
        break
8835 
      if fid == 0:
8836 
        if ftype == TType.BOOL:
8837 
          self.success = iprot.readBool();
8838 
        else:
8839 
          iprot.skip(ftype)
8840 
      else:
8841 
        iprot.skip(ftype)
8842 
      iprot.readFieldEnd()
8843 
    iprot.readStructEnd()
8844 
 
8845 
  def write(self, oprot):
8846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8848 
      return
8849 
    oprot.writeStructBegin('isItemTransferAllowed_result')
8850 
    if self.success is not None:
8851 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8852 
      oprot.writeBool(self.success)
8853 
      oprot.writeFieldEnd()
8854 
    oprot.writeFieldStop()
8855 
    oprot.writeStructEnd()
8856 
 
8857 
  def validate(self):
8858 
    return
8859 
 
8860 
 
8861 
  def __repr__(self):
8862 
    L = ['%s=%r' % (key, value)
8863 
      for key, value in self.__dict__.iteritems()]
8864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8865 
 
8866 
  def __eq__(self, other):
8867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8868 
 
8869 
  def __ne__(self, other):
8870 
    return not (self == other)
8871 
 
8872 
class createTransferLot_args:
8873 
  """
8874 
  Attributes:
8875 
   - originWarehouseId
8876 
   - destWarehouseId
8877 
  """
8878 
 
8879 
  thrift_spec = (
8880 
    None, # 0
8881 
    (1, TType.I64, 'originWarehouseId', None, None, ), # 1
8882 
    (2, TType.I64, 'destWarehouseId', None, None, ), # 2
8883 
  )
8884 
 
8885 
  def __init__(self, originWarehouseId=None, destWarehouseId=None,):
8886 
    self.originWarehouseId = originWarehouseId
8887 
    self.destWarehouseId = destWarehouseId
8888 
 
8889 
  def read(self, iprot):
8890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8892 
      return
8893 
    iprot.readStructBegin()
8894 
    while True:
8895 
      (fname, ftype, fid) = iprot.readFieldBegin()
8896 
      if ftype == TType.STOP:
8897 
        break
8898 
      if fid == 1:
8899 
        if ftype == TType.I64:
8900 
          self.originWarehouseId = iprot.readI64();
8901 
        else:
8902 
          iprot.skip(ftype)
8903 
      elif fid == 2:
8904 
        if ftype == TType.I64:
8905 
          self.destWarehouseId = iprot.readI64();
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
8917 
    oprot.writeStructBegin('createTransferLot_args')
8918 
    if self.originWarehouseId is not None:
8919 
      oprot.writeFieldBegin('originWarehouseId', TType.I64, 1)
8920 
      oprot.writeI64(self.originWarehouseId)
8921 
      oprot.writeFieldEnd()
8922 
    if self.destWarehouseId is not None:
8923 
      oprot.writeFieldBegin('destWarehouseId', TType.I64, 2)
8924 
      oprot.writeI64(self.destWarehouseId)
8925 
      oprot.writeFieldEnd()
8926 
    oprot.writeFieldStop()
8927 
    oprot.writeStructEnd()
8928 
 
8929 
  def validate(self):
8930 
    return
8931 
 
8932 
 
8933 
  def __repr__(self):
8934 
    L = ['%s=%r' % (key, value)
8935 
      for key, value in self.__dict__.iteritems()]
8936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8937 
 
8938 
  def __eq__(self, other):
8939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8940 
 
8941 
  def __ne__(self, other):
8942 
    return not (self == other)
8943 
 
8944 
class createTransferLot_result:
8945 
  """
8946 
  Attributes:
8947 
   - success
8948 
   - wex
8949 
  """
8950 
 
8951 
  thrift_spec = (
8952 
    (0, TType.I64, 'success', None, None, ), # 0
8953 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
8954 
  )
8955 
 
8956 
  def __init__(self, success=None, wex=None,):
8957 
    self.success = success
8958 
    self.wex = wex
8959 
 
8960 
  def read(self, iprot):
8961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8963 
      return
8964 
    iprot.readStructBegin()
8965 
    while True:
8966 
      (fname, ftype, fid) = iprot.readFieldBegin()
8967 
      if ftype == TType.STOP:
8968 
        break
8969 
      if fid == 0:
8970 
        if ftype == TType.I64:
8971 
          self.success = iprot.readI64();
8972 
        else:
8973 
          iprot.skip(ftype)
8974 
      elif fid == 1:
8975 
        if ftype == TType.STRUCT:
8976 
          self.wex = WarehouseServiceException()
8977 
          self.wex.read(iprot)
8978 
        else:
8979 
          iprot.skip(ftype)
8980 
      else:
8981 
        iprot.skip(ftype)
8982 
      iprot.readFieldEnd()
8983 
    iprot.readStructEnd()
8984 
 
8985 
  def write(self, oprot):
8986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8988 
      return
8989 
    oprot.writeStructBegin('createTransferLot_result')
8990 
    if self.success is not None:
8991 
      oprot.writeFieldBegin('success', TType.I64, 0)
8992 
      oprot.writeI64(self.success)
8993 
      oprot.writeFieldEnd()
8994 
    if self.wex is not None:
8995 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
8996 
      self.wex.write(oprot)
8997 
      oprot.writeFieldEnd()
8998 
    oprot.writeFieldStop()
8999 
    oprot.writeStructEnd()
9000 
 
9001 
  def validate(self):
9002 
    return
9003 
 
9004 
 
9005 
  def __repr__(self):
9006 
    L = ['%s=%r' % (key, value)
9007 
      for key, value in self.__dict__.iteritems()]
9008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9009 
 
9010 
  def __eq__(self, other):
9011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9012 
 
9013 
  def __ne__(self, other):
9014 
    return not (self == other)
9015 
 
9016 
class getTransferLot_args:
9017 
  """
9018 
  Attributes:
9019 
   - transferLotId
9020 
  """
9021 
 
9022 
  thrift_spec = (
9023 
    None, # 0
9024 
    (1, TType.I64, 'transferLotId', None, None, ), # 1
9025 
  )
9026 
 
9027 
  def __init__(self, transferLotId=None,):
9028 
    self.transferLotId = transferLotId
9029 
 
9030 
  def read(self, iprot):
9031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9033 
      return
9034 
    iprot.readStructBegin()
9035 
    while True:
9036 
      (fname, ftype, fid) = iprot.readFieldBegin()
9037 
      if ftype == TType.STOP:
9038 
        break
9039 
      if fid == 1:
9040 
        if ftype == TType.I64:
9041 
          self.transferLotId = iprot.readI64();
9042 
        else:
9043 
          iprot.skip(ftype)
9044 
      else:
9045 
        iprot.skip(ftype)
9046 
      iprot.readFieldEnd()
9047 
    iprot.readStructEnd()
9048 
 
9049 
  def write(self, oprot):
9050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9052 
      return
9053 
    oprot.writeStructBegin('getTransferLot_args')
9054 
    if self.transferLotId is not None:
9055 
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
9056 
      oprot.writeI64(self.transferLotId)
9057 
      oprot.writeFieldEnd()
9058 
    oprot.writeFieldStop()
9059 
    oprot.writeStructEnd()
9060 
 
9061 
  def validate(self):
9062 
    return
9063 
 
9064 
 
9065 
  def __repr__(self):
9066 
    L = ['%s=%r' % (key, value)
9067 
      for key, value in self.__dict__.iteritems()]
9068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9069 
 
9070 
  def __eq__(self, other):
9071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9072 
 
9073 
  def __ne__(self, other):
9074 
    return not (self == other)
9075 
 
9076 
class getTransferLot_result:
9077 
  """
9078 
  Attributes:
9079 
   - success
9080 
   - wex
9081 
  """
9082 
 
9083 
  thrift_spec = (
9084 
    (0, TType.STRUCT, 'success', (TransferLot, TransferLot.thrift_spec), None, ), # 0
9085 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
9086 
  )
9087 
 
9088 
  def __init__(self, success=None, wex=None,):
9089 
    self.success = success
9090 
    self.wex = wex
9091 
 
9092 
  def read(self, iprot):
9093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9095 
      return
9096 
    iprot.readStructBegin()
9097 
    while True:
9098 
      (fname, ftype, fid) = iprot.readFieldBegin()
9099 
      if ftype == TType.STOP:
9100 
        break
9101 
      if fid == 0:
9102 
        if ftype == TType.STRUCT:
9103 
          self.success = TransferLot()
9104 
          self.success.read(iprot)
9105 
        else:
9106 
          iprot.skip(ftype)
9107 
      elif fid == 1:
9108 
        if ftype == TType.STRUCT:
9109 
          self.wex = WarehouseServiceException()
9110 
          self.wex.read(iprot)
9111 
        else:
9112 
          iprot.skip(ftype)
9113 
      else:
9114 
        iprot.skip(ftype)
9115 
      iprot.readFieldEnd()
9116 
    iprot.readStructEnd()
9117 
 
9118 
  def write(self, oprot):
9119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9121 
      return
9122 
    oprot.writeStructBegin('getTransferLot_result')
9123 
    if self.success is not None:
9124 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9125 
      self.success.write(oprot)
9126 
      oprot.writeFieldEnd()
9127 
    if self.wex is not None:
9128 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
9129 
      self.wex.write(oprot)
9130 
      oprot.writeFieldEnd()
9131 
    oprot.writeFieldStop()
9132 
    oprot.writeStructEnd()
9133 
 
9134 
  def validate(self):
9135 
    return
9136 
 
9137 
 
9138 
  def __repr__(self):
9139 
    L = ['%s=%r' % (key, value)
9140 
      for key, value in self.__dict__.iteritems()]
9141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9142 
 
9143 
  def __eq__(self, other):
9144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9145 
 
9146 
  def __ne__(self, other):
9147 
    return not (self == other)
9148 
 
9149 
class markTransferLotAsReceived_args:
9150 
  """
9151 
  Attributes:
9152 
   - id
9153 
   - remoteTransferRefNumber
9154 
  """
9155 
 
9156 
  thrift_spec = (
9157 
    None, # 0
9158 
    (1, TType.I64, 'id', None, None, ), # 1
9159 
    (2, TType.STRING, 'remoteTransferRefNumber', None, None, ), # 2
9160 
  )
9161 
 
9162 
  def __init__(self, id=None, remoteTransferRefNumber=None,):
9163 
    self.id = id
9164 
    self.remoteTransferRefNumber = remoteTransferRefNumber
9165 
 
9166 
  def read(self, iprot):
9167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9169 
      return
9170 
    iprot.readStructBegin()
9171 
    while True:
9172 
      (fname, ftype, fid) = iprot.readFieldBegin()
9173 
      if ftype == TType.STOP:
9174 
        break
9175 
      if fid == 1:
9176 
        if ftype == TType.I64:
9177 
          self.id = iprot.readI64();
9178 
        else:
9179 
          iprot.skip(ftype)
9180 
      elif fid == 2:
9181 
        if ftype == TType.STRING:
9182 
          self.remoteTransferRefNumber = iprot.readString();
9183 
        else:
9184 
          iprot.skip(ftype)
9185 
      else:
9186 
        iprot.skip(ftype)
9187 
      iprot.readFieldEnd()
9188 
    iprot.readStructEnd()
9189 
 
9190 
  def write(self, oprot):
9191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9193 
      return
9194 
    oprot.writeStructBegin('markTransferLotAsReceived_args')
9195 
    if self.id is not None:
9196 
      oprot.writeFieldBegin('id', TType.I64, 1)
9197 
      oprot.writeI64(self.id)
9198 
      oprot.writeFieldEnd()
9199 
    if self.remoteTransferRefNumber is not None:
9200 
      oprot.writeFieldBegin('remoteTransferRefNumber', TType.STRING, 2)
9201 
      oprot.writeString(self.remoteTransferRefNumber)
9202 
      oprot.writeFieldEnd()
9203 
    oprot.writeFieldStop()
9204 
    oprot.writeStructEnd()
9205 
 
9206 
  def validate(self):
9207 
    return
9208 
 
9209 
 
9210 
  def __repr__(self):
9211 
    L = ['%s=%r' % (key, value)
9212 
      for key, value in self.__dict__.iteritems()]
9213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9214 
 
9215 
  def __eq__(self, other):
9216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9217 
 
9218 
  def __ne__(self, other):
9219 
    return not (self == other)
9220 
 
9221 
class markTransferLotAsReceived_result:
9222 
  """
9223 
  Attributes:
9224 
   - wex
9225 
  """
9226 
 
9227 
  thrift_spec = (
9228 
    None, # 0
9229 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
9230 
  )
9231 
 
9232 
  def __init__(self, wex=None,):
9233 
    self.wex = wex
9234 
 
9235 
  def read(self, iprot):
9236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9238 
      return
9239 
    iprot.readStructBegin()
9240 
    while True:
9241 
      (fname, ftype, fid) = iprot.readFieldBegin()
9242 
      if ftype == TType.STOP:
9243 
        break
9244 
      if fid == 1:
9245 
        if ftype == TType.STRUCT:
9246 
          self.wex = WarehouseServiceException()
9247 
          self.wex.read(iprot)
9248 
        else:
9249 
          iprot.skip(ftype)
9250 
      else:
9251 
        iprot.skip(ftype)
9252 
      iprot.readFieldEnd()
9253 
    iprot.readStructEnd()
9254 
 
9255 
  def write(self, oprot):
9256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9258 
      return
9259 
    oprot.writeStructBegin('markTransferLotAsReceived_result')
9260 
    if self.wex is not None:
9261 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
9262 
      self.wex.write(oprot)
9263 
      oprot.writeFieldEnd()
9264 
    oprot.writeFieldStop()
9265 
    oprot.writeStructEnd()
9266 
 
9267 
  def validate(self):
9268 
    return
9269 
 
9270 
 
9271 
  def __repr__(self):
9272 
    L = ['%s=%r' % (key, value)
9273 
      for key, value in self.__dict__.iteritems()]
9274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9275 
 
9276 
  def __eq__(self, other):
9277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9278 
 
9279 
  def __ne__(self, other):
9280 
    return not (self == other)
9281 
 
9282 
class getTransferLotsByDate_args:
9283 
  """
9284 
  Attributes:
9285 
   - fromDate
9286 
   - toDate
9287 
  """
9288 
 
9289 
  thrift_spec = (
9290 
    None, # 0
9291 
    (1, TType.I64, 'fromDate', None, None, ), # 1
9292 
    (2, TType.I64, 'toDate', None, None, ), # 2
9293 
  )
9294 
 
9295 
  def __init__(self, fromDate=None, toDate=None,):
9296 
    self.fromDate = fromDate
9297 
    self.toDate = toDate
9298 
 
9299 
  def read(self, iprot):
9300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9302 
      return
9303 
    iprot.readStructBegin()
9304 
    while True:
9305 
      (fname, ftype, fid) = iprot.readFieldBegin()
9306 
      if ftype == TType.STOP:
9307 
        break
9308 
      if fid == 1:
9309 
        if ftype == TType.I64:
9310 
          self.fromDate = iprot.readI64();
9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      elif fid == 2:
9314 
        if ftype == TType.I64:
9315 
          self.toDate = iprot.readI64();
9316 
        else:
9317 
          iprot.skip(ftype)
9318 
      else:
9319 
        iprot.skip(ftype)
9320 
      iprot.readFieldEnd()
9321 
    iprot.readStructEnd()
9322 
 
9323 
  def write(self, oprot):
9324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9326 
      return
9327 
    oprot.writeStructBegin('getTransferLotsByDate_args')
9328 
    if self.fromDate is not None:
9329 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
9330 
      oprot.writeI64(self.fromDate)
9331 
      oprot.writeFieldEnd()
9332 
    if self.toDate is not None:
9333 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
9334 
      oprot.writeI64(self.toDate)
9335 
      oprot.writeFieldEnd()
9336 
    oprot.writeFieldStop()
9337 
    oprot.writeStructEnd()
9338 
 
9339 
  def validate(self):
9340 
    return
9341 
 
9342 
 
9343 
  def __repr__(self):
9344 
    L = ['%s=%r' % (key, value)
9345 
      for key, value in self.__dict__.iteritems()]
9346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9347 
 
9348 
  def __eq__(self, other):
9349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9350 
 
9351 
  def __ne__(self, other):
9352 
    return not (self == other)
9353 
 
9354 
class getTransferLotsByDate_result:
9355 
  """
9356 
  Attributes:
9357 
   - success
9358 
   - wex
9359 
  """
9360 
 
9361 
  thrift_spec = (
9362 
    (0, TType.LIST, 'success', (TType.STRUCT,(TransferLot, TransferLot.thrift_spec)), None, ), # 0
9363 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
9364 
  )
9365 
 
9366 
  def __init__(self, success=None, wex=None,):
9367 
    self.success = success
9368 
    self.wex = wex
9369 
 
9370 
  def read(self, iprot):
9371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9373 
      return
9374 
    iprot.readStructBegin()
9375 
    while True:
9376 
      (fname, ftype, fid) = iprot.readFieldBegin()
9377 
      if ftype == TType.STOP:
9378 
        break
9379 
      if fid == 0:
9380 
        if ftype == TType.LIST:
9381 
          self.success = []
10407 amar.kumar 9382 
          (_etype157, _size154) = iprot.readListBegin()
9383 
          for _i158 in xrange(_size154):
9384 
            _elem159 = TransferLot()
9385 
            _elem159.read(iprot)
9386 
            self.success.append(_elem159)
7410 amar.kumar 9387 
          iprot.readListEnd()
9388 
        else:
9389 
          iprot.skip(ftype)
9390 
      elif fid == 1:
9391 
        if ftype == TType.STRUCT:
9392 
          self.wex = WarehouseServiceException()
9393 
          self.wex.read(iprot)
9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      else:
9397 
        iprot.skip(ftype)
9398 
      iprot.readFieldEnd()
9399 
    iprot.readStructEnd()
9400 
 
9401 
  def write(self, oprot):
9402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9404 
      return
9405 
    oprot.writeStructBegin('getTransferLotsByDate_result')
9406 
    if self.success is not None:
9407 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9408 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 9409 
      for iter160 in self.success:
9410 
        iter160.write(oprot)
7410 amar.kumar 9411 
      oprot.writeListEnd()
9412 
      oprot.writeFieldEnd()
9413 
    if self.wex is not None:
9414 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
9415 
      self.wex.write(oprot)
9416 
      oprot.writeFieldEnd()
9417 
    oprot.writeFieldStop()
9418 
    oprot.writeStructEnd()
9419 
 
9420 
  def validate(self):
9421 
    return
9422 
 
9423 
 
9424 
  def __repr__(self):
9425 
    L = ['%s=%r' % (key, value)
9426 
      for key, value in self.__dict__.iteritems()]
9427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9428 
 
9429 
  def __eq__(self, other):
9430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9431 
 
9432 
  def __ne__(self, other):
9433 
    return not (self == other)
9434 
 
9435 
class getAllowedDestinationWarehousesForTransfer_args:
9436 
  """
9437 
  Attributes:
9438 
   - warehouseId
9439 
  """
9440 
 
9441 
  thrift_spec = (
9442 
    None, # 0
9443 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
9444 
  )
9445 
 
9446 
  def __init__(self, warehouseId=None,):
9447 
    self.warehouseId = warehouseId
9448 
 
9449 
  def read(self, iprot):
9450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9452 
      return
9453 
    iprot.readStructBegin()
9454 
    while True:
9455 
      (fname, ftype, fid) = iprot.readFieldBegin()
9456 
      if ftype == TType.STOP:
9457 
        break
9458 
      if fid == 1:
9459 
        if ftype == TType.I64:
9460 
          self.warehouseId = iprot.readI64();
9461 
        else:
9462 
          iprot.skip(ftype)
9463 
      else:
9464 
        iprot.skip(ftype)
9465 
      iprot.readFieldEnd()
9466 
    iprot.readStructEnd()
9467 
 
9468 
  def write(self, oprot):
9469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9471 
      return
9472 
    oprot.writeStructBegin('getAllowedDestinationWarehousesForTransfer_args')
9473 
    if self.warehouseId is not None:
9474 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
9475 
      oprot.writeI64(self.warehouseId)
9476 
      oprot.writeFieldEnd()
9477 
    oprot.writeFieldStop()
9478 
    oprot.writeStructEnd()
9479 
 
9480 
  def validate(self):
9481 
    return
9482 
 
9483 
 
9484 
  def __repr__(self):
9485 
    L = ['%s=%r' % (key, value)
9486 
      for key, value in self.__dict__.iteritems()]
9487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9488 
 
9489 
  def __eq__(self, other):
9490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9491 
 
9492 
  def __ne__(self, other):
9493 
    return not (self == other)
9494 
 
9495 
class getAllowedDestinationWarehousesForTransfer_result:
9496 
  """
9497 
  Attributes:
9498 
   - success
9499 
  """
9500 
 
9501 
  thrift_spec = (
9502 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
9503 
  )
9504 
 
9505 
  def __init__(self, success=None,):
9506 
    self.success = success
9507 
 
9508 
  def read(self, iprot):
9509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9511 
      return
9512 
    iprot.readStructBegin()
9513 
    while True:
9514 
      (fname, ftype, fid) = iprot.readFieldBegin()
9515 
      if ftype == TType.STOP:
9516 
        break
9517 
      if fid == 0:
9518 
        if ftype == TType.LIST:
9519 
          self.success = []
10407 amar.kumar 9520 
          (_etype164, _size161) = iprot.readListBegin()
9521 
          for _i165 in xrange(_size161):
9522 
            _elem166 = iprot.readI64();
9523 
            self.success.append(_elem166)
7410 amar.kumar 9524 
          iprot.readListEnd()
9525 
        else:
9526 
          iprot.skip(ftype)
9527 
      else:
9528 
        iprot.skip(ftype)
9529 
      iprot.readFieldEnd()
9530 
    iprot.readStructEnd()
9531 
 
9532 
  def write(self, oprot):
9533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9535 
      return
9536 
    oprot.writeStructBegin('getAllowedDestinationWarehousesForTransfer_result')
9537 
    if self.success is not None:
9538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9539 
      oprot.writeListBegin(TType.I64, len(self.success))
10407 amar.kumar 9540 
      for iter167 in self.success:
9541 
        oprot.writeI64(iter167)
7410 amar.kumar 9542 
      oprot.writeListEnd()
9543 
      oprot.writeFieldEnd()
9544 
    oprot.writeFieldStop()
9545 
    oprot.writeStructEnd()
9546 
 
9547 
  def validate(self):
9548 
    return
9549 
 
9550 
 
9551 
  def __repr__(self):
9552 
    L = ['%s=%r' % (key, value)
9553 
      for key, value in self.__dict__.iteritems()]
9554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9555 
 
9556 
  def __eq__(self, other):
9557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9558 
 
9559 
  def __ne__(self, other):
9560 
    return not (self == other)
9561 
 
9562 
class getItemsInTransferLot_args:
9563 
  """
9564 
  Attributes:
9565 
   - transferLotId
9566 
  """
9567 
 
9568 
  thrift_spec = (
9569 
    None, # 0
9570 
    (1, TType.I64, 'transferLotId', None, None, ), # 1
9571 
  )
9572 
 
9573 
  def __init__(self, transferLotId=None,):
9574 
    self.transferLotId = transferLotId
9575 
 
9576 
  def read(self, iprot):
9577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9579 
      return
9580 
    iprot.readStructBegin()
9581 
    while True:
9582 
      (fname, ftype, fid) = iprot.readFieldBegin()
9583 
      if ftype == TType.STOP:
9584 
        break
9585 
      if fid == 1:
9586 
        if ftype == TType.I64:
9587 
          self.transferLotId = iprot.readI64();
9588 
        else:
9589 
          iprot.skip(ftype)
9590 
      else:
9591 
        iprot.skip(ftype)
9592 
      iprot.readFieldEnd()
9593 
    iprot.readStructEnd()
9594 
 
9595 
  def write(self, oprot):
9596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9598 
      return
9599 
    oprot.writeStructBegin('getItemsInTransferLot_args')
9600 
    if self.transferLotId is not None:
9601 
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
9602 
      oprot.writeI64(self.transferLotId)
9603 
      oprot.writeFieldEnd()
9604 
    oprot.writeFieldStop()
9605 
    oprot.writeStructEnd()
9606 
 
9607 
  def validate(self):
9608 
    return
9609 
 
9610 
 
9611 
  def __repr__(self):
9612 
    L = ['%s=%r' % (key, value)
9613 
      for key, value in self.__dict__.iteritems()]
9614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9615 
 
9616 
  def __eq__(self, other):
9617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9618 
 
9619 
  def __ne__(self, other):
9620 
    return not (self == other)
9621 
 
9622 
class getItemsInTransferLot_result:
9623 
  """
9624 
  Attributes:
9625 
   - success
9626 
  """
9627 
 
9628 
  thrift_spec = (
9629 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
9630 
  )
9631 
 
9632 
  def __init__(self, success=None,):
9633 
    self.success = success
9634 
 
9635 
  def read(self, iprot):
9636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9638 
      return
9639 
    iprot.readStructBegin()
9640 
    while True:
9641 
      (fname, ftype, fid) = iprot.readFieldBegin()
9642 
      if ftype == TType.STOP:
9643 
        break
9644 
      if fid == 0:
9645 
        if ftype == TType.MAP:
9646 
          self.success = {}
10407 amar.kumar 9647 
          (_ktype169, _vtype170, _size168 ) = iprot.readMapBegin()
9648 
          for _i172 in xrange(_size168):
9649 
            _key173 = iprot.readI64();
9650 
            _val174 = iprot.readI64();
9651 
            self.success[_key173] = _val174
7410 amar.kumar 9652 
          iprot.readMapEnd()
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
9664 
    oprot.writeStructBegin('getItemsInTransferLot_result')
9665 
    if self.success is not None:
9666 
      oprot.writeFieldBegin('success', TType.MAP, 0)
9667 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
10407 amar.kumar 9668 
      for kiter175,viter176 in self.success.items():
9669 
        oprot.writeI64(kiter175)
9670 
        oprot.writeI64(viter176)
7410 amar.kumar 9671 
      oprot.writeMapEnd()
9672 
      oprot.writeFieldEnd()
9673 
    oprot.writeFieldStop()
9674 
    oprot.writeStructEnd()
9675 
 
9676 
  def validate(self):
9677 
    return
9678 
 
9679 
 
9680 
  def __repr__(self):
9681 
    L = ['%s=%r' % (key, value)
9682 
      for key, value in self.__dict__.iteritems()]
9683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9684 
 
9685 
  def __eq__(self, other):
9686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9687 
 
9688 
  def __ne__(self, other):
9689 
    return not (self == other)
9690 
 
9691 
class markItemsAsReceivedForTransferLot_args:
9692 
  """
9693 
  Attributes:
9694 
   - id
9695 
  """
9696 
 
9697 
  thrift_spec = (
9698 
    None, # 0
9699 
    (1, TType.I64, 'id', None, None, ), # 1
9700 
  )
9701 
 
9702 
  def __init__(self, id=None,):
9703 
    self.id = id
9704 
 
9705 
  def read(self, iprot):
9706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9708 
      return
9709 
    iprot.readStructBegin()
9710 
    while True:
9711 
      (fname, ftype, fid) = iprot.readFieldBegin()
9712 
      if ftype == TType.STOP:
9713 
        break
9714 
      if fid == 1:
9715 
        if ftype == TType.I64:
9716 
          self.id = iprot.readI64();
9717 
        else:
9718 
          iprot.skip(ftype)
9719 
      else:
9720 
        iprot.skip(ftype)
9721 
      iprot.readFieldEnd()
9722 
    iprot.readStructEnd()
9723 
 
9724 
  def write(self, oprot):
9725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9727 
      return
9728 
    oprot.writeStructBegin('markItemsAsReceivedForTransferLot_args')
9729 
    if self.id is not None:
9730 
      oprot.writeFieldBegin('id', TType.I64, 1)
9731 
      oprot.writeI64(self.id)
9732 
      oprot.writeFieldEnd()
9733 
    oprot.writeFieldStop()
9734 
    oprot.writeStructEnd()
9735 
 
9736 
  def validate(self):
9737 
    return
9738 
 
9739 
 
9740 
  def __repr__(self):
9741 
    L = ['%s=%r' % (key, value)
9742 
      for key, value in self.__dict__.iteritems()]
9743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9744 
 
9745 
  def __eq__(self, other):
9746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9747 
 
9748 
  def __ne__(self, other):
9749 
    return not (self == other)
9750 
 
9751 
class markItemsAsReceivedForTransferLot_result:
9752 
  """
9753 
  Attributes:
9754 
   - wex
9755 
  """
9756 
 
9757 
  thrift_spec = (
9758 
    None, # 0
9759 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
9760 
  )
9761 
 
9762 
  def __init__(self, wex=None,):
9763 
    self.wex = wex
9764 
 
9765 
  def read(self, iprot):
9766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9768 
      return
9769 
    iprot.readStructBegin()
9770 
    while True:
9771 
      (fname, ftype, fid) = iprot.readFieldBegin()
9772 
      if ftype == TType.STOP:
9773 
        break
9774 
      if fid == 1:
9775 
        if ftype == TType.STRUCT:
9776 
          self.wex = WarehouseServiceException()
9777 
          self.wex.read(iprot)
9778 
        else:
9779 
          iprot.skip(ftype)
9780 
      else:
9781 
        iprot.skip(ftype)
9782 
      iprot.readFieldEnd()
9783 
    iprot.readStructEnd()
9784 
 
9785 
  def write(self, oprot):
9786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9788 
      return
9789 
    oprot.writeStructBegin('markItemsAsReceivedForTransferLot_result')
9790 
    if self.wex is not None:
9791 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
9792 
      self.wex.write(oprot)
9793 
      oprot.writeFieldEnd()
9794 
    oprot.writeFieldStop()
9795 
    oprot.writeStructEnd()
9796 
 
9797 
  def validate(self):
9798 
    return
9799 
 
9800 
 
9801 
  def __repr__(self):
9802 
    L = ['%s=%r' % (key, value)
9803 
      for key, value in self.__dict__.iteritems()]
9804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9805 
 
9806 
  def __eq__(self, other):
9807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9808 
 
9809 
  def __ne__(self, other):
9810 
    return not (self == other)
9811 
 
9812 
class updateTransferLotAfterItemReceive_args:
9813 
  """
9814 
  Attributes:
9815 
   - id
9816 
  """
9817 
 
9818 
  thrift_spec = (
9819 
    None, # 0
9820 
    (1, TType.I64, 'id', None, None, ), # 1
9821 
  )
9822 
 
9823 
  def __init__(self, id=None,):
9824 
    self.id = id
9825 
 
9826 
  def read(self, iprot):
9827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9829 
      return
9830 
    iprot.readStructBegin()
9831 
    while True:
9832 
      (fname, ftype, fid) = iprot.readFieldBegin()
9833 
      if ftype == TType.STOP:
9834 
        break
9835 
      if fid == 1:
9836 
        if ftype == TType.I64:
9837 
          self.id = iprot.readI64();
9838 
        else:
9839 
          iprot.skip(ftype)
9840 
      else:
9841 
        iprot.skip(ftype)
9842 
      iprot.readFieldEnd()
9843 
    iprot.readStructEnd()
9844 
 
9845 
  def write(self, oprot):
9846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9848 
      return
9849 
    oprot.writeStructBegin('updateTransferLotAfterItemReceive_args')
9850 
    if self.id is not None:
9851 
      oprot.writeFieldBegin('id', TType.I64, 1)
9852 
      oprot.writeI64(self.id)
9853 
      oprot.writeFieldEnd()
9854 
    oprot.writeFieldStop()
9855 
    oprot.writeStructEnd()
9856 
 
9857 
  def validate(self):
9858 
    return
9859 
 
9860 
 
9861 
  def __repr__(self):
9862 
    L = ['%s=%r' % (key, value)
9863 
      for key, value in self.__dict__.iteritems()]
9864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9865 
 
9866 
  def __eq__(self, other):
9867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9868 
 
9869 
  def __ne__(self, other):
9870 
    return not (self == other)
9871 
 
9872 
class updateTransferLotAfterItemReceive_result:
9873 
  """
9874 
  Attributes:
9875 
   - success
9876 
   - wex
9877 
  """
9878 
 
9879 
  thrift_spec = (
9880 
    (0, TType.I32, 'success', None, None, ), # 0
9881 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
9882 
  )
9883 
 
9884 
  def __init__(self, success=None, wex=None,):
9885 
    self.success = success
9886 
    self.wex = wex
9887 
 
9888 
  def read(self, iprot):
9889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9891 
      return
9892 
    iprot.readStructBegin()
9893 
    while True:
9894 
      (fname, ftype, fid) = iprot.readFieldBegin()
9895 
      if ftype == TType.STOP:
9896 
        break
9897 
      if fid == 0:
9898 
        if ftype == TType.I32:
9899 
          self.success = iprot.readI32();
9900 
        else:
9901 
          iprot.skip(ftype)
9902 
      elif fid == 1:
9903 
        if ftype == TType.STRUCT:
9904 
          self.wex = WarehouseServiceException()
9905 
          self.wex.read(iprot)
9906 
        else:
9907 
          iprot.skip(ftype)
9908 
      else:
9909 
        iprot.skip(ftype)
9910 
      iprot.readFieldEnd()
9911 
    iprot.readStructEnd()
9912 
 
9913 
  def write(self, oprot):
9914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9916 
      return
9917 
    oprot.writeStructBegin('updateTransferLotAfterItemReceive_result')
9918 
    if self.success is not None:
9919 
      oprot.writeFieldBegin('success', TType.I32, 0)
9920 
      oprot.writeI32(self.success)
9921 
      oprot.writeFieldEnd()
9922 
    if self.wex is not None:
9923 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
9924 
      self.wex.write(oprot)
9925 
      oprot.writeFieldEnd()
9926 
    oprot.writeFieldStop()
9927 
    oprot.writeStructEnd()
9928 
 
9929 
  def validate(self):
9930 
    return
9931 
 
9932 
 
9933 
  def __repr__(self):
9934 
    L = ['%s=%r' % (key, value)
9935 
      for key, value in self.__dict__.iteritems()]
9936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9937 
 
9938 
  def __eq__(self, other):
9939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9940 
 
9941 
  def __ne__(self, other):
9942 
    return not (self == other)
9943 
 
7459 amar.kumar 9944 
class scanForTransferOut_args:
7410 amar.kumar 9945 
  """
9946 
  Attributes:
9947 
   - inventoryItems
9948 
   - type
9949 
   - transferLotId
9950 
  """
9951 
 
9952 
  thrift_spec = (
9953 
    None, # 0
9954 
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
9955 
    (2, TType.I32, 'type', None, None, ), # 2
9956 
    (3, TType.I64, 'transferLotId', None, None, ), # 3
9957 
  )
9958 
 
9959 
  def __init__(self, inventoryItems=None, type=None, transferLotId=None,):
9960 
    self.inventoryItems = inventoryItems
9961 
    self.type = type
9962 
    self.transferLotId = transferLotId
9963 
 
9964 
  def read(self, iprot):
9965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9967 
      return
9968 
    iprot.readStructBegin()
9969 
    while True:
9970 
      (fname, ftype, fid) = iprot.readFieldBegin()
9971 
      if ftype == TType.STOP:
9972 
        break
9973 
      if fid == 1:
9974 
        if ftype == TType.LIST:
9975 
          self.inventoryItems = []
10407 amar.kumar 9976 
          (_etype180, _size177) = iprot.readListBegin()
9977 
          for _i181 in xrange(_size177):
9978 
            _elem182 = InventoryItem()
9979 
            _elem182.read(iprot)
9980 
            self.inventoryItems.append(_elem182)
7410 amar.kumar 9981 
          iprot.readListEnd()
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      elif fid == 2:
9985 
        if ftype == TType.I32:
9986 
          self.type = iprot.readI32();
9987 
        else:
9988 
          iprot.skip(ftype)
9989 
      elif fid == 3:
9990 
        if ftype == TType.I64:
9991 
          self.transferLotId = iprot.readI64();
9992 
        else:
9993 
          iprot.skip(ftype)
9994 
      else:
9995 
        iprot.skip(ftype)
9996 
      iprot.readFieldEnd()
9997 
    iprot.readStructEnd()
9998 
 
9999 
  def write(self, oprot):
10000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10002 
      return
7459 amar.kumar 10003 
    oprot.writeStructBegin('scanForTransferOut_args')
7410 amar.kumar 10004 
    if self.inventoryItems is not None:
10005 
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
10006 
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
10407 amar.kumar 10007 
      for iter183 in self.inventoryItems:
10008 
        iter183.write(oprot)
7410 amar.kumar 10009 
      oprot.writeListEnd()
10010 
      oprot.writeFieldEnd()
10011 
    if self.type is not None:
10012 
      oprot.writeFieldBegin('type', TType.I32, 2)
10013 
      oprot.writeI32(self.type)
10014 
      oprot.writeFieldEnd()
10015 
    if self.transferLotId is not None:
10016 
      oprot.writeFieldBegin('transferLotId', TType.I64, 3)
10017 
      oprot.writeI64(self.transferLotId)
10018 
      oprot.writeFieldEnd()
10019 
    oprot.writeFieldStop()
10020 
    oprot.writeStructEnd()
10021 
 
10022 
  def validate(self):
10023 
    return
10024 
 
10025 
 
10026 
  def __repr__(self):
10027 
    L = ['%s=%r' % (key, value)
10028 
      for key, value in self.__dict__.iteritems()]
10029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10030 
 
10031 
  def __eq__(self, other):
10032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10033 
 
10034 
  def __ne__(self, other):
10035 
    return not (self == other)
10036 
 
7459 amar.kumar 10037 
class scanForTransferOut_result:
7410 amar.kumar 10038 
  """
10039 
  Attributes:
10040 
   - wex
10041 
  """
10042 
 
10043 
  thrift_spec = (
10044 
    None, # 0
10045 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10046 
  )
10047 
 
10048 
  def __init__(self, wex=None,):
10049 
    self.wex = wex
10050 
 
10051 
  def read(self, iprot):
10052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10054 
      return
10055 
    iprot.readStructBegin()
10056 
    while True:
10057 
      (fname, ftype, fid) = iprot.readFieldBegin()
10058 
      if ftype == TType.STOP:
10059 
        break
10060 
      if fid == 1:
10061 
        if ftype == TType.STRUCT:
10062 
          self.wex = WarehouseServiceException()
10063 
          self.wex.read(iprot)
10064 
        else:
10065 
          iprot.skip(ftype)
10066 
      else:
10067 
        iprot.skip(ftype)
10068 
      iprot.readFieldEnd()
10069 
    iprot.readStructEnd()
10070 
 
10071 
  def write(self, oprot):
10072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10074 
      return
7459 amar.kumar 10075 
    oprot.writeStructBegin('scanForTransferOut_result')
7410 amar.kumar 10076 
    if self.wex is not None:
10077 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10078 
      self.wex.write(oprot)
10079 
      oprot.writeFieldEnd()
10080 
    oprot.writeFieldStop()
10081 
    oprot.writeStructEnd()
10082 
 
10083 
  def validate(self):
10084 
    return
10085 
 
10086 
 
10087 
  def __repr__(self):
10088 
    L = ['%s=%r' % (key, value)
10089 
      for key, value in self.__dict__.iteritems()]
10090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10091 
 
10092 
  def __eq__(self, other):
10093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10094 
 
10095 
  def __ne__(self, other):
10096 
    return not (self == other)
7459 amar.kumar 10097 
 
10098 
class scanForTransferIn_args:
10099 
  """
10100 
  Attributes:
10101 
   - inventoryItems
10102 
   - type
10103 
   - transferLotId
10104 
  """
10105 
 
10106 
  thrift_spec = (
10107 
    None, # 0
10108 
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
10109 
    (2, TType.I32, 'type', None, None, ), # 2
10110 
    (3, TType.I64, 'transferLotId', None, None, ), # 3
10111 
  )
10112 
 
10113 
  def __init__(self, inventoryItems=None, type=None, transferLotId=None,):
10114 
    self.inventoryItems = inventoryItems
10115 
    self.type = type
10116 
    self.transferLotId = transferLotId
10117 
 
10118 
  def read(self, iprot):
10119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10121 
      return
10122 
    iprot.readStructBegin()
10123 
    while True:
10124 
      (fname, ftype, fid) = iprot.readFieldBegin()
10125 
      if ftype == TType.STOP:
10126 
        break
10127 
      if fid == 1:
10128 
        if ftype == TType.LIST:
10129 
          self.inventoryItems = []
10407 amar.kumar 10130 
          (_etype187, _size184) = iprot.readListBegin()
10131 
          for _i188 in xrange(_size184):
10132 
            _elem189 = InventoryItem()
10133 
            _elem189.read(iprot)
10134 
            self.inventoryItems.append(_elem189)
7459 amar.kumar 10135 
          iprot.readListEnd()
10136 
        else:
10137 
          iprot.skip(ftype)
10138 
      elif fid == 2:
10139 
        if ftype == TType.I32:
10140 
          self.type = iprot.readI32();
10141 
        else:
10142 
          iprot.skip(ftype)
10143 
      elif fid == 3:
10144 
        if ftype == TType.I64:
10145 
          self.transferLotId = iprot.readI64();
10146 
        else:
10147 
          iprot.skip(ftype)
10148 
      else:
10149 
        iprot.skip(ftype)
10150 
      iprot.readFieldEnd()
10151 
    iprot.readStructEnd()
10152 
 
10153 
  def write(self, oprot):
10154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10156 
      return
10157 
    oprot.writeStructBegin('scanForTransferIn_args')
10158 
    if self.inventoryItems is not None:
10159 
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
10160 
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
10407 amar.kumar 10161 
      for iter190 in self.inventoryItems:
10162 
        iter190.write(oprot)
7459 amar.kumar 10163 
      oprot.writeListEnd()
10164 
      oprot.writeFieldEnd()
10165 
    if self.type is not None:
10166 
      oprot.writeFieldBegin('type', TType.I32, 2)
10167 
      oprot.writeI32(self.type)
10168 
      oprot.writeFieldEnd()
10169 
    if self.transferLotId is not None:
10170 
      oprot.writeFieldBegin('transferLotId', TType.I64, 3)
10171 
      oprot.writeI64(self.transferLotId)
10172 
      oprot.writeFieldEnd()
10173 
    oprot.writeFieldStop()
10174 
    oprot.writeStructEnd()
10175 
 
10176 
  def validate(self):
10177 
    return
10178 
 
10179 
 
10180 
  def __repr__(self):
10181 
    L = ['%s=%r' % (key, value)
10182 
      for key, value in self.__dict__.iteritems()]
10183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10184 
 
10185 
  def __eq__(self, other):
10186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10187 
 
10188 
  def __ne__(self, other):
10189 
    return not (self == other)
10190 
 
10191 
class scanForTransferIn_result:
10192 
  """
10193 
  Attributes:
10194 
   - wex
10195 
  """
10196 
 
10197 
  thrift_spec = (
10198 
    None, # 0
10199 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10200 
  )
10201 
 
10202 
  def __init__(self, wex=None,):
10203 
    self.wex = wex
10204 
 
10205 
  def read(self, iprot):
10206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10208 
      return
10209 
    iprot.readStructBegin()
10210 
    while True:
10211 
      (fname, ftype, fid) = iprot.readFieldBegin()
10212 
      if ftype == TType.STOP:
10213 
        break
10214 
      if fid == 1:
10215 
        if ftype == TType.STRUCT:
10216 
          self.wex = WarehouseServiceException()
10217 
          self.wex.read(iprot)
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      else:
10221 
        iprot.skip(ftype)
10222 
      iprot.readFieldEnd()
10223 
    iprot.readStructEnd()
10224 
 
10225 
  def write(self, oprot):
10226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10228 
      return
10229 
    oprot.writeStructBegin('scanForTransferIn_result')
10230 
    if self.wex is not None:
10231 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10232 
      self.wex.write(oprot)
10233 
      oprot.writeFieldEnd()
10234 
    oprot.writeFieldStop()
10235 
    oprot.writeStructEnd()
10236 
 
10237 
  def validate(self):
10238 
    return
10239 
 
10240 
 
10241 
  def __repr__(self):
10242 
    L = ['%s=%r' % (key, value)
10243 
      for key, value in self.__dict__.iteritems()]
10244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10245 
 
10246 
  def __eq__(self, other):
10247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10248 
 
10249 
  def __ne__(self, other):
10250 
    return not (self == other)
10251 
 
10252 
class scanForOursThirdPartyReceive_args:
10253 
  """
10254 
  Attributes:
10255 
   - inventoryItems
10256 
   - id
10257 
  """
10258 
 
10259 
  thrift_spec = (
10260 
    None, # 0
10261 
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
10262 
    (2, TType.I64, 'id', None, None, ), # 2
10263 
  )
10264 
 
10265 
  def __init__(self, inventoryItems=None, id=None,):
10266 
    self.inventoryItems = inventoryItems
10267 
    self.id = id
10268 
 
10269 
  def read(self, iprot):
10270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10272 
      return
10273 
    iprot.readStructBegin()
10274 
    while True:
10275 
      (fname, ftype, fid) = iprot.readFieldBegin()
10276 
      if ftype == TType.STOP:
10277 
        break
10278 
      if fid == 1:
10279 
        if ftype == TType.LIST:
10280 
          self.inventoryItems = []
10407 amar.kumar 10281 
          (_etype194, _size191) = iprot.readListBegin()
10282 
          for _i195 in xrange(_size191):
10283 
            _elem196 = InventoryItem()
10284 
            _elem196.read(iprot)
10285 
            self.inventoryItems.append(_elem196)
7459 amar.kumar 10286 
          iprot.readListEnd()
10287 
        else:
10288 
          iprot.skip(ftype)
10289 
      elif fid == 2:
10290 
        if ftype == TType.I64:
10291 
          self.id = iprot.readI64();
10292 
        else:
10293 
          iprot.skip(ftype)
10294 
      else:
10295 
        iprot.skip(ftype)
10296 
      iprot.readFieldEnd()
10297 
    iprot.readStructEnd()
10298 
 
10299 
  def write(self, oprot):
10300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10302 
      return
10303 
    oprot.writeStructBegin('scanForOursThirdPartyReceive_args')
10304 
    if self.inventoryItems is not None:
10305 
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
10306 
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
10407 amar.kumar 10307 
      for iter197 in self.inventoryItems:
10308 
        iter197.write(oprot)
7459 amar.kumar 10309 
      oprot.writeListEnd()
10310 
      oprot.writeFieldEnd()
10311 
    if self.id is not None:
10312 
      oprot.writeFieldBegin('id', TType.I64, 2)
10313 
      oprot.writeI64(self.id)
10314 
      oprot.writeFieldEnd()
10315 
    oprot.writeFieldStop()
10316 
    oprot.writeStructEnd()
10317 
 
10318 
  def validate(self):
10319 
    return
10320 
 
10321 
 
10322 
  def __repr__(self):
10323 
    L = ['%s=%r' % (key, value)
10324 
      for key, value in self.__dict__.iteritems()]
10325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10326 
 
10327 
  def __eq__(self, other):
10328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10329 
 
10330 
  def __ne__(self, other):
10331 
    return not (self == other)
10332 
 
10333 
class scanForOursThirdPartyReceive_result:
10334 
  """
10335 
  Attributes:
10336 
   - wex
10337 
  """
10338 
 
10339 
  thrift_spec = (
10340 
    None, # 0
10341 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10342 
  )
10343 
 
10344 
  def __init__(self, wex=None,):
10345 
    self.wex = wex
10346 
 
10347 
  def read(self, iprot):
10348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10350 
      return
10351 
    iprot.readStructBegin()
10352 
    while True:
10353 
      (fname, ftype, fid) = iprot.readFieldBegin()
10354 
      if ftype == TType.STOP:
10355 
        break
10356 
      if fid == 1:
10357 
        if ftype == TType.STRUCT:
10358 
          self.wex = WarehouseServiceException()
10359 
          self.wex.read(iprot)
10360 
        else:
10361 
          iprot.skip(ftype)
10362 
      else:
10363 
        iprot.skip(ftype)
10364 
      iprot.readFieldEnd()
10365 
    iprot.readStructEnd()
10366 
 
10367 
  def write(self, oprot):
10368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10370 
      return
10371 
    oprot.writeStructBegin('scanForOursThirdPartyReceive_result')
10372 
    if self.wex is not None:
10373 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10374 
      self.wex.write(oprot)
10375 
      oprot.writeFieldEnd()
10376 
    oprot.writeFieldStop()
10377 
    oprot.writeStructEnd()
10378 
 
10379 
  def validate(self):
10380 
    return
10381 
 
10382 
 
10383 
  def __repr__(self):
10384 
    L = ['%s=%r' % (key, value)
10385 
      for key, value in self.__dict__.iteritems()]
10386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10387 
 
10388 
  def __eq__(self, other):
10389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10390 
 
10391 
  def __ne__(self, other):
10392 
    return not (self == other)
7574 amar.kumar 10393 
 
10394 
class getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args:
10395 
  """
10396 
  Attributes:
10397 
   - itemId
10398 
   - physicalWarehouseId
10399 
  """
10400 
 
10401 
  thrift_spec = (
10402 
    None, # 0
10403 
    (1, TType.I64, 'itemId', None, None, ), # 1
10404 
    (2, TType.I64, 'physicalWarehouseId', None, None, ), # 2
10405 
  )
10406 
 
10407 
  def __init__(self, itemId=None, physicalWarehouseId=None,):
10408 
    self.itemId = itemId
10409 
    self.physicalWarehouseId = physicalWarehouseId
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 == 1:
10421 
        if ftype == TType.I64:
10422 
          self.itemId = iprot.readI64();
10423 
        else:
10424 
          iprot.skip(ftype)
10425 
      elif fid == 2:
10426 
        if ftype == TType.I64:
10427 
          self.physicalWarehouseId = iprot.readI64();
10428 
        else:
10429 
          iprot.skip(ftype)
10430 
      else:
10431 
        iprot.skip(ftype)
10432 
      iprot.readFieldEnd()
10433 
    iprot.readStructEnd()
10434 
 
10435 
  def write(self, oprot):
10436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10438 
      return
10439 
    oprot.writeStructBegin('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_args')
10440 
    if self.itemId is not None:
10441 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10442 
      oprot.writeI64(self.itemId)
10443 
      oprot.writeFieldEnd()
10444 
    if self.physicalWarehouseId is not None:
10445 
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 2)
10446 
      oprot.writeI64(self.physicalWarehouseId)
10447 
      oprot.writeFieldEnd()
10448 
    oprot.writeFieldStop()
10449 
    oprot.writeStructEnd()
10450 
 
10451 
  def validate(self):
10452 
    return
10453 
 
10454 
 
10455 
  def __repr__(self):
10456 
    L = ['%s=%r' % (key, value)
10457 
      for key, value in self.__dict__.iteritems()]
10458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10459 
 
10460 
  def __eq__(self, other):
10461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10462 
 
10463 
  def __ne__(self, other):
10464 
    return not (self == other)
10465 
 
10466 
class getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result:
10467 
  """
10468 
  Attributes:
10469 
   - success
10470 
   - wex
10471 
  """
10472 
 
10473 
  thrift_spec = (
10474 
    (0, TType.I64, 'success', None, None, ), # 0
10475 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10476 
  )
10477 
 
10478 
  def __init__(self, success=None, wex=None,):
10479 
    self.success = success
10480 
    self.wex = wex
10481 
 
10482 
  def read(self, iprot):
10483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10485 
      return
10486 
    iprot.readStructBegin()
10487 
    while True:
10488 
      (fname, ftype, fid) = iprot.readFieldBegin()
10489 
      if ftype == TType.STOP:
10490 
        break
10491 
      if fid == 0:
10492 
        if ftype == TType.I64:
10493 
          self.success = iprot.readI64();
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      elif fid == 1:
10497 
        if ftype == TType.STRUCT:
10498 
          self.wex = WarehouseServiceException()
10499 
          self.wex.read(iprot)
10500 
        else:
10501 
          iprot.skip(ftype)
10502 
      else:
10503 
        iprot.skip(ftype)
10504 
      iprot.readFieldEnd()
10505 
    iprot.readStructEnd()
10506 
 
10507 
  def write(self, oprot):
10508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10510 
      return
10511 
    oprot.writeStructBegin('getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse_result')
10512 
    if self.success is not None:
10513 
      oprot.writeFieldBegin('success', TType.I64, 0)
10514 
      oprot.writeI64(self.success)
10515 
      oprot.writeFieldEnd()
10516 
    if self.wex is not None:
10517 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10518 
      self.wex.write(oprot)
10519 
      oprot.writeFieldEnd()
10520 
    oprot.writeFieldStop()
10521 
    oprot.writeStructEnd()
10522 
 
10523 
  def validate(self):
10524 
    return
10525 
 
10526 
 
10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
7672 rajveer 10537 
 
10538 
class getInTransitInventory_args:
10539 
  """
10540 
  Attributes:
10541 
   - originWarehouseId
10542 
  """
10543 
 
10544 
  thrift_spec = (
10545 
    None, # 0
10546 
    (1, TType.I64, 'originWarehouseId', None, None, ), # 1
10547 
  )
10548 
 
10549 
  def __init__(self, originWarehouseId=None,):
10550 
    self.originWarehouseId = originWarehouseId
10551 
 
10552 
  def read(self, iprot):
10553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10555 
      return
10556 
    iprot.readStructBegin()
10557 
    while True:
10558 
      (fname, ftype, fid) = iprot.readFieldBegin()
10559 
      if ftype == TType.STOP:
10560 
        break
10561 
      if fid == 1:
10562 
        if ftype == TType.I64:
10563 
          self.originWarehouseId = iprot.readI64();
10564 
        else:
10565 
          iprot.skip(ftype)
10566 
      else:
10567 
        iprot.skip(ftype)
10568 
      iprot.readFieldEnd()
10569 
    iprot.readStructEnd()
10570 
 
10571 
  def write(self, oprot):
10572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10574 
      return
10575 
    oprot.writeStructBegin('getInTransitInventory_args')
10576 
    if self.originWarehouseId is not None:
10577 
      oprot.writeFieldBegin('originWarehouseId', TType.I64, 1)
10578 
      oprot.writeI64(self.originWarehouseId)
10579 
      oprot.writeFieldEnd()
10580 
    oprot.writeFieldStop()
10581 
    oprot.writeStructEnd()
10582 
 
10583 
  def validate(self):
10584 
    return
10585 
 
10586 
 
10587 
  def __repr__(self):
10588 
    L = ['%s=%r' % (key, value)
10589 
      for key, value in self.__dict__.iteritems()]
10590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10591 
 
10592 
  def __eq__(self, other):
10593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10594 
 
10595 
  def __ne__(self, other):
10596 
    return not (self == other)
10597 
 
10598 
class getInTransitInventory_result:
10599 
  """
10600 
  Attributes:
10601 
   - success
10602 
  """
10603 
 
10604 
  thrift_spec = (
10605 
    (0, TType.LIST, 'success', (TType.STRUCT,(InTransitInventory, InTransitInventory.thrift_spec)), None, ), # 0
10606 
  )
10607 
 
10608 
  def __init__(self, success=None,):
10609 
    self.success = success
10610 
 
10611 
  def read(self, iprot):
10612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10614 
      return
10615 
    iprot.readStructBegin()
10616 
    while True:
10617 
      (fname, ftype, fid) = iprot.readFieldBegin()
10618 
      if ftype == TType.STOP:
10619 
        break
10620 
      if fid == 0:
10621 
        if ftype == TType.LIST:
10622 
          self.success = []
10407 amar.kumar 10623 
          (_etype201, _size198) = iprot.readListBegin()
10624 
          for _i202 in xrange(_size198):
10625 
            _elem203 = InTransitInventory()
10626 
            _elem203.read(iprot)
10627 
            self.success.append(_elem203)
7672 rajveer 10628 
          iprot.readListEnd()
10629 
        else:
10630 
          iprot.skip(ftype)
10631 
      else:
10632 
        iprot.skip(ftype)
10633 
      iprot.readFieldEnd()
10634 
    iprot.readStructEnd()
10635 
 
10636 
  def write(self, oprot):
10637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10639 
      return
10640 
    oprot.writeStructBegin('getInTransitInventory_result')
10641 
    if self.success is not None:
10642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 10644 
      for iter204 in self.success:
10645 
        iter204.write(oprot)
7672 rajveer 10646 
      oprot.writeListEnd()
10647 
      oprot.writeFieldEnd()
10648 
    oprot.writeFieldStop()
10649 
    oprot.writeStructEnd()
10650 
 
10651 
  def validate(self):
10652 
    return
10653 
 
10654 
 
10655 
  def __repr__(self):
10656 
    L = ['%s=%r' % (key, value)
10657 
      for key, value in self.__dict__.iteritems()]
10658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10659 
 
10660 
  def __eq__(self, other):
10661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10662 
 
10663 
  def __ne__(self, other):
10664 
    return not (self == other)
7968 amar.kumar 10665 
 
10666 
class isItemAvailableForSale_args:
10667 
  """
10668 
  Attributes:
10669 
   - itemId
10670 
   - serialNumber
10671 
   - warehouseId
10672 
  """
10673 
 
10674 
  thrift_spec = (
10675 
    None, # 0
10676 
    (1, TType.I64, 'itemId', None, None, ), # 1
10677 
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
10678 
    (3, TType.I64, 'warehouseId', None, None, ), # 3
10679 
  )
10680 
 
10681 
  def __init__(self, itemId=None, serialNumber=None, warehouseId=None,):
10682 
    self.itemId = itemId
10683 
    self.serialNumber = serialNumber
10684 
    self.warehouseId = warehouseId
10685 
 
10686 
  def read(self, iprot):
10687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10689 
      return
10690 
    iprot.readStructBegin()
10691 
    while True:
10692 
      (fname, ftype, fid) = iprot.readFieldBegin()
10693 
      if ftype == TType.STOP:
10694 
        break
10695 
      if fid == 1:
10696 
        if ftype == TType.I64:
10697 
          self.itemId = iprot.readI64();
10698 
        else:
10699 
          iprot.skip(ftype)
10700 
      elif fid == 2:
10701 
        if ftype == TType.STRING:
10702 
          self.serialNumber = iprot.readString();
10703 
        else:
10704 
          iprot.skip(ftype)
10705 
      elif fid == 3:
10706 
        if ftype == TType.I64:
10707 
          self.warehouseId = iprot.readI64();
10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      else:
10711 
        iprot.skip(ftype)
10712 
      iprot.readFieldEnd()
10713 
    iprot.readStructEnd()
10714 
 
10715 
  def write(self, oprot):
10716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10718 
      return
10719 
    oprot.writeStructBegin('isItemAvailableForSale_args')
10720 
    if self.itemId is not None:
10721 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
10722 
      oprot.writeI64(self.itemId)
10723 
      oprot.writeFieldEnd()
10724 
    if self.serialNumber is not None:
10725 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
10726 
      oprot.writeString(self.serialNumber)
10727 
      oprot.writeFieldEnd()
10728 
    if self.warehouseId is not None:
10729 
      oprot.writeFieldBegin('warehouseId', TType.I64, 3)
10730 
      oprot.writeI64(self.warehouseId)
10731 
      oprot.writeFieldEnd()
10732 
    oprot.writeFieldStop()
10733 
    oprot.writeStructEnd()
10734 
 
10735 
  def validate(self):
10736 
    return
10737 
 
10738 
 
10739 
  def __repr__(self):
10740 
    L = ['%s=%r' % (key, value)
10741 
      for key, value in self.__dict__.iteritems()]
10742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10743 
 
10744 
  def __eq__(self, other):
10745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10746 
 
10747 
  def __ne__(self, other):
10748 
    return not (self == other)
10749 
 
10750 
class isItemAvailableForSale_result:
10751 
  """
10752 
  Attributes:
10753 
   - success
10754 
   - wex
10755 
  """
10756 
 
10757 
  thrift_spec = (
10758 
    (0, TType.BOOL, 'success', None, None, ), # 0
10759 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10760 
  )
10761 
 
10762 
  def __init__(self, success=None, wex=None,):
10763 
    self.success = success
10764 
    self.wex = wex
10765 
 
10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
10775 
      if fid == 0:
10776 
        if ftype == TType.BOOL:
10777 
          self.success = iprot.readBool();
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      elif fid == 1:
10781 
        if ftype == TType.STRUCT:
10782 
          self.wex = WarehouseServiceException()
10783 
          self.wex.read(iprot)
10784 
        else:
10785 
          iprot.skip(ftype)
10786 
      else:
10787 
        iprot.skip(ftype)
10788 
      iprot.readFieldEnd()
10789 
    iprot.readStructEnd()
10790 
 
10791 
  def write(self, oprot):
10792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10794 
      return
10795 
    oprot.writeStructBegin('isItemAvailableForSale_result')
10796 
    if self.success is not None:
10797 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10798 
      oprot.writeBool(self.success)
10799 
      oprot.writeFieldEnd()
10800 
    if self.wex is not None:
10801 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10802 
      self.wex.write(oprot)
10803 
      oprot.writeFieldEnd()
10804 
    oprot.writeFieldStop()
10805 
    oprot.writeStructEnd()
10806 
 
10807 
  def validate(self):
10808 
    return
10809 
 
10810 
 
10811 
  def __repr__(self):
10812 
    L = ['%s=%r' % (key, value)
10813 
      for key, value in self.__dict__.iteritems()]
10814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10815 
 
10816 
  def __eq__(self, other):
10817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10818 
 
10819 
  def __ne__(self, other):
10820 
    return not (self == other)
10821 
 
10822 
class getHistoricBadInventoryByScans_args:
10823 
  """
10824 
  Attributes:
10825 
   - date
10826 
  """
10827 
 
10828 
  thrift_spec = (
10829 
    None, # 0
10830 
    (1, TType.I64, 'date', None, None, ), # 1
10831 
  )
10832 
 
10833 
  def __init__(self, date=None,):
10834 
    self.date = date
10835 
 
10836 
  def read(self, iprot):
10837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10839 
      return
10840 
    iprot.readStructBegin()
10841 
    while True:
10842 
      (fname, ftype, fid) = iprot.readFieldBegin()
10843 
      if ftype == TType.STOP:
10844 
        break
10845 
      if fid == 1:
10846 
        if ftype == TType.I64:
10847 
          self.date = iprot.readI64();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
10859 
    oprot.writeStructBegin('getHistoricBadInventoryByScans_args')
10860 
    if self.date is not None:
10861 
      oprot.writeFieldBegin('date', TType.I64, 1)
10862 
      oprot.writeI64(self.date)
10863 
      oprot.writeFieldEnd()
10864 
    oprot.writeFieldStop()
10865 
    oprot.writeStructEnd()
10866 
 
10867 
  def validate(self):
10868 
    return
10869 
 
10870 
 
10871 
  def __repr__(self):
10872 
    L = ['%s=%r' % (key, value)
10873 
      for key, value in self.__dict__.iteritems()]
10874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10875 
 
10876 
  def __eq__(self, other):
10877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10878 
 
10879 
  def __ne__(self, other):
10880 
    return not (self == other)
10881 
 
10882 
class getHistoricBadInventoryByScans_result:
10883 
  """
10884 
  Attributes:
10885 
   - success
10886 
   - wex
10887 
  """
10888 
 
10889 
  thrift_spec = (
10890 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
10891 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
10892 
  )
10893 
 
10894 
  def __init__(self, success=None, wex=None,):
10895 
    self.success = success
10896 
    self.wex = wex
10897 
 
10898 
  def read(self, iprot):
10899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10901 
      return
10902 
    iprot.readStructBegin()
10903 
    while True:
10904 
      (fname, ftype, fid) = iprot.readFieldBegin()
10905 
      if ftype == TType.STOP:
10906 
        break
10907 
      if fid == 0:
10908 
        if ftype == TType.LIST:
10909 
          self.success = []
10407 amar.kumar 10910 
          (_etype208, _size205) = iprot.readListBegin()
10911 
          for _i209 in xrange(_size205):
10912 
            _elem210 = InventoryAvailability()
10913 
            _elem210.read(iprot)
10914 
            self.success.append(_elem210)
7968 amar.kumar 10915 
          iprot.readListEnd()
10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      elif fid == 1:
10919 
        if ftype == TType.STRUCT:
10920 
          self.wex = WarehouseServiceException()
10921 
          self.wex.read(iprot)
10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      else:
10925 
        iprot.skip(ftype)
10926 
      iprot.readFieldEnd()
10927 
    iprot.readStructEnd()
10928 
 
10929 
  def write(self, oprot):
10930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10932 
      return
10933 
    oprot.writeStructBegin('getHistoricBadInventoryByScans_result')
10934 
    if self.success is not None:
10935 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10936 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 10937 
      for iter211 in self.success:
10938 
        iter211.write(oprot)
7968 amar.kumar 10939 
      oprot.writeListEnd()
10940 
      oprot.writeFieldEnd()
10941 
    if self.wex is not None:
10942 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
10943 
      self.wex.write(oprot)
10944 
      oprot.writeFieldEnd()
10945 
    oprot.writeFieldStop()
10946 
    oprot.writeStructEnd()
10947 
 
10948 
  def validate(self):
10949 
    return
10950 
 
10951 
 
10952 
  def __repr__(self):
10953 
    L = ['%s=%r' % (key, value)
10954 
      for key, value in self.__dict__.iteritems()]
10955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10956 
 
10957 
  def __eq__(self, other):
10958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10959 
 
10960 
  def __ne__(self, other):
10961 
    return not (self == other)
8565 amar.kumar 10962 
 
10963 
class scanForBadSale_args:
10964 
  """
10965 
  Attributes:
8717 amar.kumar 10966 
   - serialNumber
10967 
   - itemNumber
10968 
   - itemId
8565 amar.kumar 10969 
   - orderId
8717 amar.kumar 10970 
   - fulfilmentWarehouseId
8565 amar.kumar 10971 
   - quantity
10972 
   - billingWarehouseId
10973 
  """
10974 
 
10975 
  thrift_spec = (
10976 
    None, # 0
8717 amar.kumar 10977 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
10978 
    (2, TType.STRING, 'itemNumber', None, None, ), # 2
10979 
    (3, TType.I64, 'itemId', None, None, ), # 3
10980 
    (4, TType.I64, 'orderId', None, None, ), # 4
10981 
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
10982 
    (6, TType.I64, 'quantity', None, None, ), # 6
10983 
    (7, TType.I64, 'billingWarehouseId', None, None, ), # 7
8565 amar.kumar 10984 
  )
10985 
 
8717 amar.kumar 10986 
  def __init__(self, serialNumber=None, itemNumber=None, itemId=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
10987 
    self.serialNumber = serialNumber
10988 
    self.itemNumber = itemNumber
10989 
    self.itemId = itemId
8565 amar.kumar 10990 
    self.orderId = orderId
8717 amar.kumar 10991 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
8565 amar.kumar 10992 
    self.quantity = quantity
10993 
    self.billingWarehouseId = billingWarehouseId
10994 
 
10995 
  def read(self, iprot):
10996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10998 
      return
10999 
    iprot.readStructBegin()
11000 
    while True:
11001 
      (fname, ftype, fid) = iprot.readFieldBegin()
11002 
      if ftype == TType.STOP:
11003 
        break
11004 
      if fid == 1:
8717 amar.kumar 11005 
        if ftype == TType.STRING:
11006 
          self.serialNumber = iprot.readString();
8565 amar.kumar 11007 
        else:
11008 
          iprot.skip(ftype)
11009 
      elif fid == 2:
8717 amar.kumar 11010 
        if ftype == TType.STRING:
11011 
          self.itemNumber = iprot.readString();
8565 amar.kumar 11012 
        else:
11013 
          iprot.skip(ftype)
11014 
      elif fid == 3:
11015 
        if ftype == TType.I64:
8717 amar.kumar 11016 
          self.itemId = iprot.readI64();
8565 amar.kumar 11017 
        else:
11018 
          iprot.skip(ftype)
11019 
      elif fid == 4:
11020 
        if ftype == TType.I64:
8717 amar.kumar 11021 
          self.orderId = iprot.readI64();
8565 amar.kumar 11022 
        else:
11023 
          iprot.skip(ftype)
11024 
      elif fid == 5:
11025 
        if ftype == TType.I64:
8717 amar.kumar 11026 
          self.fulfilmentWarehouseId = iprot.readI64();
11027 
        else:
11028 
          iprot.skip(ftype)
11029 
      elif fid == 6:
11030 
        if ftype == TType.I64:
11031 
          self.quantity = iprot.readI64();
11032 
        else:
11033 
          iprot.skip(ftype)
11034 
      elif fid == 7:
11035 
        if ftype == TType.I64:
8565 amar.kumar 11036 
          self.billingWarehouseId = iprot.readI64();
11037 
        else:
11038 
          iprot.skip(ftype)
11039 
      else:
11040 
        iprot.skip(ftype)
11041 
      iprot.readFieldEnd()
11042 
    iprot.readStructEnd()
11043 
 
11044 
  def write(self, oprot):
11045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11047 
      return
11048 
    oprot.writeStructBegin('scanForBadSale_args')
8717 amar.kumar 11049 
    if self.serialNumber is not None:
11050 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
11051 
      oprot.writeString(self.serialNumber)
8565 amar.kumar 11052 
      oprot.writeFieldEnd()
8717 amar.kumar 11053 
    if self.itemNumber is not None:
11054 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 2)
11055 
      oprot.writeString(self.itemNumber)
11056 
      oprot.writeFieldEnd()
11057 
    if self.itemId is not None:
11058 
      oprot.writeFieldBegin('itemId', TType.I64, 3)
11059 
      oprot.writeI64(self.itemId)
11060 
      oprot.writeFieldEnd()
8565 amar.kumar 11061 
    if self.orderId is not None:
8717 amar.kumar 11062 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
8565 amar.kumar 11063 
      oprot.writeI64(self.orderId)
11064 
      oprot.writeFieldEnd()
8717 amar.kumar 11065 
    if self.fulfilmentWarehouseId is not None:
11066 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
11067 
      oprot.writeI64(self.fulfilmentWarehouseId)
11068 
      oprot.writeFieldEnd()
8565 amar.kumar 11069 
    if self.quantity is not None:
8717 amar.kumar 11070 
      oprot.writeFieldBegin('quantity', TType.I64, 6)
8565 amar.kumar 11071 
      oprot.writeI64(self.quantity)
11072 
      oprot.writeFieldEnd()
11073 
    if self.billingWarehouseId is not None:
8717 amar.kumar 11074 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 7)
8565 amar.kumar 11075 
      oprot.writeI64(self.billingWarehouseId)
11076 
      oprot.writeFieldEnd()
11077 
    oprot.writeFieldStop()
11078 
    oprot.writeStructEnd()
11079 
 
11080 
  def validate(self):
11081 
    return
11082 
 
11083 
 
11084 
  def __repr__(self):
11085 
    L = ['%s=%r' % (key, value)
11086 
      for key, value in self.__dict__.iteritems()]
11087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11088 
 
11089 
  def __eq__(self, other):
11090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11091 
 
11092 
  def __ne__(self, other):
11093 
    return not (self == other)
11094 
 
11095 
class scanForBadSale_result:
8717 amar.kumar 11096 
  """
11097 
  Attributes:
11098 
   - success
11099 
   - wex
11100 
  """
8565 amar.kumar 11101 
 
11102 
  thrift_spec = (
8717 amar.kumar 11103 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
11104 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
8565 amar.kumar 11105 
  )
11106 
 
8717 amar.kumar 11107 
  def __init__(self, success=None, wex=None,):
11108 
    self.success = success
11109 
    self.wex = wex
11110 
 
8565 amar.kumar 11111 
  def read(self, iprot):
11112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11114 
      return
11115 
    iprot.readStructBegin()
11116 
    while True:
11117 
      (fname, ftype, fid) = iprot.readFieldBegin()
11118 
      if ftype == TType.STOP:
11119 
        break
8717 amar.kumar 11120 
      if fid == 0:
11121 
        if ftype == TType.STRUCT:
11122 
          self.success = InventoryItem()
11123 
          self.success.read(iprot)
11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      elif fid == 1:
11127 
        if ftype == TType.STRUCT:
11128 
          self.wex = WarehouseServiceException()
11129 
          self.wex.read(iprot)
11130 
        else:
11131 
          iprot.skip(ftype)
8565 amar.kumar 11132 
      else:
11133 
        iprot.skip(ftype)
11134 
      iprot.readFieldEnd()
11135 
    iprot.readStructEnd()
11136 
 
11137 
  def write(self, oprot):
11138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11140 
      return
11141 
    oprot.writeStructBegin('scanForBadSale_result')
8717 amar.kumar 11142 
    if self.success is not None:
11143 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11144 
      self.success.write(oprot)
11145 
      oprot.writeFieldEnd()
11146 
    if self.wex is not None:
11147 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11148 
      self.wex.write(oprot)
11149 
      oprot.writeFieldEnd()
8565 amar.kumar 11150 
    oprot.writeFieldStop()
11151 
    oprot.writeStructEnd()
11152 
 
11153 
  def validate(self):
11154 
    return
11155 
 
11156 
 
11157 
  def __repr__(self):
11158 
    L = ['%s=%r' % (key, value)
11159 
      for key, value in self.__dict__.iteritems()]
11160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11161 
 
11162 
  def __eq__(self, other):
11163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11164 
 
11165 
  def __ne__(self, other):
11166 
    return not (self == other)
10120 manish.sha 11167 
 
11168 
class getTransferLotItemsForMarkReceive_args:
11169 
  """
11170 
  Attributes:
11171 
   - transferLotId
11172 
   - scanType
11173 
  """
11174 
 
11175 
  thrift_spec = (
11176 
    None, # 0
11177 
    (1, TType.I64, 'transferLotId', None, None, ), # 1
11178 
    (2, TType.I32, 'scanType', None, None, ), # 2
11179 
  )
11180 
 
11181 
  def __init__(self, transferLotId=None, scanType=None,):
11182 
    self.transferLotId = transferLotId
11183 
    self.scanType = scanType
11184 
 
11185 
  def read(self, iprot):
11186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11188 
      return
11189 
    iprot.readStructBegin()
11190 
    while True:
11191 
      (fname, ftype, fid) = iprot.readFieldBegin()
11192 
      if ftype == TType.STOP:
11193 
        break
11194 
      if fid == 1:
11195 
        if ftype == TType.I64:
11196 
          self.transferLotId = iprot.readI64();
11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      elif fid == 2:
11200 
        if ftype == TType.I32:
11201 
          self.scanType = iprot.readI32();
11202 
        else:
11203 
          iprot.skip(ftype)
11204 
      else:
11205 
        iprot.skip(ftype)
11206 
      iprot.readFieldEnd()
11207 
    iprot.readStructEnd()
11208 
 
11209 
  def write(self, oprot):
11210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11212 
      return
11213 
    oprot.writeStructBegin('getTransferLotItemsForMarkReceive_args')
11214 
    if self.transferLotId is not None:
11215 
      oprot.writeFieldBegin('transferLotId', TType.I64, 1)
11216 
      oprot.writeI64(self.transferLotId)
11217 
      oprot.writeFieldEnd()
11218 
    if self.scanType is not None:
11219 
      oprot.writeFieldBegin('scanType', TType.I32, 2)
11220 
      oprot.writeI32(self.scanType)
11221 
      oprot.writeFieldEnd()
11222 
    oprot.writeFieldStop()
11223 
    oprot.writeStructEnd()
11224 
 
11225 
  def validate(self):
11226 
    return
11227 
 
11228 
 
11229 
  def __repr__(self):
11230 
    L = ['%s=%r' % (key, value)
11231 
      for key, value in self.__dict__.iteritems()]
11232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11233 
 
11234 
  def __eq__(self, other):
11235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11236 
 
11237 
  def __ne__(self, other):
11238 
    return not (self == other)
11239 
 
11240 
class getTransferLotItemsForMarkReceive_result:
11241 
  """
11242 
  Attributes:
11243 
   - success
11244 
   - wex
11245 
  """
11246 
 
11247 
  thrift_spec = (
11248 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
11249 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11250 
  )
11251 
 
11252 
  def __init__(self, success=None, wex=None,):
11253 
    self.success = success
11254 
    self.wex = wex
11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
11265 
      if fid == 0:
11266 
        if ftype == TType.LIST:
11267 
          self.success = []
10407 amar.kumar 11268 
          (_etype215, _size212) = iprot.readListBegin()
11269 
          for _i216 in xrange(_size212):
11270 
            _elem217 = InventoryItem()
11271 
            _elem217.read(iprot)
11272 
            self.success.append(_elem217)
10120 manish.sha 11273 
          iprot.readListEnd()
11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      elif fid == 1:
11277 
        if ftype == TType.STRUCT:
11278 
          self.wex = WarehouseServiceException()
11279 
          self.wex.read(iprot)
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('getTransferLotItemsForMarkReceive_result')
11292 
    if self.success is not None:
11293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
10407 amar.kumar 11295 
      for iter218 in self.success:
11296 
        iter218.write(oprot)
10120 manish.sha 11297 
      oprot.writeListEnd()
11298 
      oprot.writeFieldEnd()
11299 
    if self.wex is not None:
11300 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11301 
      self.wex.write(oprot)
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 markItemsAsReceivedForTransferLotPartial_args:
11322 
  """
11323 
  Attributes:
11324 
   - inventoryItems
11325 
   - transferLotId
11326 
  """
11327 
 
11328 
  thrift_spec = (
11329 
    None, # 0
11330 
    (1, TType.LIST, 'inventoryItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
11331 
    (2, TType.I64, 'transferLotId', None, None, ), # 2
11332 
  )
11333 
 
11334 
  def __init__(self, inventoryItems=None, transferLotId=None,):
11335 
    self.inventoryItems = inventoryItems
11336 
    self.transferLotId = transferLotId
11337 
 
11338 
  def read(self, iprot):
11339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11341 
      return
11342 
    iprot.readStructBegin()
11343 
    while True:
11344 
      (fname, ftype, fid) = iprot.readFieldBegin()
11345 
      if ftype == TType.STOP:
11346 
        break
11347 
      if fid == 1:
11348 
        if ftype == TType.LIST:
11349 
          self.inventoryItems = []
10407 amar.kumar 11350 
          (_etype222, _size219) = iprot.readListBegin()
11351 
          for _i223 in xrange(_size219):
11352 
            _elem224 = InventoryItem()
11353 
            _elem224.read(iprot)
11354 
            self.inventoryItems.append(_elem224)
10120 manish.sha 11355 
          iprot.readListEnd()
11356 
        else:
11357 
          iprot.skip(ftype)
11358 
      elif fid == 2:
11359 
        if ftype == TType.I64:
11360 
          self.transferLotId = iprot.readI64();
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('markItemsAsReceivedForTransferLotPartial_args')
11373 
    if self.inventoryItems is not None:
11374 
      oprot.writeFieldBegin('inventoryItems', TType.LIST, 1)
11375 
      oprot.writeListBegin(TType.STRUCT, len(self.inventoryItems))
10407 amar.kumar 11376 
      for iter225 in self.inventoryItems:
11377 
        iter225.write(oprot)
10120 manish.sha 11378 
      oprot.writeListEnd()
11379 
      oprot.writeFieldEnd()
11380 
    if self.transferLotId is not None:
11381 
      oprot.writeFieldBegin('transferLotId', TType.I64, 2)
11382 
      oprot.writeI64(self.transferLotId)
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 markItemsAsReceivedForTransferLotPartial_result:
11403 
  """
11404 
  Attributes:
11405 
   - wex
11406 
  """
11407 
 
11408 
  thrift_spec = (
11409 
    None, # 0
11410 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11411 
  )
11412 
 
11413 
  def __init__(self, wex=None,):
11414 
    self.wex = wex
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.STRUCT:
11427 
          self.wex = WarehouseServiceException()
11428 
          self.wex.read(iprot)
11429 
        else:
11430 
          iprot.skip(ftype)
11431 
      else:
11432 
        iprot.skip(ftype)
11433 
      iprot.readFieldEnd()
11434 
    iprot.readStructEnd()
11435 
 
11436 
  def write(self, oprot):
11437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11439 
      return
11440 
    oprot.writeStructBegin('markItemsAsReceivedForTransferLotPartial_result')
11441 
    if self.wex is not None:
11442 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11443 
      self.wex.write(oprot)
11444 
      oprot.writeFieldEnd()
11445 
    oprot.writeFieldStop()
11446 
    oprot.writeStructEnd()
11447 
 
11448 
  def validate(self):
11449 
    return
11450 
 
11451 
 
11452 
  def __repr__(self):
11453 
    L = ['%s=%r' % (key, value)
11454 
      for key, value in self.__dict__.iteritems()]
11455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11456 
 
11457 
  def __eq__(self, other):
11458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11459 
 
11460 
  def __ne__(self, other):
11461 
    return not (self == other)
11462 
 
11463 
class markTransferLotAsReceivedPartial_args:
11464 
  """
11465 
  Attributes:
11466 
   - id
11467 
   - remoteTransferRefNumber
11468 
  """
11469 
 
11470 
  thrift_spec = (
11471 
    None, # 0
11472 
    (1, TType.I64, 'id', None, None, ), # 1
11473 
    (2, TType.STRING, 'remoteTransferRefNumber', None, None, ), # 2
11474 
  )
11475 
 
11476 
  def __init__(self, id=None, remoteTransferRefNumber=None,):
11477 
    self.id = id
11478 
    self.remoteTransferRefNumber = remoteTransferRefNumber
11479 
 
11480 
  def read(self, iprot):
11481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11483 
      return
11484 
    iprot.readStructBegin()
11485 
    while True:
11486 
      (fname, ftype, fid) = iprot.readFieldBegin()
11487 
      if ftype == TType.STOP:
11488 
        break
11489 
      if fid == 1:
11490 
        if ftype == TType.I64:
11491 
          self.id = iprot.readI64();
11492 
        else:
11493 
          iprot.skip(ftype)
11494 
      elif fid == 2:
11495 
        if ftype == TType.STRING:
11496 
          self.remoteTransferRefNumber = iprot.readString();
11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      else:
11500 
        iprot.skip(ftype)
11501 
      iprot.readFieldEnd()
11502 
    iprot.readStructEnd()
11503 
 
11504 
  def write(self, oprot):
11505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11507 
      return
11508 
    oprot.writeStructBegin('markTransferLotAsReceivedPartial_args')
11509 
    if self.id is not None:
11510 
      oprot.writeFieldBegin('id', TType.I64, 1)
11511 
      oprot.writeI64(self.id)
11512 
      oprot.writeFieldEnd()
11513 
    if self.remoteTransferRefNumber is not None:
11514 
      oprot.writeFieldBegin('remoteTransferRefNumber', TType.STRING, 2)
11515 
      oprot.writeString(self.remoteTransferRefNumber)
11516 
      oprot.writeFieldEnd()
11517 
    oprot.writeFieldStop()
11518 
    oprot.writeStructEnd()
11519 
 
11520 
  def validate(self):
11521 
    return
11522 
 
11523 
 
11524 
  def __repr__(self):
11525 
    L = ['%s=%r' % (key, value)
11526 
      for key, value in self.__dict__.iteritems()]
11527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11528 
 
11529 
  def __eq__(self, other):
11530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11531 
 
11532 
  def __ne__(self, other):
11533 
    return not (self == other)
11534 
 
11535 
class markTransferLotAsReceivedPartial_result:
11536 
  """
11537 
  Attributes:
11538 
   - wex
11539 
  """
11540 
 
11541 
  thrift_spec = (
11542 
    None, # 0
11543 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11544 
  )
11545 
 
11546 
  def __init__(self, wex=None,):
11547 
    self.wex = wex
11548 
 
11549 
  def read(self, iprot):
11550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11552 
      return
11553 
    iprot.readStructBegin()
11554 
    while True:
11555 
      (fname, ftype, fid) = iprot.readFieldBegin()
11556 
      if ftype == TType.STOP:
11557 
        break
11558 
      if fid == 1:
11559 
        if ftype == TType.STRUCT:
11560 
          self.wex = WarehouseServiceException()
11561 
          self.wex.read(iprot)
11562 
        else:
11563 
          iprot.skip(ftype)
11564 
      else:
11565 
        iprot.skip(ftype)
11566 
      iprot.readFieldEnd()
11567 
    iprot.readStructEnd()
11568 
 
11569 
  def write(self, oprot):
11570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11572 
      return
11573 
    oprot.writeStructBegin('markTransferLotAsReceivedPartial_result')
11574 
    if self.wex is not None:
11575 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11576 
      self.wex.write(oprot)
11577 
      oprot.writeFieldEnd()
11578 
    oprot.writeFieldStop()
11579 
    oprot.writeStructEnd()
11580 
 
11581 
  def validate(self):
11582 
    return
11583 
 
11584 
 
11585 
  def __repr__(self):
11586 
    L = ['%s=%r' % (key, value)
11587 
      for key, value in self.__dict__.iteritems()]
11588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11589 
 
11590 
  def __eq__(self, other):
11591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11592 
 
11593 
  def __ne__(self, other):
11594 
    return not (self == other)
10690 manish.sha 11595 
 
11596 
class getInventoryItemScannedInForPO_args:
11597 
  """
11598 
  Attributes:
11599 
   - itemId
11600 
   - purchaseIds
11601 
  """
11602 
 
11603 
  thrift_spec = (
11604 
    None, # 0
11605 
    (1, TType.I64, 'itemId', None, None, ), # 1
11606 
    (2, TType.LIST, 'purchaseIds', (TType.I64,None), None, ), # 2
11607 
  )
11608 
 
11609 
  def __init__(self, itemId=None, purchaseIds=None,):
11610 
    self.itemId = itemId
11611 
    self.purchaseIds = purchaseIds
11612 
 
11613 
  def read(self, iprot):
11614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11616 
      return
11617 
    iprot.readStructBegin()
11618 
    while True:
11619 
      (fname, ftype, fid) = iprot.readFieldBegin()
11620 
      if ftype == TType.STOP:
11621 
        break
11622 
      if fid == 1:
11623 
        if ftype == TType.I64:
11624 
          self.itemId = iprot.readI64();
11625 
        else:
11626 
          iprot.skip(ftype)
11627 
      elif fid == 2:
11628 
        if ftype == TType.LIST:
11629 
          self.purchaseIds = []
11630 
          (_etype229, _size226) = iprot.readListBegin()
11631 
          for _i230 in xrange(_size226):
11632 
            _elem231 = iprot.readI64();
11633 
            self.purchaseIds.append(_elem231)
11634 
          iprot.readListEnd()
11635 
        else:
11636 
          iprot.skip(ftype)
11637 
      else:
11638 
        iprot.skip(ftype)
11639 
      iprot.readFieldEnd()
11640 
    iprot.readStructEnd()
11641 
 
11642 
  def write(self, oprot):
11643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11645 
      return
11646 
    oprot.writeStructBegin('getInventoryItemScannedInForPO_args')
11647 
    if self.itemId is not None:
11648 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
11649 
      oprot.writeI64(self.itemId)
11650 
      oprot.writeFieldEnd()
11651 
    if self.purchaseIds is not None:
11652 
      oprot.writeFieldBegin('purchaseIds', TType.LIST, 2)
11653 
      oprot.writeListBegin(TType.I64, len(self.purchaseIds))
11654 
      for iter232 in self.purchaseIds:
11655 
        oprot.writeI64(iter232)
11656 
      oprot.writeListEnd()
11657 
      oprot.writeFieldEnd()
11658 
    oprot.writeFieldStop()
11659 
    oprot.writeStructEnd()
11660 
 
11661 
  def validate(self):
11662 
    return
11663 
 
11664 
 
11665 
  def __repr__(self):
11666 
    L = ['%s=%r' % (key, value)
11667 
      for key, value in self.__dict__.iteritems()]
11668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11669 
 
11670 
  def __eq__(self, other):
11671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11672 
 
11673 
  def __ne__(self, other):
11674 
    return not (self == other)
11675 
 
11676 
class getInventoryItemScannedInForPO_result:
11677 
  """
11678 
  Attributes:
11679 
   - success
11680 
   - wex
11681 
  """
11682 
 
11683 
  thrift_spec = (
11684 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
11685 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11686 
  )
11687 
 
11688 
  def __init__(self, success=None, wex=None,):
11689 
    self.success = success
11690 
    self.wex = wex
11691 
 
11692 
  def read(self, iprot):
11693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11695 
      return
11696 
    iprot.readStructBegin()
11697 
    while True:
11698 
      (fname, ftype, fid) = iprot.readFieldBegin()
11699 
      if ftype == TType.STOP:
11700 
        break
11701 
      if fid == 0:
11702 
        if ftype == TType.LIST:
11703 
          self.success = []
11704 
          (_etype236, _size233) = iprot.readListBegin()
11705 
          for _i237 in xrange(_size233):
11706 
            _elem238 = InventoryItem()
11707 
            _elem238.read(iprot)
11708 
            self.success.append(_elem238)
11709 
          iprot.readListEnd()
11710 
        else:
11711 
          iprot.skip(ftype)
11712 
      elif fid == 1:
11713 
        if ftype == TType.STRUCT:
11714 
          self.wex = WarehouseServiceException()
11715 
          self.wex.read(iprot)
11716 
        else:
11717 
          iprot.skip(ftype)
11718 
      else:
11719 
        iprot.skip(ftype)
11720 
      iprot.readFieldEnd()
11721 
    iprot.readStructEnd()
11722 
 
11723 
  def write(self, oprot):
11724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11726 
      return
11727 
    oprot.writeStructBegin('getInventoryItemScannedInForPO_result')
11728 
    if self.success is not None:
11729 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11730 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11731 
      for iter239 in self.success:
11732 
        iter239.write(oprot)
11733 
      oprot.writeListEnd()
11734 
      oprot.writeFieldEnd()
11735 
    if self.wex is not None:
11736 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11737 
      self.wex.write(oprot)
11738 
      oprot.writeFieldEnd()
11739 
    oprot.writeFieldStop()
11740 
    oprot.writeStructEnd()
11741 
 
11742 
  def validate(self):
11743 
    return
11744 
 
11745 
 
11746 
  def __repr__(self):
11747 
    L = ['%s=%r' % (key, value)
11748 
      for key, value in self.__dict__.iteritems()]
11749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11750 
 
11751 
  def __eq__(self, other):
11752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11753 
 
11754 
  def __ne__(self, other):
11755 
    return not (self == other)
11756 
 
11757 
class getAmazonTransferredSkuDetails_args:
11758 
  """
11759 
  Attributes:
11760 
   - itemIds
11761 
  """
11762 
 
11763 
  thrift_spec = (
11764 
    None, # 0
11765 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
11766 
  )
11767 
 
11768 
  def __init__(self, itemIds=None,):
11769 
    self.itemIds = itemIds
11770 
 
11771 
  def read(self, iprot):
11772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11774 
      return
11775 
    iprot.readStructBegin()
11776 
    while True:
11777 
      (fname, ftype, fid) = iprot.readFieldBegin()
11778 
      if ftype == TType.STOP:
11779 
        break
11780 
      if fid == 1:
11781 
        if ftype == TType.LIST:
11782 
          self.itemIds = []
11783 
          (_etype243, _size240) = iprot.readListBegin()
11784 
          for _i244 in xrange(_size240):
11785 
            _elem245 = iprot.readI64();
11786 
            self.itemIds.append(_elem245)
11787 
          iprot.readListEnd()
11788 
        else:
11789 
          iprot.skip(ftype)
11790 
      else:
11791 
        iprot.skip(ftype)
11792 
      iprot.readFieldEnd()
11793 
    iprot.readStructEnd()
11794 
 
11795 
  def write(self, oprot):
11796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11798 
      return
11799 
    oprot.writeStructBegin('getAmazonTransferredSkuDetails_args')
11800 
    if self.itemIds is not None:
11801 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
11802 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
11803 
      for iter246 in self.itemIds:
11804 
        oprot.writeI64(iter246)
11805 
      oprot.writeListEnd()
11806 
      oprot.writeFieldEnd()
11807 
    oprot.writeFieldStop()
11808 
    oprot.writeStructEnd()
11809 
 
11810 
  def validate(self):
11811 
    return
11812 
 
11813 
 
11814 
  def __repr__(self):
11815 
    L = ['%s=%r' % (key, value)
11816 
      for key, value in self.__dict__.iteritems()]
11817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11818 
 
11819 
  def __eq__(self, other):
11820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11821 
 
11822 
  def __ne__(self, other):
11823 
    return not (self == other)
11824 
 
11825 
class getAmazonTransferredSkuDetails_result:
11826 
  """
11827 
  Attributes:
11828 
   - success
11829 
   - wex
11830 
  """
11831 
 
11832 
  thrift_spec = (
11833 
    (0, TType.LIST, 'success', (TType.STRUCT,(AmazonTransferredSkuDetail, AmazonTransferredSkuDetail.thrift_spec)), None, ), # 0
11834 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11835 
  )
11836 
 
11837 
  def __init__(self, success=None, wex=None,):
11838 
    self.success = success
11839 
    self.wex = wex
11840 
 
11841 
  def read(self, iprot):
11842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11844 
      return
11845 
    iprot.readStructBegin()
11846 
    while True:
11847 
      (fname, ftype, fid) = iprot.readFieldBegin()
11848 
      if ftype == TType.STOP:
11849 
        break
11850 
      if fid == 0:
11851 
        if ftype == TType.LIST:
11852 
          self.success = []
11853 
          (_etype250, _size247) = iprot.readListBegin()
11854 
          for _i251 in xrange(_size247):
11855 
            _elem252 = AmazonTransferredSkuDetail()
11856 
            _elem252.read(iprot)
11857 
            self.success.append(_elem252)
11858 
          iprot.readListEnd()
11859 
        else:
11860 
          iprot.skip(ftype)
11861 
      elif fid == 1:
11862 
        if ftype == TType.STRUCT:
11863 
          self.wex = WarehouseServiceException()
11864 
          self.wex.read(iprot)
11865 
        else:
11866 
          iprot.skip(ftype)
11867 
      else:
11868 
        iprot.skip(ftype)
11869 
      iprot.readFieldEnd()
11870 
    iprot.readStructEnd()
11871 
 
11872 
  def write(self, oprot):
11873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11875 
      return
11876 
    oprot.writeStructBegin('getAmazonTransferredSkuDetails_result')
11877 
    if self.success is not None:
11878 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11879 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11880 
      for iter253 in self.success:
11881 
        iter253.write(oprot)
11882 
      oprot.writeListEnd()
11883 
      oprot.writeFieldEnd()
11884 
    if self.wex is not None:
11885 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
11886 
      self.wex.write(oprot)
11887 
      oprot.writeFieldEnd()
11888 
    oprot.writeFieldStop()
11889 
    oprot.writeStructEnd()
11890 
 
11891 
  def validate(self):
11892 
    return
11893 
 
11894 
 
11895 
  def __repr__(self):
11896 
    L = ['%s=%r' % (key, value)
11897 
      for key, value in self.__dict__.iteritems()]
11898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11899 
 
11900 
  def __eq__(self, other):
11901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11902 
 
11903 
  def __ne__(self, other):
11904 
    return not (self == other)
11905 
 
11906 
class getScansforPurchase_args:
11907 
  """
11908 
  Attributes:
11909 
   - purchaseId
11910 
   - scanType
11911 
  """
11912 
 
11913 
  thrift_spec = (
11914 
    None, # 0
11915 
    (1, TType.I64, 'purchaseId', None, None, ), # 1
11916 
    (2, TType.I32, 'scanType', None, None, ), # 2
11917 
  )
11918 
 
11919 
  def __init__(self, purchaseId=None, scanType=None,):
11920 
    self.purchaseId = purchaseId
11921 
    self.scanType = scanType
11922 
 
11923 
  def read(self, iprot):
11924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11926 
      return
11927 
    iprot.readStructBegin()
11928 
    while True:
11929 
      (fname, ftype, fid) = iprot.readFieldBegin()
11930 
      if ftype == TType.STOP:
11931 
        break
11932 
      if fid == 1:
11933 
        if ftype == TType.I64:
11934 
          self.purchaseId = iprot.readI64();
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      elif fid == 2:
11938 
        if ftype == TType.I32:
11939 
          self.scanType = iprot.readI32();
11940 
        else:
11941 
          iprot.skip(ftype)
11942 
      else:
11943 
        iprot.skip(ftype)
11944 
      iprot.readFieldEnd()
11945 
    iprot.readStructEnd()
11946 
 
11947 
  def write(self, oprot):
11948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11950 
      return
11951 
    oprot.writeStructBegin('getScansforPurchase_args')
11952 
    if self.purchaseId is not None:
11953 
      oprot.writeFieldBegin('purchaseId', TType.I64, 1)
11954 
      oprot.writeI64(self.purchaseId)
11955 
      oprot.writeFieldEnd()
11956 
    if self.scanType is not None:
11957 
      oprot.writeFieldBegin('scanType', TType.I32, 2)
11958 
      oprot.writeI32(self.scanType)
11959 
      oprot.writeFieldEnd()
11960 
    oprot.writeFieldStop()
11961 
    oprot.writeStructEnd()
11962 
 
11963 
  def validate(self):
11964 
    return
11965 
 
11966 
 
11967 
  def __repr__(self):
11968 
    L = ['%s=%r' % (key, value)
11969 
      for key, value in self.__dict__.iteritems()]
11970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11971 
 
11972 
  def __eq__(self, other):
11973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11974 
 
11975 
  def __ne__(self, other):
11976 
    return not (self == other)
11977 
 
11978 
class getScansforPurchase_result:
11979 
  """
11980 
  Attributes:
11981 
   - success
11982 
   - wex
11983 
  """
11984 
 
11985 
  thrift_spec = (
11986 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
11987 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
11988 
  )
11989 
 
11990 
  def __init__(self, success=None, wex=None,):
11991 
    self.success = success
11992 
    self.wex = wex
11993 
 
11994 
  def read(self, iprot):
11995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11997 
      return
11998 
    iprot.readStructBegin()
11999 
    while True:
12000 
      (fname, ftype, fid) = iprot.readFieldBegin()
12001 
      if ftype == TType.STOP:
12002 
        break
12003 
      if fid == 0:
12004 
        if ftype == TType.LIST:
12005 
          self.success = []
12006 
          (_etype257, _size254) = iprot.readListBegin()
12007 
          for _i258 in xrange(_size254):
12008 
            _elem259 = Scan()
12009 
            _elem259.read(iprot)
12010 
            self.success.append(_elem259)
12011 
          iprot.readListEnd()
12012 
        else:
12013 
          iprot.skip(ftype)
12014 
      elif fid == 1:
12015 
        if ftype == TType.STRUCT:
12016 
          self.wex = WarehouseServiceException()
12017 
          self.wex.read(iprot)
12018 
        else:
12019 
          iprot.skip(ftype)
12020 
      else:
12021 
        iprot.skip(ftype)
12022 
      iprot.readFieldEnd()
12023 
    iprot.readStructEnd()
12024 
 
12025 
  def write(self, oprot):
12026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12028 
      return
12029 
    oprot.writeStructBegin('getScansforPurchase_result')
12030 
    if self.success is not None:
12031 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12032 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12033 
      for iter260 in self.success:
12034 
        iter260.write(oprot)
12035 
      oprot.writeListEnd()
12036 
      oprot.writeFieldEnd()
12037 
    if self.wex is not None:
12038 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
12039 
      self.wex.write(oprot)
12040 
      oprot.writeFieldEnd()
12041 
    oprot.writeFieldStop()
12042 
    oprot.writeStructEnd()
12043 
 
12044 
  def validate(self):
12045 
    return
12046 
 
12047 
 
12048 
  def __repr__(self):
12049 
    L = ['%s=%r' % (key, value)
12050 
      for key, value in self.__dict__.iteritems()]
12051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12052 
 
12053 
  def __eq__(self, other):
12054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12055 
 
12056 
  def __ne__(self, other):
12057 
    return not (self == other)
10864 manish.sha 12058 
 
12059 
class getCurrentBadQuantityForItem_args:
12060 
  """
12061 
  Attributes:
12062 
   - itemId
12063 
   - currentWarehouseId
12064 
   - physicalWarehouseId
12065 
  """
12066 
 
12067 
  thrift_spec = (
12068 
    None, # 0
12069 
    (1, TType.I64, 'itemId', None, None, ), # 1
12070 
    (2, TType.I64, 'currentWarehouseId', None, None, ), # 2
12071 
    (3, TType.I64, 'physicalWarehouseId', None, None, ), # 3
12072 
  )
12073 
 
12074 
  def __init__(self, itemId=None, currentWarehouseId=None, physicalWarehouseId=None,):
12075 
    self.itemId = itemId
12076 
    self.currentWarehouseId = currentWarehouseId
12077 
    self.physicalWarehouseId = physicalWarehouseId
12078 
 
12079 
  def read(self, iprot):
12080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12082 
      return
12083 
    iprot.readStructBegin()
12084 
    while True:
12085 
      (fname, ftype, fid) = iprot.readFieldBegin()
12086 
      if ftype == TType.STOP:
12087 
        break
12088 
      if fid == 1:
12089 
        if ftype == TType.I64:
12090 
          self.itemId = iprot.readI64();
12091 
        else:
12092 
          iprot.skip(ftype)
12093 
      elif fid == 2:
12094 
        if ftype == TType.I64:
12095 
          self.currentWarehouseId = iprot.readI64();
12096 
        else:
12097 
          iprot.skip(ftype)
12098 
      elif fid == 3:
12099 
        if ftype == TType.I64:
12100 
          self.physicalWarehouseId = iprot.readI64();
12101 
        else:
12102 
          iprot.skip(ftype)
12103 
      else:
12104 
        iprot.skip(ftype)
12105 
      iprot.readFieldEnd()
12106 
    iprot.readStructEnd()
12107 
 
12108 
  def write(self, oprot):
12109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12111 
      return
12112 
    oprot.writeStructBegin('getCurrentBadQuantityForItem_args')
12113 
    if self.itemId is not None:
12114 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12115 
      oprot.writeI64(self.itemId)
12116 
      oprot.writeFieldEnd()
12117 
    if self.currentWarehouseId is not None:
12118 
      oprot.writeFieldBegin('currentWarehouseId', TType.I64, 2)
12119 
      oprot.writeI64(self.currentWarehouseId)
12120 
      oprot.writeFieldEnd()
12121 
    if self.physicalWarehouseId is not None:
12122 
      oprot.writeFieldBegin('physicalWarehouseId', TType.I64, 3)
12123 
      oprot.writeI64(self.physicalWarehouseId)
12124 
      oprot.writeFieldEnd()
12125 
    oprot.writeFieldStop()
12126 
    oprot.writeStructEnd()
12127 
 
12128 
  def validate(self):
12129 
    return
12130 
 
12131 
 
12132 
  def __repr__(self):
12133 
    L = ['%s=%r' % (key, value)
12134 
      for key, value in self.__dict__.iteritems()]
12135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12136 
 
12137 
  def __eq__(self, other):
12138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12139 
 
12140 
  def __ne__(self, other):
12141 
    return not (self == other)
12142 
 
12143 
class getCurrentBadQuantityForItem_result:
12144 
  """
12145 
  Attributes:
12146 
   - success
12147 
   - wex
12148 
  """
12149 
 
12150 
  thrift_spec = (
12151 
    (0, TType.I64, 'success', None, None, ), # 0
12152 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12153 
  )
12154 
 
12155 
  def __init__(self, success=None, wex=None,):
12156 
    self.success = success
12157 
    self.wex = wex
12158 
 
12159 
  def read(self, iprot):
12160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12162 
      return
12163 
    iprot.readStructBegin()
12164 
    while True:
12165 
      (fname, ftype, fid) = iprot.readFieldBegin()
12166 
      if ftype == TType.STOP:
12167 
        break
12168 
      if fid == 0:
12169 
        if ftype == TType.I64:
12170 
          self.success = iprot.readI64();
12171 
        else:
12172 
          iprot.skip(ftype)
12173 
      elif fid == 1:
12174 
        if ftype == TType.STRUCT:
12175 
          self.wex = WarehouseServiceException()
12176 
          self.wex.read(iprot)
12177 
        else:
12178 
          iprot.skip(ftype)
12179 
      else:
12180 
        iprot.skip(ftype)
12181 
      iprot.readFieldEnd()
12182 
    iprot.readStructEnd()
12183 
 
12184 
  def write(self, oprot):
12185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12187 
      return
12188 
    oprot.writeStructBegin('getCurrentBadQuantityForItem_result')
12189 
    if self.success is not None:
12190 
      oprot.writeFieldBegin('success', TType.I64, 0)
12191 
      oprot.writeI64(self.success)
12192 
      oprot.writeFieldEnd()
12193 
    if self.wex is not None:
12194 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
12195 
      self.wex.write(oprot)
12196 
      oprot.writeFieldEnd()
12197 
    oprot.writeFieldStop()
12198 
    oprot.writeStructEnd()
12199 
 
12200 
  def validate(self):
12201 
    return
12202 
 
12203 
 
12204 
  def __repr__(self):
12205 
    L = ['%s=%r' % (key, value)
12206 
      for key, value in self.__dict__.iteritems()]
12207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12208 
 
12209 
  def __eq__(self, other):
12210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12211 
 
12212 
  def __ne__(self, other):
12213 
    return not (self == other)
12214 
 
12215 
class scanForBadPurchaseReturn_args:
12216 
  """
12217 
  Attributes:
12218 
   - saleReturnItems
12219 
   - vendorId
12220 
   - billingWarehouseId
12221 
  """
12222 
 
12223 
  thrift_spec = (
12224 
    None, # 0
12225 
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
12226 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12227 
    (3, TType.I64, 'billingWarehouseId', None, None, ), # 3
12228 
  )
12229 
 
12230 
  def __init__(self, saleReturnItems=None, vendorId=None, billingWarehouseId=None,):
12231 
    self.saleReturnItems = saleReturnItems
12232 
    self.vendorId = vendorId
12233 
    self.billingWarehouseId = billingWarehouseId
12234 
 
12235 
  def read(self, iprot):
12236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12238 
      return
12239 
    iprot.readStructBegin()
12240 
    while True:
12241 
      (fname, ftype, fid) = iprot.readFieldBegin()
12242 
      if ftype == TType.STOP:
12243 
        break
12244 
      if fid == 1:
12245 
        if ftype == TType.LIST:
12246 
          self.saleReturnItems = []
12247 
          (_etype264, _size261) = iprot.readListBegin()
12248 
          for _i265 in xrange(_size261):
12249 
            _elem266 = InventoryItem()
12250 
            _elem266.read(iprot)
12251 
            self.saleReturnItems.append(_elem266)
12252 
          iprot.readListEnd()
12253 
        else:
12254 
          iprot.skip(ftype)
12255 
      elif fid == 2:
12256 
        if ftype == TType.I64:
12257 
          self.vendorId = iprot.readI64();
12258 
        else:
12259 
          iprot.skip(ftype)
12260 
      elif fid == 3:
12261 
        if ftype == TType.I64:
12262 
          self.billingWarehouseId = iprot.readI64();
12263 
        else:
12264 
          iprot.skip(ftype)
12265 
      else:
12266 
        iprot.skip(ftype)
12267 
      iprot.readFieldEnd()
12268 
    iprot.readStructEnd()
12269 
 
12270 
  def write(self, oprot):
12271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12273 
      return
12274 
    oprot.writeStructBegin('scanForBadPurchaseReturn_args')
12275 
    if self.saleReturnItems is not None:
12276 
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
12277 
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
12278 
      for iter267 in self.saleReturnItems:
12279 
        iter267.write(oprot)
12280 
      oprot.writeListEnd()
12281 
      oprot.writeFieldEnd()
12282 
    if self.vendorId is not None:
12283 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12284 
      oprot.writeI64(self.vendorId)
12285 
      oprot.writeFieldEnd()
12286 
    if self.billingWarehouseId is not None:
12287 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 3)
12288 
      oprot.writeI64(self.billingWarehouseId)
12289 
      oprot.writeFieldEnd()
12290 
    oprot.writeFieldStop()
12291 
    oprot.writeStructEnd()
12292 
 
12293 
  def validate(self):
12294 
    return
12295 
 
12296 
 
12297 
  def __repr__(self):
12298 
    L = ['%s=%r' % (key, value)
12299 
      for key, value in self.__dict__.iteritems()]
12300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12301 
 
12302 
  def __eq__(self, other):
12303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12304 
 
12305 
  def __ne__(self, other):
12306 
    return not (self == other)
12307 
 
12308 
class scanForBadPurchaseReturn_result:
12309 
  """
12310 
  Attributes:
12311 
   - success
12312 
   - ex
12313 
  """
12314 
 
12315 
  thrift_spec = (
12316 
    (0, TType.I64, 'success', None, None, ), # 0
12317 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12318 
  )
12319 
 
12320 
  def __init__(self, success=None, ex=None,):
12321 
    self.success = success
12322 
    self.ex = ex
12323 
 
12324 
  def read(self, iprot):
12325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12327 
      return
12328 
    iprot.readStructBegin()
12329 
    while True:
12330 
      (fname, ftype, fid) = iprot.readFieldBegin()
12331 
      if ftype == TType.STOP:
12332 
        break
12333 
      if fid == 0:
12334 
        if ftype == TType.I64:
12335 
          self.success = iprot.readI64();
12336 
        else:
12337 
          iprot.skip(ftype)
12338 
      elif fid == 1:
12339 
        if ftype == TType.STRUCT:
12340 
          self.ex = WarehouseServiceException()
12341 
          self.ex.read(iprot)
12342 
        else:
12343 
          iprot.skip(ftype)
12344 
      else:
12345 
        iprot.skip(ftype)
12346 
      iprot.readFieldEnd()
12347 
    iprot.readStructEnd()
12348 
 
12349 
  def write(self, oprot):
12350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12352 
      return
12353 
    oprot.writeStructBegin('scanForBadPurchaseReturn_result')
12354 
    if self.success is not None:
12355 
      oprot.writeFieldBegin('success', TType.I64, 0)
12356 
      oprot.writeI64(self.success)
12357 
      oprot.writeFieldEnd()
12358 
    if self.ex is not None:
12359 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12360 
      self.ex.write(oprot)
12361 
      oprot.writeFieldEnd()
12362 
    oprot.writeFieldStop()
12363 
    oprot.writeStructEnd()
12364 
 
12365 
  def validate(self):
12366 
    return
12367 
 
12368 
 
12369 
  def __repr__(self):
12370 
    L = ['%s=%r' % (key, value)
12371 
      for key, value in self.__dict__.iteritems()]
12372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12373 
 
12374 
  def __eq__(self, other):
12375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12376 
 
12377 
  def __ne__(self, other):
12378 
    return not (self == other)
12379 
 
12380 
class getItemsInPurchaseReturn_args:
12381 
  """
12382 
  Attributes:
12383 
   - purchaseReturnId
11751 manish.sha 12384 
   - type
10864 manish.sha 12385 
  """
12386 
 
12387 
  thrift_spec = (
12388 
    None, # 0
12389 
    (1, TType.I64, 'purchaseReturnId', None, None, ), # 1
11751 manish.sha 12390 
    (2, TType.I32, 'type', None, None, ), # 2
10864 manish.sha 12391 
  )
12392 
 
11751 manish.sha 12393 
  def __init__(self, purchaseReturnId=None, type=None,):
10864 manish.sha 12394 
    self.purchaseReturnId = purchaseReturnId
11751 manish.sha 12395 
    self.type = type
10864 manish.sha 12396 
 
12397 
  def read(self, iprot):
12398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12400 
      return
12401 
    iprot.readStructBegin()
12402 
    while True:
12403 
      (fname, ftype, fid) = iprot.readFieldBegin()
12404 
      if ftype == TType.STOP:
12405 
        break
12406 
      if fid == 1:
12407 
        if ftype == TType.I64:
12408 
          self.purchaseReturnId = iprot.readI64();
12409 
        else:
12410 
          iprot.skip(ftype)
11751 manish.sha 12411 
      elif fid == 2:
12412 
        if ftype == TType.I32:
12413 
          self.type = iprot.readI32();
12414 
        else:
12415 
          iprot.skip(ftype)
10864 manish.sha 12416 
      else:
12417 
        iprot.skip(ftype)
12418 
      iprot.readFieldEnd()
12419 
    iprot.readStructEnd()
12420 
 
12421 
  def write(self, oprot):
12422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12424 
      return
12425 
    oprot.writeStructBegin('getItemsInPurchaseReturn_args')
12426 
    if self.purchaseReturnId is not None:
12427 
      oprot.writeFieldBegin('purchaseReturnId', TType.I64, 1)
12428 
      oprot.writeI64(self.purchaseReturnId)
12429 
      oprot.writeFieldEnd()
11751 manish.sha 12430 
    if self.type is not None:
12431 
      oprot.writeFieldBegin('type', TType.I32, 2)
12432 
      oprot.writeI32(self.type)
12433 
      oprot.writeFieldEnd()
10864 manish.sha 12434 
    oprot.writeFieldStop()
12435 
    oprot.writeStructEnd()
12436 
 
12437 
  def validate(self):
12438 
    return
12439 
 
12440 
 
12441 
  def __repr__(self):
12442 
    L = ['%s=%r' % (key, value)
12443 
      for key, value in self.__dict__.iteritems()]
12444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12445 
 
12446 
  def __eq__(self, other):
12447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12448 
 
12449 
  def __ne__(self, other):
12450 
    return not (self == other)
12451 
 
12452 
class getItemsInPurchaseReturn_result:
12453 
  """
12454 
  Attributes:
12455 
   - success
12456 
   - ex
12457 
  """
12458 
 
12459 
  thrift_spec = (
12460 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
12461 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12462 
  )
12463 
 
12464 
  def __init__(self, success=None, ex=None,):
12465 
    self.success = success
12466 
    self.ex = ex
12467 
 
12468 
  def read(self, iprot):
12469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12471 
      return
12472 
    iprot.readStructBegin()
12473 
    while True:
12474 
      (fname, ftype, fid) = iprot.readFieldBegin()
12475 
      if ftype == TType.STOP:
12476 
        break
12477 
      if fid == 0:
12478 
        if ftype == TType.MAP:
12479 
          self.success = {}
12480 
          (_ktype269, _vtype270, _size268 ) = iprot.readMapBegin()
12481 
          for _i272 in xrange(_size268):
12482 
            _key273 = iprot.readI64();
12483 
            _val274 = iprot.readI64();
12484 
            self.success[_key273] = _val274
12485 
          iprot.readMapEnd()
12486 
        else:
12487 
          iprot.skip(ftype)
12488 
      elif fid == 1:
12489 
        if ftype == TType.STRUCT:
12490 
          self.ex = WarehouseServiceException()
12491 
          self.ex.read(iprot)
12492 
        else:
12493 
          iprot.skip(ftype)
12494 
      else:
12495 
        iprot.skip(ftype)
12496 
      iprot.readFieldEnd()
12497 
    iprot.readStructEnd()
12498 
 
12499 
  def write(self, oprot):
12500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12502 
      return
12503 
    oprot.writeStructBegin('getItemsInPurchaseReturn_result')
12504 
    if self.success is not None:
12505 
      oprot.writeFieldBegin('success', TType.MAP, 0)
12506 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
12507 
      for kiter275,viter276 in self.success.items():
12508 
        oprot.writeI64(kiter275)
12509 
        oprot.writeI64(viter276)
12510 
      oprot.writeMapEnd()
12511 
      oprot.writeFieldEnd()
12512 
    if self.ex is not None:
12513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12514 
      self.ex.write(oprot)
12515 
      oprot.writeFieldEnd()
12516 
    oprot.writeFieldStop()
12517 
    oprot.writeStructEnd()
12518 
 
12519 
  def validate(self):
12520 
    return
12521 
 
12522 
 
12523 
  def __repr__(self):
12524 
    L = ['%s=%r' % (key, value)
12525 
      for key, value in self.__dict__.iteritems()]
12526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12527 
 
12528 
  def __eq__(self, other):
12529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12530 
 
12531 
  def __ne__(self, other):
12532 
    return not (self == other)
10886 manish.sha 12533 
 
12534 
class getScansForInventoryItem_args:
12535 
  """
12536 
  Attributes:
12537 
   - inventoryItemId
12538 
   - type
12539 
  """
12540 
 
12541 
  thrift_spec = (
12542 
    None, # 0
12543 
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
12544 
    (2, TType.I32, 'type', None, None, ), # 2
12545 
  )
12546 
 
12547 
  def __init__(self, inventoryItemId=None, type=None,):
12548 
    self.inventoryItemId = inventoryItemId
12549 
    self.type = type
12550 
 
12551 
  def read(self, iprot):
12552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12554 
      return
12555 
    iprot.readStructBegin()
12556 
    while True:
12557 
      (fname, ftype, fid) = iprot.readFieldBegin()
12558 
      if ftype == TType.STOP:
12559 
        break
12560 
      if fid == 1:
12561 
        if ftype == TType.I64:
12562 
          self.inventoryItemId = iprot.readI64();
12563 
        else:
12564 
          iprot.skip(ftype)
12565 
      elif fid == 2:
12566 
        if ftype == TType.I32:
12567 
          self.type = iprot.readI32();
12568 
        else:
12569 
          iprot.skip(ftype)
12570 
      else:
12571 
        iprot.skip(ftype)
12572 
      iprot.readFieldEnd()
12573 
    iprot.readStructEnd()
12574 
 
12575 
  def write(self, oprot):
12576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12578 
      return
12579 
    oprot.writeStructBegin('getScansForInventoryItem_args')
12580 
    if self.inventoryItemId is not None:
12581 
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
12582 
      oprot.writeI64(self.inventoryItemId)
12583 
      oprot.writeFieldEnd()
12584 
    if self.type is not None:
12585 
      oprot.writeFieldBegin('type', TType.I32, 2)
12586 
      oprot.writeI32(self.type)
12587 
      oprot.writeFieldEnd()
12588 
    oprot.writeFieldStop()
12589 
    oprot.writeStructEnd()
12590 
 
12591 
  def validate(self):
12592 
    return
12593 
 
12594 
 
12595 
  def __repr__(self):
12596 
    L = ['%s=%r' % (key, value)
12597 
      for key, value in self.__dict__.iteritems()]
12598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12599 
 
12600 
  def __eq__(self, other):
12601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12602 
 
12603 
  def __ne__(self, other):
12604 
    return not (self == other)
12605 
 
12606 
class getScansForInventoryItem_result:
12607 
  """
12608 
  Attributes:
12609 
   - success
12610 
   - ex
12611 
  """
12612 
 
12613 
  thrift_spec = (
12614 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
12615 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12616 
  )
12617 
 
12618 
  def __init__(self, success=None, ex=None,):
12619 
    self.success = success
12620 
    self.ex = ex
12621 
 
12622 
  def read(self, iprot):
12623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12625 
      return
12626 
    iprot.readStructBegin()
12627 
    while True:
12628 
      (fname, ftype, fid) = iprot.readFieldBegin()
12629 
      if ftype == TType.STOP:
12630 
        break
12631 
      if fid == 0:
12632 
        if ftype == TType.LIST:
12633 
          self.success = []
12634 
          (_etype280, _size277) = iprot.readListBegin()
12635 
          for _i281 in xrange(_size277):
12636 
            _elem282 = Scan()
12637 
            _elem282.read(iprot)
12638 
            self.success.append(_elem282)
12639 
          iprot.readListEnd()
12640 
        else:
12641 
          iprot.skip(ftype)
12642 
      elif fid == 1:
12643 
        if ftype == TType.STRUCT:
12644 
          self.ex = WarehouseServiceException()
12645 
          self.ex.read(iprot)
12646 
        else:
12647 
          iprot.skip(ftype)
12648 
      else:
12649 
        iprot.skip(ftype)
12650 
      iprot.readFieldEnd()
12651 
    iprot.readStructEnd()
12652 
 
12653 
  def write(self, oprot):
12654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12656 
      return
12657 
    oprot.writeStructBegin('getScansForInventoryItem_result')
12658 
    if self.success is not None:
12659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12661 
      for iter283 in self.success:
12662 
        iter283.write(oprot)
12663 
      oprot.writeListEnd()
12664 
      oprot.writeFieldEnd()
12665 
    if self.ex is not None:
12666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12667 
      self.ex.write(oprot)
12668 
      oprot.writeFieldEnd()
12669 
    oprot.writeFieldStop()
12670 
    oprot.writeStructEnd()
12671 
 
12672 
  def validate(self):
12673 
    return
12674 
 
12675 
 
12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12531 manish.sha 12686 
 
12687 
class checkGrnImeiStatus_args:
12688 
  """
12689 
  Attributes:
12690 
   - imeiNos
12691 
  """
12692 
 
12693 
  thrift_spec = (
12694 
    None, # 0
12695 
    (1, TType.LIST, 'imeiNos', (TType.STRING,None), None, ), # 1
12696 
  )
12697 
 
12698 
  def __init__(self, imeiNos=None,):
12699 
    self.imeiNos = imeiNos
12700 
 
12701 
  def read(self, iprot):
12702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12704 
      return
12705 
    iprot.readStructBegin()
12706 
    while True:
12707 
      (fname, ftype, fid) = iprot.readFieldBegin()
12708 
      if ftype == TType.STOP:
12709 
        break
12710 
      if fid == 1:
12711 
        if ftype == TType.LIST:
12712 
          self.imeiNos = []
12713 
          (_etype287, _size284) = iprot.readListBegin()
12714 
          for _i288 in xrange(_size284):
12715 
            _elem289 = iprot.readString();
12716 
            self.imeiNos.append(_elem289)
12717 
          iprot.readListEnd()
12718 
        else:
12719 
          iprot.skip(ftype)
12720 
      else:
12721 
        iprot.skip(ftype)
12722 
      iprot.readFieldEnd()
12723 
    iprot.readStructEnd()
12724 
 
12725 
  def write(self, oprot):
12726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12728 
      return
12729 
    oprot.writeStructBegin('checkGrnImeiStatus_args')
12730 
    if self.imeiNos is not None:
12731 
      oprot.writeFieldBegin('imeiNos', TType.LIST, 1)
12732 
      oprot.writeListBegin(TType.STRING, len(self.imeiNos))
12733 
      for iter290 in self.imeiNos:
12734 
        oprot.writeString(iter290)
12735 
      oprot.writeListEnd()
12736 
      oprot.writeFieldEnd()
12737 
    oprot.writeFieldStop()
12738 
    oprot.writeStructEnd()
12739 
 
12740 
  def validate(self):
12741 
    return
12742 
 
12743 
 
12744 
  def __repr__(self):
12745 
    L = ['%s=%r' % (key, value)
12746 
      for key, value in self.__dict__.iteritems()]
12747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12748 
 
12749 
  def __eq__(self, other):
12750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12751 
 
12752 
  def __ne__(self, other):
12753 
    return not (self == other)
12754 
 
12755 
class checkGrnImeiStatus_result:
12756 
  """
12757 
  Attributes:
12758 
   - success
12759 
   - ex
12760 
  """
12761 
 
12762 
  thrift_spec = (
12763 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
12764 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12765 
  )
12766 
 
12767 
  def __init__(self, success=None, ex=None,):
12768 
    self.success = success
12769 
    self.ex = ex
12770 
 
12771 
  def read(self, iprot):
12772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12774 
      return
12775 
    iprot.readStructBegin()
12776 
    while True:
12777 
      (fname, ftype, fid) = iprot.readFieldBegin()
12778 
      if ftype == TType.STOP:
12779 
        break
12780 
      if fid == 0:
12781 
        if ftype == TType.LIST:
12782 
          self.success = []
12783 
          (_etype294, _size291) = iprot.readListBegin()
12784 
          for _i295 in xrange(_size291):
12785 
            _elem296 = iprot.readString();
12786 
            self.success.append(_elem296)
12787 
          iprot.readListEnd()
12788 
        else:
12789 
          iprot.skip(ftype)
12790 
      elif fid == 1:
12791 
        if ftype == TType.STRUCT:
12792 
          self.ex = WarehouseServiceException()
12793 
          self.ex.read(iprot)
12794 
        else:
12795 
          iprot.skip(ftype)
12796 
      else:
12797 
        iprot.skip(ftype)
12798 
      iprot.readFieldEnd()
12799 
    iprot.readStructEnd()
12800 
 
12801 
  def write(self, oprot):
12802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12804 
      return
12805 
    oprot.writeStructBegin('checkGrnImeiStatus_result')
12806 
    if self.success is not None:
12807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12808 
      oprot.writeListBegin(TType.STRING, len(self.success))
12809 
      for iter297 in self.success:
12810 
        oprot.writeString(iter297)
12811 
      oprot.writeListEnd()
12812 
      oprot.writeFieldEnd()
12813 
    if self.ex is not None:
12814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12815 
      self.ex.write(oprot)
12816 
      oprot.writeFieldEnd()
12817 
    oprot.writeFieldStop()
12818 
    oprot.writeStructEnd()
12819 
 
12820 
  def validate(self):
12821 
    return
12822 
 
12823 
 
12824 
  def __repr__(self):
12825 
    L = ['%s=%r' % (key, value)
12826 
      for key, value in self.__dict__.iteritems()]
12827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12828 
 
12829 
  def __eq__(self, other):
12830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12831 
 
12832 
  def __ne__(self, other):
12833 
    return not (self == other)
12800 manish.sha 12834 
 
12835 
class getInventoryAgeConsideredItems_args:
12836 
  """
12837 
  Attributes:
12838 
   - itemId
12839 
  """
12840 
 
12841 
  thrift_spec = (
12842 
    None, # 0
12843 
    (1, TType.I64, 'itemId', None, None, ), # 1
12844 
  )
12845 
 
12846 
  def __init__(self, itemId=None,):
12847 
    self.itemId = itemId
12848 
 
12849 
  def read(self, iprot):
12850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12852 
      return
12853 
    iprot.readStructBegin()
12854 
    while True:
12855 
      (fname, ftype, fid) = iprot.readFieldBegin()
12856 
      if ftype == TType.STOP:
12857 
        break
12858 
      if fid == 1:
12859 
        if ftype == TType.I64:
12860 
          self.itemId = iprot.readI64();
12861 
        else:
12862 
          iprot.skip(ftype)
12863 
      else:
12864 
        iprot.skip(ftype)
12865 
      iprot.readFieldEnd()
12866 
    iprot.readStructEnd()
12867 
 
12868 
  def write(self, oprot):
12869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12871 
      return
12872 
    oprot.writeStructBegin('getInventoryAgeConsideredItems_args')
12873 
    if self.itemId is not None:
12874 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
12875 
      oprot.writeI64(self.itemId)
12876 
      oprot.writeFieldEnd()
12877 
    oprot.writeFieldStop()
12878 
    oprot.writeStructEnd()
12879 
 
12880 
  def validate(self):
12881 
    return
12882 
 
12883 
 
12884 
  def __repr__(self):
12885 
    L = ['%s=%r' % (key, value)
12886 
      for key, value in self.__dict__.iteritems()]
12887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12888 
 
12889 
  def __eq__(self, other):
12890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12891 
 
12892 
  def __ne__(self, other):
12893 
    return not (self == other)
12894 
 
12895 
class getInventoryAgeConsideredItems_result:
12896 
  """
12897 
  Attributes:
12898 
   - success
12899 
   - ex
12900 
  """
12901 
 
12902 
  thrift_spec = (
12903 
    (0, TType.LIST, 'success', (TType.STRUCT,(InvAgeConsiderItems, InvAgeConsiderItems.thrift_spec)), None, ), # 0
12904 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
12905 
  )
12906 
 
12907 
  def __init__(self, success=None, ex=None,):
12908 
    self.success = success
12909 
    self.ex = ex
12910 
 
12911 
  def read(self, iprot):
12912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12914 
      return
12915 
    iprot.readStructBegin()
12916 
    while True:
12917 
      (fname, ftype, fid) = iprot.readFieldBegin()
12918 
      if ftype == TType.STOP:
12919 
        break
12920 
      if fid == 0:
12921 
        if ftype == TType.LIST:
12922 
          self.success = []
12923 
          (_etype301, _size298) = iprot.readListBegin()
12924 
          for _i302 in xrange(_size298):
12925 
            _elem303 = InvAgeConsiderItems()
12926 
            _elem303.read(iprot)
12927 
            self.success.append(_elem303)
12928 
          iprot.readListEnd()
12929 
        else:
12930 
          iprot.skip(ftype)
12931 
      elif fid == 1:
12932 
        if ftype == TType.STRUCT:
12933 
          self.ex = WarehouseServiceException()
12934 
          self.ex.read(iprot)
12935 
        else:
12936 
          iprot.skip(ftype)
12937 
      else:
12938 
        iprot.skip(ftype)
12939 
      iprot.readFieldEnd()
12940 
    iprot.readStructEnd()
12941 
 
12942 
  def write(self, oprot):
12943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12945 
      return
12946 
    oprot.writeStructBegin('getInventoryAgeConsideredItems_result')
12947 
    if self.success is not None:
12948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12950 
      for iter304 in self.success:
12951 
        iter304.write(oprot)
12952 
      oprot.writeListEnd()
12953 
      oprot.writeFieldEnd()
12954 
    if self.ex is not None:
12955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12956 
      self.ex.write(oprot)
12957 
      oprot.writeFieldEnd()
12958 
    oprot.writeFieldStop()
12959 
    oprot.writeStructEnd()
12960 
 
12961 
  def validate(self):
12962 
    return
12963 
 
12964 
 
12965 
  def __repr__(self):
12966 
    L = ['%s=%r' % (key, value)
12967 
      for key, value in self.__dict__.iteritems()]
12968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12969 
 
12970 
  def __eq__(self, other):
12971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12972 
 
12973 
  def __ne__(self, other):
12974 
    return not (self == other)