Subversion Repositories SmartDukaan

Rev

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