Subversion Repositories SmartDukaan

Rev

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