Subversion Repositories SmartDukaan

Rev

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