Subversion Repositories SmartDukaan

Rev

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