Subversion Repositories SmartDukaan

Rev

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

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