Subversion Repositories SmartDukaan

Rev

Rev 7718 | Rev 8565 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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