Subversion Repositories SmartDukaan

Rev

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