Subversion Repositories SmartDukaan

Rev

Rev 7199 | Rev 7410 | 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 
 
5361 mandeep.dh 40 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
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
2821 chandransh 49 
    """
50 
    pass
51 
 
5110 mandeep.dh 52 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 53 
    """
54 
    Scan serialized items linked with an order. Returns its price.
2821 chandransh 55 
 
4501 mandeep.dh 56 
    Parameters:
4555 mandeep.dh 57 
     - serialNumber
4501 mandeep.dh 58 
     - type
59 
     - orderId
5110 mandeep.dh 60 
     - fulfilmentWarehouseId
61 
     - quantity
62 
     - billingWarehouseId
4501 mandeep.dh 63 
    """
64 
    pass
65 
 
5361 mandeep.dh 66 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 67 
    """
68 
    Scan non-serialized items linked with an order.
69 
 
70 
    Parameters:
5361 mandeep.dh 71 
     - inventoryItem
4501 mandeep.dh 72 
     - type
73 
     - quantity
74 
     - orderId
5110 mandeep.dh 75 
     - fulfilmentWarehouseId
5361 mandeep.dh 76 
     - billingWarehouseId
4501 mandeep.dh 77 
    """
78 
    pass
79 
 
80 
  def createItemNumberMapping(self, itemNumber, itemId):
81 
    """
82 
    Created item number to item id mapping
83 
 
84 
    Parameters:
85 
     - itemNumber
86 
     - itemId
87 
    """
88 
    pass
89 
 
4620 amit.gupta 90 
  def getItemNumbers(self, itemId):
91 
    """
92 
    Get itemNumber mappings for itemId
4501 mandeep.dh 93 
 
4620 amit.gupta 94 
    Parameters:
95 
     - itemId
96 
    """
97 
    pass
98 
 
5110 mandeep.dh 99 
  def getItemIds(self, itemNumber):
100 
    """
101 
    Gets item ids for a given item number
4620 amit.gupta 102 
 
5110 mandeep.dh 103 
    Parameters:
104 
     - itemNumber
105 
    """
106 
    pass
107 
 
5185 mandeep.dh 108 
  def getInventoryItemsFromLastScanType(self, lastScanType):
109 
    """
110 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 111 
 
5185 mandeep.dh 112 
    Parameters:
113 
     - lastScanType
114 
    """
115 
    pass
116 
 
117 
  def getInventoryItemFromId(self, inventoryItemId):
118 
    """
119 
    Retrieves inventory item given a inventoryItem id
120 
 
121 
    Parameters:
122 
     - inventoryItemId
123 
    """
124 
    pass
125 
 
5372 mandeep.dh 126 
  def getPurchaseScans(self, startDate, endDate):
127 
    """
128 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 129 
 
5372 mandeep.dh 130 
    Parameters:
131 
     - startDate
132 
     - endDate
133 
    """
134 
    pass
135 
 
7216 amar.kumar 136 
  def getPurchaseScansByGrnDate(self, startDate, endDate):
137 
    """
138 
    Returns the purchase scans between grn dates grouped by items for Purchase register reconciliation
139 
 
140 
    Parameters:
141 
     - startDate
142 
     - endDate
143 
    """
144 
    pass
145 
 
5496 mandeep.dh 146 
  def fetchScansPerInvoiceNumber(self, date):
147 
    """
148 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 149 
 
5496 mandeep.dh 150 
    Parameters:
151 
     - date
152 
    """
153 
    pass
154 
 
5620 mandeep.dh 155 
  def getInventoryItemFromOrder(self, orderId):
156 
    """
157 
    Returns inventory item for a given order
5496 mandeep.dh 158 
 
5620 mandeep.dh 159 
    Parameters:
160 
     - orderId
161 
    """
162 
    pass
163 
 
5711 mandeep.dh 164 
  def getInventoryAge(self, ):
165 
    """
166 
    Fetches the stock inventory age week-wise
167 
    """
168 
    pass
5620 mandeep.dh 169 
 
6361 rajveer 170 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
171 
    """
172 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 173 
 
6361 rajveer 174 
    Parameters:
175 
     - itemId
176 
     - fromDate
177 
     - toDate
178 
    """
179 
    pass
180 
 
181 
  def getScanRecordsForSerialNumber(self, serialNumber):
182 
    """
183 
    Fetches the scanRecords for a given serialNumber for a given time interval
184 
 
185 
    Parameters:
186 
     - serialNumber
187 
    """
188 
    pass
189 
 
6467 amar.kumar 190 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
191 
    """
6630 amar.kumar 192 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 193 
 
6467 amar.kumar 194 
    Parameters:
195 
     - saleReturnItems
196 
     - vendorId
197 
    """
198 
    pass
199 
 
6630 amar.kumar 200 
  def scanForLostItem(self, lostItems, vendorId):
201 
    """
202 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 203 
 
6630 amar.kumar 204 
    Parameters:
205 
     - lostItems
206 
     - vendorId
207 
    """
208 
    pass
209 
 
210 
  def getCurrentSerializedInventoryByScans(self, ):
211 
    """
212 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
213 
    """
214 
    pass
215 
 
216 
  def getCurrentNonSerializedInventoryByScans(self, ):
217 
    """
218 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
219 
    """
220 
    pass
221 
 
6762 amar.kumar 222 
  def getHistoricSerializedInventoryByScans(self, date):
223 
    """
224 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
6630 amar.kumar 225 
 
6762 amar.kumar 226 
    Parameters:
227 
     - date
228 
    """
229 
    pass
230 
 
231 
  def getHistoricNonSerializedInventoryByScans(self, date):
232 
    """
233 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
234 
 
235 
    Parameters:
236 
     - date
237 
    """
238 
    pass
239 
 
240 
  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
241 
    """
6880 amar.kumar 242 
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 243 
 
244 
    Parameters:
245 
     - itemId
246 
     - serialNumber
247 
     - itemNumber
248 
     - invoiceNumber
249 
     - warehouseId
250 
     - unitPrice
251 
     - orderId
252 
    """
253 
    pass
254 
 
255 
  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
256 
    """
6880 amar.kumar 257 
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 258 
 
259 
    Parameters:
260 
     - orderId
261 
     - unitPrice
262 
    """
263 
    pass
264 
 
6880 amar.kumar 265 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
266 
    """
267 
    Parameters:
268 
     - startDate
269 
     - endDate
270 
    """
271 
    pass
6762 amar.kumar 272 
 
6880 amar.kumar 273 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
274 
    """
275 
    Parameters:
276 
     - startDate
277 
     - endDate
278 
    """
279 
    pass
280 
 
7216 amar.kumar 281 
  def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
282 
    """
283 
    Parameters:
284 
     - startDate
285 
     - endDate
286 
    """
287 
    pass
288 
 
289 
  def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
290 
    """
291 
    Parameters:
292 
     - startDate
293 
     - endDate
294 
    """
295 
    pass
296 
 
7190 amar.kumar 297 
  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
298 
    """
299 
    Parameters:
300 
     - orderId
301 
     - freebieItemId
302 
     - freebieWarehouseId
303 
     - scanType
304 
    """
305 
    pass
6880 amar.kumar 306 
 
7199 amar.kumar 307 
  def reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
308 
    """
309 
    Parameters:
310 
     - oldOrderId
311 
     - newOrderId
312 
     - freebieItemId
313 
     - scanType
314 
    """
315 
    pass
7190 amar.kumar 316 
 
7199 amar.kumar 317 
 
3376 rajveer 318 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
2821 chandransh 319 
  def __init__(self, iprot, oprot=None):
3376 rajveer 320 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
2821 chandransh 321 
 
4501 mandeep.dh 322 
  def getInventoryItem(self, serialNumber):
2832 chandransh 323 
    """
4501 mandeep.dh 324 
    Retrieves serialized inventory item given a serial number
3431 rajveer 325 
 
2832 chandransh 326 
    Parameters:
4501 mandeep.dh 327 
     - serialNumber
2832 chandransh 328 
    """
4501 mandeep.dh 329 
    self.send_getInventoryItem(serialNumber)
330 
    return self.recv_getInventoryItem()
2832 chandransh 331 
 
4501 mandeep.dh 332 
  def send_getInventoryItem(self, serialNumber):
333 
    self._oprot.writeMessageBegin('getInventoryItem', TMessageType.CALL, self._seqid)
334 
    args = getInventoryItem_args()
335 
    args.serialNumber = serialNumber
2832 chandransh 336 
    args.write(self._oprot)
337 
    self._oprot.writeMessageEnd()
338 
    self._oprot.trans.flush()
339 
 
4501 mandeep.dh 340 
  def recv_getInventoryItem(self, ):
2832 chandransh 341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
342 
    if mtype == TMessageType.EXCEPTION:
343 
      x = TApplicationException()
344 
      x.read(self._iprot)
345 
      self._iprot.readMessageEnd()
346 
      raise x
4501 mandeep.dh 347 
    result = getInventoryItem_result()
2832 chandransh 348 
    result.read(self._iprot)
349 
    self._iprot.readMessageEnd()
3431 rajveer 350 
    if result.success is not None:
2832 chandransh 351 
      return result.success
4541 mandeep.dh 352 
    if result.wex is not None:
353 
      raise result.wex
4501 mandeep.dh 354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItem failed: unknown result");
2832 chandransh 355 
 
5530 mandeep.dh 356 
  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
2821 chandransh 357 
    """
5361 mandeep.dh 358 
    Retrieves non-serialized inventory item from a given supplier
3431 rajveer 359 
 
2821 chandransh 360 
    Parameters:
5530 mandeep.dh 361 
     - itemNumber
4501 mandeep.dh 362 
     - itemId
5530 mandeep.dh 363 
     - fulfilmentWarehouseId
2821 chandransh 364 
    """
5530 mandeep.dh 365 
    self.send_getNonSeralizedInventoryItem(itemNumber, itemId, fulfilmentWarehouseId)
5361 mandeep.dh 366 
    return self.recv_getNonSeralizedInventoryItem()
2821 chandransh 367 
 
5530 mandeep.dh 368 
  def send_getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
5361 mandeep.dh 369 
    self._oprot.writeMessageBegin('getNonSeralizedInventoryItem', TMessageType.CALL, self._seqid)
370 
    args = getNonSeralizedInventoryItem_args()
5530 mandeep.dh 371 
    args.itemNumber = itemNumber
4501 mandeep.dh 372 
    args.itemId = itemId
5530 mandeep.dh 373 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 374 
    args.write(self._oprot)
375 
    self._oprot.writeMessageEnd()
376 
    self._oprot.trans.flush()
377 
 
5361 mandeep.dh 378 
  def recv_getNonSeralizedInventoryItem(self, ):
2821 chandransh 379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
380 
    if mtype == TMessageType.EXCEPTION:
381 
      x = TApplicationException()
382 
      x.read(self._iprot)
383 
      self._iprot.readMessageEnd()
384 
      raise x
5361 mandeep.dh 385 
    result = getNonSeralizedInventoryItem_result()
2821 chandransh 386 
    result.read(self._iprot)
387 
    self._iprot.readMessageEnd()
3431 rajveer 388 
    if result.success is not None:
2821 chandransh 389 
      return result.success
5361 mandeep.dh 390 
    if result.wex is not None:
391 
      raise result.wex
392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");
2821 chandransh 393 
 
5361 mandeep.dh 394 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
3383 chandransh 395 
    """
4501 mandeep.dh 396 
    Scan non-serialized items.
3431 rajveer 397 
 
2821 chandransh 398 
    Parameters:
5361 mandeep.dh 399 
     - inventoryItem
2821 chandransh 400 
     - type
4501 mandeep.dh 401 
     - quantity
5361 mandeep.dh 402 
     - billingWarehouseId
2821 chandransh 403 
    """
5361 mandeep.dh 404 
    self.send_scan(inventoryItem, type, quantity, billingWarehouseId)
4501 mandeep.dh 405 
    self.recv_scan()
2821 chandransh 406 
 
5361 mandeep.dh 407 
  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId):
4501 mandeep.dh 408 
    self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
409 
    args = scan_args()
5361 mandeep.dh 410 
    args.inventoryItem = inventoryItem
2821 chandransh 411 
    args.type = type
4501 mandeep.dh 412 
    args.quantity = quantity
5361 mandeep.dh 413 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 414 
    args.write(self._oprot)
415 
    self._oprot.writeMessageEnd()
416 
    self._oprot.trans.flush()
417 
 
4501 mandeep.dh 418 
  def recv_scan(self, ):
2821 chandransh 419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
420 
    if mtype == TMessageType.EXCEPTION:
421 
      x = TApplicationException()
422 
      x.read(self._iprot)
423 
      self._iprot.readMessageEnd()
424 
      raise x
4501 mandeep.dh 425 
    result = scan_result()
2821 chandransh 426 
    result.read(self._iprot)
427 
    self._iprot.readMessageEnd()
3431 rajveer 428 
    if result.wex is not None:
2821 chandransh 429 
      raise result.wex
430 
    return
431 
 
5110 mandeep.dh 432 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
2821 chandransh 433 
    """
4501 mandeep.dh 434 
    Scan serialized items linked with an order. Returns its price.
3431 rajveer 435 
 
2821 chandransh 436 
    Parameters:
4555 mandeep.dh 437 
     - serialNumber
2821 chandransh 438 
     - type
4501 mandeep.dh 439 
     - orderId
5110 mandeep.dh 440 
     - fulfilmentWarehouseId
441 
     - quantity
442 
     - billingWarehouseId
2821 chandransh 443 
    """
5110 mandeep.dh 444 
    self.send_scanSerializedItemForOrder(serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
4501 mandeep.dh 445 
    return self.recv_scanSerializedItemForOrder()
2821 chandransh 446 
 
5110 mandeep.dh 447 
  def send_scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 448 
    self._oprot.writeMessageBegin('scanSerializedItemForOrder', TMessageType.CALL, self._seqid)
449 
    args = scanSerializedItemForOrder_args()
4555 mandeep.dh 450 
    args.serialNumber = serialNumber
2821 chandransh 451 
    args.type = type
4501 mandeep.dh 452 
    args.orderId = orderId
5110 mandeep.dh 453 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
454 
    args.quantity = quantity
455 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 456 
    args.write(self._oprot)
457 
    self._oprot.writeMessageEnd()
458 
    self._oprot.trans.flush()
459 
 
4501 mandeep.dh 460 
  def recv_scanSerializedItemForOrder(self, ):
2821 chandransh 461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
462 
    if mtype == TMessageType.EXCEPTION:
463 
      x = TApplicationException()
464 
      x.read(self._iprot)
465 
      self._iprot.readMessageEnd()
466 
      raise x
4501 mandeep.dh 467 
    result = scanSerializedItemForOrder_result()
2821 chandransh 468 
    result.read(self._iprot)
469 
    self._iprot.readMessageEnd()
4501 mandeep.dh 470 
    if result.success is not None:
471 
      return result.success
3431 rajveer 472 
    if result.wex is not None:
2821 chandransh 473 
      raise result.wex
4501 mandeep.dh 474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanSerializedItemForOrder failed: unknown result");
475 
 
5361 mandeep.dh 476 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 477 
    """
478 
    Scan non-serialized items linked with an order.
479 
 
480 
    Parameters:
5361 mandeep.dh 481 
     - inventoryItem
4501 mandeep.dh 482 
     - type
483 
     - quantity
484 
     - orderId
5110 mandeep.dh 485 
     - fulfilmentWarehouseId
5361 mandeep.dh 486 
     - billingWarehouseId
4501 mandeep.dh 487 
    """
5361 mandeep.dh 488 
    self.send_scanForOrder(inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId)
489 
    return self.recv_scanForOrder()
4501 mandeep.dh 490 
 
5361 mandeep.dh 491 
  def send_scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 492 
    self._oprot.writeMessageBegin('scanForOrder', TMessageType.CALL, self._seqid)
493 
    args = scanForOrder_args()
5361 mandeep.dh 494 
    args.inventoryItem = inventoryItem
4501 mandeep.dh 495 
    args.type = type
496 
    args.quantity = quantity
497 
    args.orderId = orderId
5110 mandeep.dh 498 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 499 
    args.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 500 
    args.write(self._oprot)
501 
    self._oprot.writeMessageEnd()
502 
    self._oprot.trans.flush()
503 
 
504 
  def recv_scanForOrder(self, ):
505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
506 
    if mtype == TMessageType.EXCEPTION:
507 
      x = TApplicationException()
508 
      x.read(self._iprot)
509 
      self._iprot.readMessageEnd()
510 
      raise x
511 
    result = scanForOrder_result()
512 
    result.read(self._iprot)
513 
    self._iprot.readMessageEnd()
5361 mandeep.dh 514 
    if result.success is not None:
515 
      return result.success
4501 mandeep.dh 516 
    if result.wex is not None:
517 
      raise result.wex
5361 mandeep.dh 518 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOrder failed: unknown result");
2821 chandransh 519 
 
4501 mandeep.dh 520 
  def createItemNumberMapping(self, itemNumber, itemId):
521 
    """
522 
    Created item number to item id mapping
2821 chandransh 523 
 
4501 mandeep.dh 524 
    Parameters:
525 
     - itemNumber
526 
     - itemId
527 
    """
528 
    self.send_createItemNumberMapping(itemNumber, itemId)
529 
    self.recv_createItemNumberMapping()
530 
 
531 
  def send_createItemNumberMapping(self, itemNumber, itemId):
532 
    self._oprot.writeMessageBegin('createItemNumberMapping', TMessageType.CALL, self._seqid)
533 
    args = createItemNumberMapping_args()
534 
    args.itemNumber = itemNumber
535 
    args.itemId = itemId
536 
    args.write(self._oprot)
537 
    self._oprot.writeMessageEnd()
538 
    self._oprot.trans.flush()
539 
 
540 
  def recv_createItemNumberMapping(self, ):
541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
542 
    if mtype == TMessageType.EXCEPTION:
543 
      x = TApplicationException()
544 
      x.read(self._iprot)
545 
      self._iprot.readMessageEnd()
546 
      raise x
547 
    result = createItemNumberMapping_result()
548 
    result.read(self._iprot)
549 
    self._iprot.readMessageEnd()
550 
    return
551 
 
4620 amit.gupta 552 
  def getItemNumbers(self, itemId):
553 
    """
554 
    Get itemNumber mappings for itemId
4501 mandeep.dh 555 
 
4620 amit.gupta 556 
    Parameters:
557 
     - itemId
558 
    """
559 
    self.send_getItemNumbers(itemId)
560 
    return self.recv_getItemNumbers()
561 
 
562 
  def send_getItemNumbers(self, itemId):
563 
    self._oprot.writeMessageBegin('getItemNumbers', TMessageType.CALL, self._seqid)
564 
    args = getItemNumbers_args()
565 
    args.itemId = itemId
566 
    args.write(self._oprot)
567 
    self._oprot.writeMessageEnd()
568 
    self._oprot.trans.flush()
569 
 
570 
  def recv_getItemNumbers(self, ):
571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
572 
    if mtype == TMessageType.EXCEPTION:
573 
      x = TApplicationException()
574 
      x.read(self._iprot)
575 
      self._iprot.readMessageEnd()
576 
      raise x
577 
    result = getItemNumbers_result()
578 
    result.read(self._iprot)
579 
    self._iprot.readMessageEnd()
580 
    if result.success is not None:
581 
      return result.success
582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemNumbers failed: unknown result");
583 
 
5110 mandeep.dh 584 
  def getItemIds(self, itemNumber):
585 
    """
586 
    Gets item ids for a given item number
4620 amit.gupta 587 
 
5110 mandeep.dh 588 
    Parameters:
589 
     - itemNumber
590 
    """
591 
    self.send_getItemIds(itemNumber)
592 
    return self.recv_getItemIds()
593 
 
594 
  def send_getItemIds(self, itemNumber):
595 
    self._oprot.writeMessageBegin('getItemIds', TMessageType.CALL, self._seqid)
596 
    args = getItemIds_args()
597 
    args.itemNumber = itemNumber
598 
    args.write(self._oprot)
599 
    self._oprot.writeMessageEnd()
600 
    self._oprot.trans.flush()
601 
 
602 
  def recv_getItemIds(self, ):
603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
604 
    if mtype == TMessageType.EXCEPTION:
605 
      x = TApplicationException()
606 
      x.read(self._iprot)
607 
      self._iprot.readMessageEnd()
608 
      raise x
609 
    result = getItemIds_result()
610 
    result.read(self._iprot)
611 
    self._iprot.readMessageEnd()
612 
    if result.success is not None:
613 
      return result.success
614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemIds failed: unknown result");
615 
 
5185 mandeep.dh 616 
  def getInventoryItemsFromLastScanType(self, lastScanType):
617 
    """
618 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 619 
 
5185 mandeep.dh 620 
    Parameters:
621 
     - lastScanType
622 
    """
623 
    self.send_getInventoryItemsFromLastScanType(lastScanType)
624 
    return self.recv_getInventoryItemsFromLastScanType()
625 
 
626 
  def send_getInventoryItemsFromLastScanType(self, lastScanType):
627 
    self._oprot.writeMessageBegin('getInventoryItemsFromLastScanType', TMessageType.CALL, self._seqid)
628 
    args = getInventoryItemsFromLastScanType_args()
629 
    args.lastScanType = lastScanType
630 
    args.write(self._oprot)
631 
    self._oprot.writeMessageEnd()
632 
    self._oprot.trans.flush()
633 
 
634 
  def recv_getInventoryItemsFromLastScanType(self, ):
635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
636 
    if mtype == TMessageType.EXCEPTION:
637 
      x = TApplicationException()
638 
      x.read(self._iprot)
639 
      self._iprot.readMessageEnd()
640 
      raise x
641 
    result = getInventoryItemsFromLastScanType_result()
642 
    result.read(self._iprot)
643 
    self._iprot.readMessageEnd()
644 
    if result.success is not None:
645 
      return result.success
646 
    if result.wex is not None:
647 
      raise result.wex
648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsFromLastScanType failed: unknown result");
649 
 
650 
  def getInventoryItemFromId(self, inventoryItemId):
651 
    """
652 
    Retrieves inventory item given a inventoryItem id
653 
 
654 
    Parameters:
655 
     - inventoryItemId
656 
    """
657 
    self.send_getInventoryItemFromId(inventoryItemId)
658 
    return self.recv_getInventoryItemFromId()
659 
 
660 
  def send_getInventoryItemFromId(self, inventoryItemId):
661 
    self._oprot.writeMessageBegin('getInventoryItemFromId', TMessageType.CALL, self._seqid)
662 
    args = getInventoryItemFromId_args()
663 
    args.inventoryItemId = inventoryItemId
664 
    args.write(self._oprot)
665 
    self._oprot.writeMessageEnd()
666 
    self._oprot.trans.flush()
667 
 
668 
  def recv_getInventoryItemFromId(self, ):
669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
670 
    if mtype == TMessageType.EXCEPTION:
671 
      x = TApplicationException()
672 
      x.read(self._iprot)
673 
      self._iprot.readMessageEnd()
674 
      raise x
675 
    result = getInventoryItemFromId_result()
676 
    result.read(self._iprot)
677 
    self._iprot.readMessageEnd()
678 
    if result.success is not None:
679 
      return result.success
680 
    if result.wex is not None:
681 
      raise result.wex
682 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromId failed: unknown result");
683 
 
5372 mandeep.dh 684 
  def getPurchaseScans(self, startDate, endDate):
685 
    """
686 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 687 
 
5372 mandeep.dh 688 
    Parameters:
689 
     - startDate
690 
     - endDate
691 
    """
692 
    self.send_getPurchaseScans(startDate, endDate)
693 
    return self.recv_getPurchaseScans()
694 
 
695 
  def send_getPurchaseScans(self, startDate, endDate):
696 
    self._oprot.writeMessageBegin('getPurchaseScans', TMessageType.CALL, self._seqid)
697 
    args = getPurchaseScans_args()
698 
    args.startDate = startDate
699 
    args.endDate = endDate
700 
    args.write(self._oprot)
701 
    self._oprot.writeMessageEnd()
702 
    self._oprot.trans.flush()
703 
 
704 
  def recv_getPurchaseScans(self, ):
705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
706 
    if mtype == TMessageType.EXCEPTION:
707 
      x = TApplicationException()
708 
      x.read(self._iprot)
709 
      self._iprot.readMessageEnd()
710 
      raise x
711 
    result = getPurchaseScans_result()
712 
    result.read(self._iprot)
713 
    self._iprot.readMessageEnd()
714 
    if result.success is not None:
715 
      return result.success
716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScans failed: unknown result");
717 
 
7216 amar.kumar 718 
  def getPurchaseScansByGrnDate(self, startDate, endDate):
719 
    """
720 
    Returns the purchase scans between grn dates grouped by items for Purchase register reconciliation
721 
 
722 
    Parameters:
723 
     - startDate
724 
     - endDate
725 
    """
726 
    self.send_getPurchaseScansByGrnDate(startDate, endDate)
727 
    return self.recv_getPurchaseScansByGrnDate()
728 
 
729 
  def send_getPurchaseScansByGrnDate(self, startDate, endDate):
730 
    self._oprot.writeMessageBegin('getPurchaseScansByGrnDate', TMessageType.CALL, self._seqid)
731 
    args = getPurchaseScansByGrnDate_args()
732 
    args.startDate = startDate
733 
    args.endDate = endDate
734 
    args.write(self._oprot)
735 
    self._oprot.writeMessageEnd()
736 
    self._oprot.trans.flush()
737 
 
738 
  def recv_getPurchaseScansByGrnDate(self, ):
739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
740 
    if mtype == TMessageType.EXCEPTION:
741 
      x = TApplicationException()
742 
      x.read(self._iprot)
743 
      self._iprot.readMessageEnd()
744 
      raise x
745 
    result = getPurchaseScansByGrnDate_result()
746 
    result.read(self._iprot)
747 
    self._iprot.readMessageEnd()
748 
    if result.success is not None:
749 
      return result.success
750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScansByGrnDate failed: unknown result");
751 
 
5496 mandeep.dh 752 
  def fetchScansPerInvoiceNumber(self, date):
753 
    """
754 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 755 
 
5496 mandeep.dh 756 
    Parameters:
757 
     - date
758 
    """
759 
    self.send_fetchScansPerInvoiceNumber(date)
760 
    return self.recv_fetchScansPerInvoiceNumber()
761 
 
762 
  def send_fetchScansPerInvoiceNumber(self, date):
763 
    self._oprot.writeMessageBegin('fetchScansPerInvoiceNumber', TMessageType.CALL, self._seqid)
764 
    args = fetchScansPerInvoiceNumber_args()
765 
    args.date = date
766 
    args.write(self._oprot)
767 
    self._oprot.writeMessageEnd()
768 
    self._oprot.trans.flush()
769 
 
770 
  def recv_fetchScansPerInvoiceNumber(self, ):
771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
772 
    if mtype == TMessageType.EXCEPTION:
773 
      x = TApplicationException()
774 
      x.read(self._iprot)
775 
      self._iprot.readMessageEnd()
776 
      raise x
777 
    result = fetchScansPerInvoiceNumber_result()
778 
    result.read(self._iprot)
779 
    self._iprot.readMessageEnd()
780 
    if result.success is not None:
781 
      return result.success
782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerInvoiceNumber failed: unknown result");
783 
 
5620 mandeep.dh 784 
  def getInventoryItemFromOrder(self, orderId):
785 
    """
786 
    Returns inventory item for a given order
5496 mandeep.dh 787 
 
5620 mandeep.dh 788 
    Parameters:
789 
     - orderId
790 
    """
791 
    self.send_getInventoryItemFromOrder(orderId)
792 
    return self.recv_getInventoryItemFromOrder()
793 
 
794 
  def send_getInventoryItemFromOrder(self, orderId):
795 
    self._oprot.writeMessageBegin('getInventoryItemFromOrder', TMessageType.CALL, self._seqid)
796 
    args = getInventoryItemFromOrder_args()
797 
    args.orderId = orderId
798 
    args.write(self._oprot)
799 
    self._oprot.writeMessageEnd()
800 
    self._oprot.trans.flush()
801 
 
802 
  def recv_getInventoryItemFromOrder(self, ):
803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
804 
    if mtype == TMessageType.EXCEPTION:
805 
      x = TApplicationException()
806 
      x.read(self._iprot)
807 
      self._iprot.readMessageEnd()
808 
      raise x
809 
    result = getInventoryItemFromOrder_result()
810 
    result.read(self._iprot)
811 
    self._iprot.readMessageEnd()
812 
    if result.success is not None:
813 
      return result.success
814 
    if result.we is not None:
815 
      raise result.we
816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromOrder failed: unknown result");
817 
 
5711 mandeep.dh 818 
  def getInventoryAge(self, ):
819 
    """
820 
    Fetches the stock inventory age week-wise
821 
    """
822 
    self.send_getInventoryAge()
823 
    return self.recv_getInventoryAge()
5620 mandeep.dh 824 
 
5711 mandeep.dh 825 
  def send_getInventoryAge(self, ):
826 
    self._oprot.writeMessageBegin('getInventoryAge', TMessageType.CALL, self._seqid)
827 
    args = getInventoryAge_args()
828 
    args.write(self._oprot)
829 
    self._oprot.writeMessageEnd()
830 
    self._oprot.trans.flush()
831 
 
832 
  def recv_getInventoryAge(self, ):
833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
834 
    if mtype == TMessageType.EXCEPTION:
835 
      x = TApplicationException()
836 
      x.read(self._iprot)
837 
      self._iprot.readMessageEnd()
838 
      raise x
839 
    result = getInventoryAge_result()
840 
    result.read(self._iprot)
841 
    self._iprot.readMessageEnd()
842 
    if result.success is not None:
843 
      return result.success
844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAge failed: unknown result");
845 
 
6361 rajveer 846 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
847 
    """
848 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 849 
 
6361 rajveer 850 
    Parameters:
851 
     - itemId
852 
     - fromDate
853 
     - toDate
854 
    """
855 
    self.send_getInventoryScansForItem(itemId, fromDate, toDate)
856 
    return self.recv_getInventoryScansForItem()
857 
 
858 
  def send_getInventoryScansForItem(self, itemId, fromDate, toDate):
859 
    self._oprot.writeMessageBegin('getInventoryScansForItem', TMessageType.CALL, self._seqid)
860 
    args = getInventoryScansForItem_args()
861 
    args.itemId = itemId
862 
    args.fromDate = fromDate
863 
    args.toDate = toDate
864 
    args.write(self._oprot)
865 
    self._oprot.writeMessageEnd()
866 
    self._oprot.trans.flush()
867 
 
868 
  def recv_getInventoryScansForItem(self, ):
869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
870 
    if mtype == TMessageType.EXCEPTION:
871 
      x = TApplicationException()
872 
      x.read(self._iprot)
873 
      self._iprot.readMessageEnd()
874 
      raise x
875 
    result = getInventoryScansForItem_result()
876 
    result.read(self._iprot)
877 
    self._iprot.readMessageEnd()
878 
    if result.success is not None:
879 
      return result.success
880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryScansForItem failed: unknown result");
881 
 
882 
  def getScanRecordsForSerialNumber(self, serialNumber):
883 
    """
884 
    Fetches the scanRecords for a given serialNumber for a given time interval
885 
 
886 
    Parameters:
887 
     - serialNumber
888 
    """
889 
    self.send_getScanRecordsForSerialNumber(serialNumber)
890 
    return self.recv_getScanRecordsForSerialNumber()
891 
 
892 
  def send_getScanRecordsForSerialNumber(self, serialNumber):
893 
    self._oprot.writeMessageBegin('getScanRecordsForSerialNumber', TMessageType.CALL, self._seqid)
894 
    args = getScanRecordsForSerialNumber_args()
895 
    args.serialNumber = serialNumber
896 
    args.write(self._oprot)
897 
    self._oprot.writeMessageEnd()
898 
    self._oprot.trans.flush()
899 
 
900 
  def recv_getScanRecordsForSerialNumber(self, ):
901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
902 
    if mtype == TMessageType.EXCEPTION:
903 
      x = TApplicationException()
904 
      x.read(self._iprot)
905 
      self._iprot.readMessageEnd()
906 
      raise x
907 
    result = getScanRecordsForSerialNumber_result()
908 
    result.read(self._iprot)
909 
    self._iprot.readMessageEnd()
910 
    if result.success is not None:
911 
      return result.success
912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScanRecordsForSerialNumber failed: unknown result");
913 
 
6467 amar.kumar 914 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
915 
    """
6630 amar.kumar 916 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 917 
 
6467 amar.kumar 918 
    Parameters:
919 
     - saleReturnItems
920 
     - vendorId
921 
    """
922 
    self.send_scanForPurchaseReturn(saleReturnItems, vendorId)
923 
    self.recv_scanForPurchaseReturn()
924 
 
925 
  def send_scanForPurchaseReturn(self, saleReturnItems, vendorId):
926 
    self._oprot.writeMessageBegin('scanForPurchaseReturn', TMessageType.CALL, self._seqid)
927 
    args = scanForPurchaseReturn_args()
928 
    args.saleReturnItems = saleReturnItems
929 
    args.vendorId = vendorId
930 
    args.write(self._oprot)
931 
    self._oprot.writeMessageEnd()
932 
    self._oprot.trans.flush()
933 
 
934 
  def recv_scanForPurchaseReturn(self, ):
935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
936 
    if mtype == TMessageType.EXCEPTION:
937 
      x = TApplicationException()
938 
      x.read(self._iprot)
939 
      self._iprot.readMessageEnd()
940 
      raise x
941 
    result = scanForPurchaseReturn_result()
942 
    result.read(self._iprot)
943 
    self._iprot.readMessageEnd()
944 
    if result.ex is not None:
945 
      raise result.ex
946 
    return
947 
 
6630 amar.kumar 948 
  def scanForLostItem(self, lostItems, vendorId):
949 
    """
950 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 951 
 
6630 amar.kumar 952 
    Parameters:
953 
     - lostItems
954 
     - vendorId
955 
    """
956 
    self.send_scanForLostItem(lostItems, vendorId)
957 
    self.recv_scanForLostItem()
958 
 
959 
  def send_scanForLostItem(self, lostItems, vendorId):
960 
    self._oprot.writeMessageBegin('scanForLostItem', TMessageType.CALL, self._seqid)
961 
    args = scanForLostItem_args()
962 
    args.lostItems = lostItems
963 
    args.vendorId = vendorId
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_scanForLostItem(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = scanForLostItem_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
978 
    if result.ex is not None:
979 
      raise result.ex
980 
    return
981 
 
982 
  def getCurrentSerializedInventoryByScans(self, ):
983 
    """
984 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
985 
    """
986 
    self.send_getCurrentSerializedInventoryByScans()
987 
    return self.recv_getCurrentSerializedInventoryByScans()
988 
 
989 
  def send_getCurrentSerializedInventoryByScans(self, ):
990 
    self._oprot.writeMessageBegin('getCurrentSerializedInventoryByScans', TMessageType.CALL, self._seqid)
991 
    args = getCurrentSerializedInventoryByScans_args()
992 
    args.write(self._oprot)
993 
    self._oprot.writeMessageEnd()
994 
    self._oprot.trans.flush()
995 
 
996 
  def recv_getCurrentSerializedInventoryByScans(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 = getCurrentSerializedInventoryByScans_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, "getCurrentSerializedInventoryByScans failed: unknown result");
1009 
 
1010 
  def getCurrentNonSerializedInventoryByScans(self, ):
1011 
    """
1012 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
1013 
    """
1014 
    self.send_getCurrentNonSerializedInventoryByScans()
1015 
    return self.recv_getCurrentNonSerializedInventoryByScans()
1016 
 
1017 
  def send_getCurrentNonSerializedInventoryByScans(self, ):
1018 
    self._oprot.writeMessageBegin('getCurrentNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1019 
    args = getCurrentNonSerializedInventoryByScans_args()
1020 
    args.write(self._oprot)
1021 
    self._oprot.writeMessageEnd()
1022 
    self._oprot.trans.flush()
1023 
 
1024 
  def recv_getCurrentNonSerializedInventoryByScans(self, ):
1025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1026 
    if mtype == TMessageType.EXCEPTION:
1027 
      x = TApplicationException()
1028 
      x.read(self._iprot)
1029 
      self._iprot.readMessageEnd()
1030 
      raise x
1031 
    result = getCurrentNonSerializedInventoryByScans_result()
1032 
    result.read(self._iprot)
1033 
    self._iprot.readMessageEnd()
1034 
    if result.success is not None:
1035 
      return result.success
1036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentNonSerializedInventoryByScans failed: unknown result");
1037 
 
6762 amar.kumar 1038 
  def getHistoricSerializedInventoryByScans(self, date):
1039 
    """
1040 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
6630 amar.kumar 1041 
 
6762 amar.kumar 1042 
    Parameters:
1043 
     - date
1044 
    """
1045 
    self.send_getHistoricSerializedInventoryByScans(date)
1046 
    return self.recv_getHistoricSerializedInventoryByScans()
1047 
 
1048 
  def send_getHistoricSerializedInventoryByScans(self, date):
1049 
    self._oprot.writeMessageBegin('getHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1050 
    args = getHistoricSerializedInventoryByScans_args()
1051 
    args.date = date
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_getHistoricSerializedInventoryByScans(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = getHistoricSerializedInventoryByScans_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
1066 
    if result.success is not None:
1067 
      return result.success
1068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricSerializedInventoryByScans failed: unknown result");
1069 
 
1070 
  def getHistoricNonSerializedInventoryByScans(self, date):
1071 
    """
1072 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
1073 
 
1074 
    Parameters:
1075 
     - date
1076 
    """
1077 
    self.send_getHistoricNonSerializedInventoryByScans(date)
1078 
    return self.recv_getHistoricNonSerializedInventoryByScans()
1079 
 
1080 
  def send_getHistoricNonSerializedInventoryByScans(self, date):
1081 
    self._oprot.writeMessageBegin('getHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1082 
    args = getHistoricNonSerializedInventoryByScans_args()
1083 
    args.date = date
1084 
    args.write(self._oprot)
1085 
    self._oprot.writeMessageEnd()
1086 
    self._oprot.trans.flush()
1087 
 
1088 
  def recv_getHistoricNonSerializedInventoryByScans(self, ):
1089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1090 
    if mtype == TMessageType.EXCEPTION:
1091 
      x = TApplicationException()
1092 
      x.read(self._iprot)
1093 
      self._iprot.readMessageEnd()
1094 
      raise x
1095 
    result = getHistoricNonSerializedInventoryByScans_result()
1096 
    result.read(self._iprot)
1097 
    self._iprot.readMessageEnd()
1098 
    if result.success is not None:
1099 
      return result.success
1100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricNonSerializedInventoryByScans failed: unknown result");
1101 
 
1102 
  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
1103 
    """
6880 amar.kumar 1104 
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1105 
 
1106 
    Parameters:
1107 
     - itemId
1108 
     - serialNumber
1109 
     - itemNumber
1110 
     - invoiceNumber
1111 
     - warehouseId
1112 
     - unitPrice
1113 
     - orderId
1114 
    """
1115 
    self.send_scanForOursExternalSale(itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId)
1116 
    return self.recv_scanForOursExternalSale()
1117 
 
1118 
  def send_scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
1119 
    self._oprot.writeMessageBegin('scanForOursExternalSale', TMessageType.CALL, self._seqid)
1120 
    args = scanForOursExternalSale_args()
1121 
    args.itemId = itemId
1122 
    args.serialNumber = serialNumber
1123 
    args.itemNumber = itemNumber
1124 
    args.invoiceNumber = invoiceNumber
1125 
    args.warehouseId = warehouseId
1126 
    args.unitPrice = unitPrice
1127 
    args.orderId = orderId
1128 
    args.write(self._oprot)
1129 
    self._oprot.writeMessageEnd()
1130 
    self._oprot.trans.flush()
1131 
 
1132 
  def recv_scanForOursExternalSale(self, ):
1133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1134 
    if mtype == TMessageType.EXCEPTION:
1135 
      x = TApplicationException()
1136 
      x.read(self._iprot)
1137 
      self._iprot.readMessageEnd()
1138 
      raise x
1139 
    result = scanForOursExternalSale_result()
1140 
    result.read(self._iprot)
1141 
    self._iprot.readMessageEnd()
1142 
    if result.success is not None:
1143 
      return result.success
1144 
    if result.ex is not None:
1145 
      raise result.ex
1146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOursExternalSale failed: unknown result");
1147 
 
1148 
  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
1149 
    """
6880 amar.kumar 1150 
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1151 
 
1152 
    Parameters:
1153 
     - orderId
1154 
     - unitPrice
1155 
    """
1156 
    self.send_scanForOursExternalSaleReturn(orderId, unitPrice)
1157 
    self.recv_scanForOursExternalSaleReturn()
1158 
 
1159 
  def send_scanForOursExternalSaleReturn(self, orderId, unitPrice):
1160 
    self._oprot.writeMessageBegin('scanForOursExternalSaleReturn', TMessageType.CALL, self._seqid)
1161 
    args = scanForOursExternalSaleReturn_args()
1162 
    args.orderId = orderId
1163 
    args.unitPrice = unitPrice
1164 
    args.write(self._oprot)
1165 
    self._oprot.writeMessageEnd()
1166 
    self._oprot.trans.flush()
1167 
 
1168 
  def recv_scanForOursExternalSaleReturn(self, ):
1169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1170 
    if mtype == TMessageType.EXCEPTION:
1171 
      x = TApplicationException()
1172 
      x.read(self._iprot)
1173 
      self._iprot.readMessageEnd()
1174 
      raise x
1175 
    result = scanForOursExternalSaleReturn_result()
1176 
    result.read(self._iprot)
1177 
    self._iprot.readMessageEnd()
1178 
    return
1179 
 
6880 amar.kumar 1180 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1181 
    """
1182 
    Parameters:
1183 
     - startDate
1184 
     - endDate
1185 
    """
1186 
    self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
1187 
    return self.recv_getMovementNonSerializedInventoryByScans()
6762 amar.kumar 1188 
 
6880 amar.kumar 1189 
  def send_getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1190 
    self._oprot.writeMessageBegin('getMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1191 
    args = getMovementNonSerializedInventoryByScans_args()
1192 
    args.startDate = startDate
1193 
    args.endDate = endDate
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getMovementNonSerializedInventoryByScans(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getMovementNonSerializedInventoryByScans_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.success is not None:
1209 
      return result.success
1210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");
1211 
 
1212 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
1213 
    """
1214 
    Parameters:
1215 
     - startDate
1216 
     - endDate
1217 
    """
1218 
    self.send_getMovementSerializedInventoryByScans(startDate, endDate)
1219 
    return self.recv_getMovementSerializedInventoryByScans()
1220 
 
1221 
  def send_getMovementSerializedInventoryByScans(self, startDate, endDate):
1222 
    self._oprot.writeMessageBegin('getMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1223 
    args = getMovementSerializedInventoryByScans_args()
1224 
    args.startDate = startDate
1225 
    args.endDate = endDate
1226 
    args.write(self._oprot)
1227 
    self._oprot.writeMessageEnd()
1228 
    self._oprot.trans.flush()
1229 
 
1230 
  def recv_getMovementSerializedInventoryByScans(self, ):
1231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1232 
    if mtype == TMessageType.EXCEPTION:
1233 
      x = TApplicationException()
1234 
      x.read(self._iprot)
1235 
      self._iprot.readMessageEnd()
1236 
      raise x
1237 
    result = getMovementSerializedInventoryByScans_result()
1238 
    result.read(self._iprot)
1239 
    self._iprot.readMessageEnd()
1240 
    if result.success is not None:
1241 
      return result.success
1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");
1243 
 
7216 amar.kumar 1244 
  def getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
1245 
    """
1246 
    Parameters:
1247 
     - startDate
1248 
     - endDate
1249 
    """
1250 
    self.send_getCompleteMovementSerializedInventoryByScans(startDate, endDate)
1251 
    return self.recv_getCompleteMovementSerializedInventoryByScans()
1252 
 
1253 
  def send_getCompleteMovementSerializedInventoryByScans(self, startDate, endDate):
1254 
    self._oprot.writeMessageBegin('getCompleteMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1255 
    args = getCompleteMovementSerializedInventoryByScans_args()
1256 
    args.startDate = startDate
1257 
    args.endDate = endDate
1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
1262 
  def recv_getCompleteMovementSerializedInventoryByScans(self, ):
1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
1269 
    result = getCompleteMovementSerializedInventoryByScans_result()
1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
1272 
    if result.success is not None:
1273 
      return result.success
1274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementSerializedInventoryByScans failed: unknown result");
1275 
 
1276 
  def getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
1277 
    """
1278 
    Parameters:
1279 
     - startDate
1280 
     - endDate
1281 
    """
1282 
    self.send_getCompleteMovementNonSerializedInventoryByScans(startDate, endDate)
1283 
    return self.recv_getCompleteMovementNonSerializedInventoryByScans()
1284 
 
1285 
  def send_getCompleteMovementNonSerializedInventoryByScans(self, startDate, endDate):
1286 
    self._oprot.writeMessageBegin('getCompleteMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1287 
    args = getCompleteMovementNonSerializedInventoryByScans_args()
1288 
    args.startDate = startDate
1289 
    args.endDate = endDate
1290 
    args.write(self._oprot)
1291 
    self._oprot.writeMessageEnd()
1292 
    self._oprot.trans.flush()
1293 
 
1294 
  def recv_getCompleteMovementNonSerializedInventoryByScans(self, ):
1295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1296 
    if mtype == TMessageType.EXCEPTION:
1297 
      x = TApplicationException()
1298 
      x.read(self._iprot)
1299 
      self._iprot.readMessageEnd()
1300 
      raise x
1301 
    result = getCompleteMovementNonSerializedInventoryByScans_result()
1302 
    result.read(self._iprot)
1303 
    self._iprot.readMessageEnd()
1304 
    if result.success is not None:
1305 
      return result.success
1306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCompleteMovementNonSerializedInventoryByScans failed: unknown result");
1307 
 
7190 amar.kumar 1308 
  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1309 
    """
1310 
    Parameters:
1311 
     - orderId
1312 
     - freebieItemId
1313 
     - freebieWarehouseId
1314 
     - scanType
1315 
    """
1316 
    self.send_scanfreebie(orderId, freebieItemId, freebieWarehouseId, scanType)
1317 
    return self.recv_scanfreebie()
6880 amar.kumar 1318 
 
7190 amar.kumar 1319 
  def send_scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1320 
    self._oprot.writeMessageBegin('scanfreebie', TMessageType.CALL, self._seqid)
1321 
    args = scanfreebie_args()
1322 
    args.orderId = orderId
1323 
    args.freebieItemId = freebieItemId
1324 
    args.freebieWarehouseId = freebieWarehouseId
1325 
    args.scanType = scanType
1326 
    args.write(self._oprot)
1327 
    self._oprot.writeMessageEnd()
1328 
    self._oprot.trans.flush()
1329 
 
1330 
  def recv_scanfreebie(self, ):
1331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1332 
    if mtype == TMessageType.EXCEPTION:
1333 
      x = TApplicationException()
1334 
      x.read(self._iprot)
1335 
      self._iprot.readMessageEnd()
1336 
      raise x
1337 
    result = scanfreebie_result()
1338 
    result.read(self._iprot)
1339 
    self._iprot.readMessageEnd()
1340 
    if result.success is not None:
1341 
      return result.success
1342 
    if result.wex is not None:
1343 
      raise result.wex
1344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanfreebie failed: unknown result");
1345 
 
7199 amar.kumar 1346 
  def reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
1347 
    """
1348 
    Parameters:
1349 
     - oldOrderId
1350 
     - newOrderId
1351 
     - freebieItemId
1352 
     - scanType
1353 
    """
1354 
    self.send_reshipfreebie(oldOrderId, newOrderId, freebieItemId, scanType)
1355 
    self.recv_reshipfreebie()
7190 amar.kumar 1356 
 
7199 amar.kumar 1357 
  def send_reshipfreebie(self, oldOrderId, newOrderId, freebieItemId, scanType):
1358 
    self._oprot.writeMessageBegin('reshipfreebie', TMessageType.CALL, self._seqid)
1359 
    args = reshipfreebie_args()
1360 
    args.oldOrderId = oldOrderId
1361 
    args.newOrderId = newOrderId
1362 
    args.freebieItemId = freebieItemId
1363 
    args.scanType = scanType
1364 
    args.write(self._oprot)
1365 
    self._oprot.writeMessageEnd()
1366 
    self._oprot.trans.flush()
1367 
 
1368 
  def recv_reshipfreebie(self, ):
1369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1370 
    if mtype == TMessageType.EXCEPTION:
1371 
      x = TApplicationException()
1372 
      x.read(self._iprot)
1373 
      self._iprot.readMessageEnd()
1374 
      raise x
1375 
    result = reshipfreebie_result()
1376 
    result.read(self._iprot)
1377 
    self._iprot.readMessageEnd()
1378 
    if result.wex is not None:
1379 
      raise result.wex
1380 
    return
1381 
 
1382 
 
3376 rajveer 1383 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
2821 chandransh 1384 
  def __init__(self, handler):
3376 rajveer 1385 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4501 mandeep.dh 1386 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
5361 mandeep.dh 1387 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
4501 mandeep.dh 1388 
    self._processMap["scan"] = Processor.process_scan
1389 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
1390 
    self._processMap["scanForOrder"] = Processor.process_scanForOrder
1391 
    self._processMap["createItemNumberMapping"] = Processor.process_createItemNumberMapping
4620 amit.gupta 1392 
    self._processMap["getItemNumbers"] = Processor.process_getItemNumbers
5110 mandeep.dh 1393 
    self._processMap["getItemIds"] = Processor.process_getItemIds
5185 mandeep.dh 1394 
    self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
1395 
    self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
5372 mandeep.dh 1396 
    self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
7216 amar.kumar 1397 
    self._processMap["getPurchaseScansByGrnDate"] = Processor.process_getPurchaseScansByGrnDate
5496 mandeep.dh 1398 
    self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
5620 mandeep.dh 1399 
    self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
5711 mandeep.dh 1400 
    self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
6361 rajveer 1401 
    self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
1402 
    self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
6467 amar.kumar 1403 
    self._processMap["scanForPurchaseReturn"] = Processor.process_scanForPurchaseReturn
6630 amar.kumar 1404 
    self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
1405 
    self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
1406 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
6762 amar.kumar 1407 
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
1408 
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
1409 
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
1410 
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
6880 amar.kumar 1411 
    self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
1412 
    self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
7216 amar.kumar 1413 
    self._processMap["getCompleteMovementSerializedInventoryByScans"] = Processor.process_getCompleteMovementSerializedInventoryByScans
1414 
    self._processMap["getCompleteMovementNonSerializedInventoryByScans"] = Processor.process_getCompleteMovementNonSerializedInventoryByScans
7190 amar.kumar 1415 
    self._processMap["scanfreebie"] = Processor.process_scanfreebie
7199 amar.kumar 1416 
    self._processMap["reshipfreebie"] = Processor.process_reshipfreebie
2821 chandransh 1417 
 
1418 
  def process(self, iprot, oprot):
1419 
    (name, type, seqid) = iprot.readMessageBegin()
1420 
    if name not in self._processMap:
1421 
      iprot.skip(TType.STRUCT)
1422 
      iprot.readMessageEnd()
1423 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1424 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1425 
      x.write(oprot)
1426 
      oprot.writeMessageEnd()
1427 
      oprot.trans.flush()
1428 
      return
1429 
    else:
1430 
      self._processMap[name](self, seqid, iprot, oprot)
1431 
    return True
1432 
 
4501 mandeep.dh 1433 
  def process_getInventoryItem(self, seqid, iprot, oprot):
1434 
    args = getInventoryItem_args()
2832 chandransh 1435 
    args.read(iprot)
1436 
    iprot.readMessageEnd()
4501 mandeep.dh 1437 
    result = getInventoryItem_result()
4541 mandeep.dh 1438 
    try:
1439 
      result.success = self._handler.getInventoryItem(args.serialNumber)
1440 
    except WarehouseServiceException, wex:
1441 
      result.wex = wex
4501 mandeep.dh 1442 
    oprot.writeMessageBegin("getInventoryItem", TMessageType.REPLY, seqid)
2832 chandransh 1443 
    result.write(oprot)
1444 
    oprot.writeMessageEnd()
1445 
    oprot.trans.flush()
1446 
 
5361 mandeep.dh 1447 
  def process_getNonSeralizedInventoryItem(self, seqid, iprot, oprot):
1448 
    args = getNonSeralizedInventoryItem_args()
2821 chandransh 1449 
    args.read(iprot)
1450 
    iprot.readMessageEnd()
5361 mandeep.dh 1451 
    result = getNonSeralizedInventoryItem_result()
1452 
    try:
5530 mandeep.dh 1453 
      result.success = self._handler.getNonSeralizedInventoryItem(args.itemNumber, args.itemId, args.fulfilmentWarehouseId)
5361 mandeep.dh 1454 
    except WarehouseServiceException, wex:
1455 
      result.wex = wex
1456 
    oprot.writeMessageBegin("getNonSeralizedInventoryItem", TMessageType.REPLY, seqid)
2821 chandransh 1457 
    result.write(oprot)
1458 
    oprot.writeMessageEnd()
1459 
    oprot.trans.flush()
1460 
 
4501 mandeep.dh 1461 
  def process_scan(self, seqid, iprot, oprot):
1462 
    args = scan_args()
3383 chandransh 1463 
    args.read(iprot)
1464 
    iprot.readMessageEnd()
4501 mandeep.dh 1465 
    result = scan_result()
3383 chandransh 1466 
    try:
5361 mandeep.dh 1467 
      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId)
3383 chandransh 1468 
    except WarehouseServiceException, wex:
1469 
      result.wex = wex
4501 mandeep.dh 1470 
    oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
3383 chandransh 1471 
    result.write(oprot)
1472 
    oprot.writeMessageEnd()
1473 
    oprot.trans.flush()
1474 
 
4501 mandeep.dh 1475 
  def process_scanSerializedItemForOrder(self, seqid, iprot, oprot):
1476 
    args = scanSerializedItemForOrder_args()
2821 chandransh 1477 
    args.read(iprot)
1478 
    iprot.readMessageEnd()
4501 mandeep.dh 1479 
    result = scanSerializedItemForOrder_result()
2821 chandransh 1480 
    try:
5110 mandeep.dh 1481 
      result.success = self._handler.scanSerializedItemForOrder(args.serialNumber, args.type, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
2821 chandransh 1482 
    except WarehouseServiceException, wex:
1483 
      result.wex = wex
4501 mandeep.dh 1484 
    oprot.writeMessageBegin("scanSerializedItemForOrder", TMessageType.REPLY, seqid)
2821 chandransh 1485 
    result.write(oprot)
1486 
    oprot.writeMessageEnd()
1487 
    oprot.trans.flush()
1488 
 
4501 mandeep.dh 1489 
  def process_scanForOrder(self, seqid, iprot, oprot):
1490 
    args = scanForOrder_args()
2821 chandransh 1491 
    args.read(iprot)
1492 
    iprot.readMessageEnd()
4501 mandeep.dh 1493 
    result = scanForOrder_result()
2821 chandransh 1494 
    try:
5361 mandeep.dh 1495 
      result.success = self._handler.scanForOrder(args.inventoryItem, args.type, args.quantity, args.orderId, args.fulfilmentWarehouseId, args.billingWarehouseId)
2821 chandransh 1496 
    except WarehouseServiceException, wex:
1497 
      result.wex = wex
4501 mandeep.dh 1498 
    oprot.writeMessageBegin("scanForOrder", TMessageType.REPLY, seqid)
2821 chandransh 1499 
    result.write(oprot)
1500 
    oprot.writeMessageEnd()
1501 
    oprot.trans.flush()
1502 
 
4501 mandeep.dh 1503 
  def process_createItemNumberMapping(self, seqid, iprot, oprot):
1504 
    args = createItemNumberMapping_args()
1505 
    args.read(iprot)
1506 
    iprot.readMessageEnd()
1507 
    result = createItemNumberMapping_result()
1508 
    self._handler.createItemNumberMapping(args.itemNumber, args.itemId)
1509 
    oprot.writeMessageBegin("createItemNumberMapping", TMessageType.REPLY, seqid)
1510 
    result.write(oprot)
1511 
    oprot.writeMessageEnd()
1512 
    oprot.trans.flush()
2821 chandransh 1513 
 
4620 amit.gupta 1514 
  def process_getItemNumbers(self, seqid, iprot, oprot):
1515 
    args = getItemNumbers_args()
1516 
    args.read(iprot)
1517 
    iprot.readMessageEnd()
1518 
    result = getItemNumbers_result()
1519 
    result.success = self._handler.getItemNumbers(args.itemId)
1520 
    oprot.writeMessageBegin("getItemNumbers", TMessageType.REPLY, seqid)
1521 
    result.write(oprot)
1522 
    oprot.writeMessageEnd()
1523 
    oprot.trans.flush()
4501 mandeep.dh 1524 
 
5110 mandeep.dh 1525 
  def process_getItemIds(self, seqid, iprot, oprot):
1526 
    args = getItemIds_args()
1527 
    args.read(iprot)
1528 
    iprot.readMessageEnd()
1529 
    result = getItemIds_result()
1530 
    result.success = self._handler.getItemIds(args.itemNumber)
1531 
    oprot.writeMessageBegin("getItemIds", TMessageType.REPLY, seqid)
1532 
    result.write(oprot)
1533 
    oprot.writeMessageEnd()
1534 
    oprot.trans.flush()
4620 amit.gupta 1535 
 
5185 mandeep.dh 1536 
  def process_getInventoryItemsFromLastScanType(self, seqid, iprot, oprot):
1537 
    args = getInventoryItemsFromLastScanType_args()
1538 
    args.read(iprot)
1539 
    iprot.readMessageEnd()
1540 
    result = getInventoryItemsFromLastScanType_result()
1541 
    try:
1542 
      result.success = self._handler.getInventoryItemsFromLastScanType(args.lastScanType)
1543 
    except WarehouseServiceException, wex:
1544 
      result.wex = wex
1545 
    oprot.writeMessageBegin("getInventoryItemsFromLastScanType", TMessageType.REPLY, seqid)
1546 
    result.write(oprot)
1547 
    oprot.writeMessageEnd()
1548 
    oprot.trans.flush()
5110 mandeep.dh 1549 
 
5185 mandeep.dh 1550 
  def process_getInventoryItemFromId(self, seqid, iprot, oprot):
1551 
    args = getInventoryItemFromId_args()
1552 
    args.read(iprot)
1553 
    iprot.readMessageEnd()
1554 
    result = getInventoryItemFromId_result()
1555 
    try:
1556 
      result.success = self._handler.getInventoryItemFromId(args.inventoryItemId)
1557 
    except WarehouseServiceException, wex:
1558 
      result.wex = wex
1559 
    oprot.writeMessageBegin("getInventoryItemFromId", TMessageType.REPLY, seqid)
1560 
    result.write(oprot)
1561 
    oprot.writeMessageEnd()
1562 
    oprot.trans.flush()
1563 
 
5372 mandeep.dh 1564 
  def process_getPurchaseScans(self, seqid, iprot, oprot):
1565 
    args = getPurchaseScans_args()
1566 
    args.read(iprot)
1567 
    iprot.readMessageEnd()
1568 
    result = getPurchaseScans_result()
1569 
    result.success = self._handler.getPurchaseScans(args.startDate, args.endDate)
1570 
    oprot.writeMessageBegin("getPurchaseScans", TMessageType.REPLY, seqid)
1571 
    result.write(oprot)
1572 
    oprot.writeMessageEnd()
1573 
    oprot.trans.flush()
5185 mandeep.dh 1574 
 
7216 amar.kumar 1575 
  def process_getPurchaseScansByGrnDate(self, seqid, iprot, oprot):
1576 
    args = getPurchaseScansByGrnDate_args()
1577 
    args.read(iprot)
1578 
    iprot.readMessageEnd()
1579 
    result = getPurchaseScansByGrnDate_result()
1580 
    result.success = self._handler.getPurchaseScansByGrnDate(args.startDate, args.endDate)
1581 
    oprot.writeMessageBegin("getPurchaseScansByGrnDate", TMessageType.REPLY, seqid)
1582 
    result.write(oprot)
1583 
    oprot.writeMessageEnd()
1584 
    oprot.trans.flush()
1585 
 
5496 mandeep.dh 1586 
  def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
1587 
    args = fetchScansPerInvoiceNumber_args()
1588 
    args.read(iprot)
1589 
    iprot.readMessageEnd()
1590 
    result = fetchScansPerInvoiceNumber_result()
1591 
    result.success = self._handler.fetchScansPerInvoiceNumber(args.date)
1592 
    oprot.writeMessageBegin("fetchScansPerInvoiceNumber", TMessageType.REPLY, seqid)
1593 
    result.write(oprot)
1594 
    oprot.writeMessageEnd()
1595 
    oprot.trans.flush()
5372 mandeep.dh 1596 
 
5620 mandeep.dh 1597 
  def process_getInventoryItemFromOrder(self, seqid, iprot, oprot):
1598 
    args = getInventoryItemFromOrder_args()
1599 
    args.read(iprot)
1600 
    iprot.readMessageEnd()
1601 
    result = getInventoryItemFromOrder_result()
1602 
    try:
1603 
      result.success = self._handler.getInventoryItemFromOrder(args.orderId)
1604 
    except WarehouseServiceException, we:
1605 
      result.we = we
1606 
    oprot.writeMessageBegin("getInventoryItemFromOrder", TMessageType.REPLY, seqid)
1607 
    result.write(oprot)
1608 
    oprot.writeMessageEnd()
1609 
    oprot.trans.flush()
5496 mandeep.dh 1610 
 
5711 mandeep.dh 1611 
  def process_getInventoryAge(self, seqid, iprot, oprot):
1612 
    args = getInventoryAge_args()
1613 
    args.read(iprot)
1614 
    iprot.readMessageEnd()
1615 
    result = getInventoryAge_result()
1616 
    result.success = self._handler.getInventoryAge()
1617 
    oprot.writeMessageBegin("getInventoryAge", TMessageType.REPLY, seqid)
1618 
    result.write(oprot)
1619 
    oprot.writeMessageEnd()
1620 
    oprot.trans.flush()
5620 mandeep.dh 1621 
 
6361 rajveer 1622 
  def process_getInventoryScansForItem(self, seqid, iprot, oprot):
1623 
    args = getInventoryScansForItem_args()
1624 
    args.read(iprot)
1625 
    iprot.readMessageEnd()
1626 
    result = getInventoryScansForItem_result()
1627 
    result.success = self._handler.getInventoryScansForItem(args.itemId, args.fromDate, args.toDate)
1628 
    oprot.writeMessageBegin("getInventoryScansForItem", TMessageType.REPLY, seqid)
1629 
    result.write(oprot)
1630 
    oprot.writeMessageEnd()
1631 
    oprot.trans.flush()
5711 mandeep.dh 1632 
 
6361 rajveer 1633 
  def process_getScanRecordsForSerialNumber(self, seqid, iprot, oprot):
1634 
    args = getScanRecordsForSerialNumber_args()
1635 
    args.read(iprot)
1636 
    iprot.readMessageEnd()
1637 
    result = getScanRecordsForSerialNumber_result()
1638 
    result.success = self._handler.getScanRecordsForSerialNumber(args.serialNumber)
1639 
    oprot.writeMessageBegin("getScanRecordsForSerialNumber", TMessageType.REPLY, seqid)
1640 
    result.write(oprot)
1641 
    oprot.writeMessageEnd()
1642 
    oprot.trans.flush()
1643 
 
6467 amar.kumar 1644 
  def process_scanForPurchaseReturn(self, seqid, iprot, oprot):
1645 
    args = scanForPurchaseReturn_args()
1646 
    args.read(iprot)
1647 
    iprot.readMessageEnd()
1648 
    result = scanForPurchaseReturn_result()
1649 
    try:
1650 
      self._handler.scanForPurchaseReturn(args.saleReturnItems, args.vendorId)
1651 
    except WarehouseServiceException, ex:
1652 
      result.ex = ex
1653 
    oprot.writeMessageBegin("scanForPurchaseReturn", TMessageType.REPLY, seqid)
1654 
    result.write(oprot)
1655 
    oprot.writeMessageEnd()
1656 
    oprot.trans.flush()
6361 rajveer 1657 
 
6630 amar.kumar 1658 
  def process_scanForLostItem(self, seqid, iprot, oprot):
1659 
    args = scanForLostItem_args()
1660 
    args.read(iprot)
1661 
    iprot.readMessageEnd()
1662 
    result = scanForLostItem_result()
1663 
    try:
1664 
      self._handler.scanForLostItem(args.lostItems, args.vendorId)
1665 
    except WarehouseServiceException, ex:
1666 
      result.ex = ex
1667 
    oprot.writeMessageBegin("scanForLostItem", TMessageType.REPLY, seqid)
1668 
    result.write(oprot)
1669 
    oprot.writeMessageEnd()
1670 
    oprot.trans.flush()
6467 amar.kumar 1671 
 
6630 amar.kumar 1672 
  def process_getCurrentSerializedInventoryByScans(self, seqid, iprot, oprot):
1673 
    args = getCurrentSerializedInventoryByScans_args()
1674 
    args.read(iprot)
1675 
    iprot.readMessageEnd()
1676 
    result = getCurrentSerializedInventoryByScans_result()
1677 
    result.success = self._handler.getCurrentSerializedInventoryByScans()
1678 
    oprot.writeMessageBegin("getCurrentSerializedInventoryByScans", TMessageType.REPLY, seqid)
1679 
    result.write(oprot)
1680 
    oprot.writeMessageEnd()
1681 
    oprot.trans.flush()
1682 
 
1683 
  def process_getCurrentNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1684 
    args = getCurrentNonSerializedInventoryByScans_args()
1685 
    args.read(iprot)
1686 
    iprot.readMessageEnd()
1687 
    result = getCurrentNonSerializedInventoryByScans_result()
1688 
    result.success = self._handler.getCurrentNonSerializedInventoryByScans()
1689 
    oprot.writeMessageBegin("getCurrentNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1690 
    result.write(oprot)
1691 
    oprot.writeMessageEnd()
1692 
    oprot.trans.flush()
1693 
 
6762 amar.kumar 1694 
  def process_getHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
1695 
    args = getHistoricSerializedInventoryByScans_args()
1696 
    args.read(iprot)
1697 
    iprot.readMessageEnd()
1698 
    result = getHistoricSerializedInventoryByScans_result()
1699 
    result.success = self._handler.getHistoricSerializedInventoryByScans(args.date)
1700 
    oprot.writeMessageBegin("getHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
1701 
    result.write(oprot)
1702 
    oprot.writeMessageEnd()
1703 
    oprot.trans.flush()
6630 amar.kumar 1704 
 
6762 amar.kumar 1705 
  def process_getHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1706 
    args = getHistoricNonSerializedInventoryByScans_args()
1707 
    args.read(iprot)
1708 
    iprot.readMessageEnd()
1709 
    result = getHistoricNonSerializedInventoryByScans_result()
1710 
    result.success = self._handler.getHistoricNonSerializedInventoryByScans(args.date)
1711 
    oprot.writeMessageBegin("getHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1712 
    result.write(oprot)
1713 
    oprot.writeMessageEnd()
1714 
    oprot.trans.flush()
1715 
 
1716 
  def process_scanForOursExternalSale(self, seqid, iprot, oprot):
1717 
    args = scanForOursExternalSale_args()
1718 
    args.read(iprot)
1719 
    iprot.readMessageEnd()
1720 
    result = scanForOursExternalSale_result()
1721 
    try:
1722 
      result.success = self._handler.scanForOursExternalSale(args.itemId, args.serialNumber, args.itemNumber, args.invoiceNumber, args.warehouseId, args.unitPrice, args.orderId)
1723 
    except WarehouseServiceException, ex:
1724 
      result.ex = ex
1725 
    oprot.writeMessageBegin("scanForOursExternalSale", TMessageType.REPLY, seqid)
1726 
    result.write(oprot)
1727 
    oprot.writeMessageEnd()
1728 
    oprot.trans.flush()
1729 
 
1730 
  def process_scanForOursExternalSaleReturn(self, seqid, iprot, oprot):
1731 
    args = scanForOursExternalSaleReturn_args()
1732 
    args.read(iprot)
1733 
    iprot.readMessageEnd()
1734 
    result = scanForOursExternalSaleReturn_result()
1735 
    self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
1736 
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
1737 
    result.write(oprot)
1738 
    oprot.writeMessageEnd()
1739 
    oprot.trans.flush()
1740 
 
6880 amar.kumar 1741 
  def process_getMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1742 
    args = getMovementNonSerializedInventoryByScans_args()
1743 
    args.read(iprot)
1744 
    iprot.readMessageEnd()
1745 
    result = getMovementNonSerializedInventoryByScans_result()
1746 
    result.success = self._handler.getMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
1747 
    oprot.writeMessageBegin("getMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1748 
    result.write(oprot)
1749 
    oprot.writeMessageEnd()
1750 
    oprot.trans.flush()
6762 amar.kumar 1751 
 
6880 amar.kumar 1752 
  def process_getMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
1753 
    args = getMovementSerializedInventoryByScans_args()
1754 
    args.read(iprot)
1755 
    iprot.readMessageEnd()
1756 
    result = getMovementSerializedInventoryByScans_result()
1757 
    result.success = self._handler.getMovementSerializedInventoryByScans(args.startDate, args.endDate)
1758 
    oprot.writeMessageBegin("getMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
1759 
    result.write(oprot)
1760 
    oprot.writeMessageEnd()
1761 
    oprot.trans.flush()
1762 
 
7216 amar.kumar 1763 
  def process_getCompleteMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
1764 
    args = getCompleteMovementSerializedInventoryByScans_args()
1765 
    args.read(iprot)
1766 
    iprot.readMessageEnd()
1767 
    result = getCompleteMovementSerializedInventoryByScans_result()
1768 
    result.success = self._handler.getCompleteMovementSerializedInventoryByScans(args.startDate, args.endDate)
1769 
    oprot.writeMessageBegin("getCompleteMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
1770 
    result.write(oprot)
1771 
    oprot.writeMessageEnd()
1772 
    oprot.trans.flush()
1773 
 
1774 
  def process_getCompleteMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1775 
    args = getCompleteMovementNonSerializedInventoryByScans_args()
1776 
    args.read(iprot)
1777 
    iprot.readMessageEnd()
1778 
    result = getCompleteMovementNonSerializedInventoryByScans_result()
1779 
    result.success = self._handler.getCompleteMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
1780 
    oprot.writeMessageBegin("getCompleteMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1781 
    result.write(oprot)
1782 
    oprot.writeMessageEnd()
1783 
    oprot.trans.flush()
1784 
 
7190 amar.kumar 1785 
  def process_scanfreebie(self, seqid, iprot, oprot):
1786 
    args = scanfreebie_args()
1787 
    args.read(iprot)
1788 
    iprot.readMessageEnd()
1789 
    result = scanfreebie_result()
1790 
    try:
1791 
      result.success = self._handler.scanfreebie(args.orderId, args.freebieItemId, args.freebieWarehouseId, args.scanType)
1792 
    except WarehouseServiceException, wex:
1793 
      result.wex = wex
1794 
    oprot.writeMessageBegin("scanfreebie", TMessageType.REPLY, seqid)
1795 
    result.write(oprot)
1796 
    oprot.writeMessageEnd()
1797 
    oprot.trans.flush()
6880 amar.kumar 1798 
 
7199 amar.kumar 1799 
  def process_reshipfreebie(self, seqid, iprot, oprot):
1800 
    args = reshipfreebie_args()
1801 
    args.read(iprot)
1802 
    iprot.readMessageEnd()
1803 
    result = reshipfreebie_result()
1804 
    try:
1805 
      self._handler.reshipfreebie(args.oldOrderId, args.newOrderId, args.freebieItemId, args.scanType)
1806 
    except WarehouseServiceException, wex:
1807 
      result.wex = wex
1808 
    oprot.writeMessageBegin("reshipfreebie", TMessageType.REPLY, seqid)
1809 
    result.write(oprot)
1810 
    oprot.writeMessageEnd()
1811 
    oprot.trans.flush()
7190 amar.kumar 1812 
 
7199 amar.kumar 1813 
 
2821 chandransh 1814 
# HELPER FUNCTIONS AND STRUCTURES
1815 
 
4501 mandeep.dh 1816 
class getInventoryItem_args:
2832 chandransh 1817 
  """
1818 
  Attributes:
4501 mandeep.dh 1819 
   - serialNumber
2832 chandransh 1820 
  """
1821 
 
1822 
  thrift_spec = (
1823 
    None, # 0
4501 mandeep.dh 1824 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
2832 chandransh 1825 
  )
1826 
 
4501 mandeep.dh 1827 
  def __init__(self, serialNumber=None,):
1828 
    self.serialNumber = serialNumber
2832 chandransh 1829 
 
1830 
  def read(self, iprot):
1831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1833 
      return
1834 
    iprot.readStructBegin()
1835 
    while True:
1836 
      (fname, ftype, fid) = iprot.readFieldBegin()
1837 
      if ftype == TType.STOP:
1838 
        break
1839 
      if fid == 1:
4501 mandeep.dh 1840 
        if ftype == TType.STRING:
1841 
          self.serialNumber = iprot.readString();
2832 chandransh 1842 
        else:
1843 
          iprot.skip(ftype)
1844 
      else:
1845 
        iprot.skip(ftype)
1846 
      iprot.readFieldEnd()
1847 
    iprot.readStructEnd()
1848 
 
1849 
  def write(self, oprot):
1850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1852 
      return
4501 mandeep.dh 1853 
    oprot.writeStructBegin('getInventoryItem_args')
1854 
    if self.serialNumber is not None:
1855 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
1856 
      oprot.writeString(self.serialNumber)
2832 chandransh 1857 
      oprot.writeFieldEnd()
1858 
    oprot.writeFieldStop()
1859 
    oprot.writeStructEnd()
1860 
 
3431 rajveer 1861 
  def validate(self):
1862 
    return
1863 
 
1864 
 
2832 chandransh 1865 
  def __repr__(self):
1866 
    L = ['%s=%r' % (key, value)
1867 
      for key, value in self.__dict__.iteritems()]
1868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1869 
 
1870 
  def __eq__(self, other):
1871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1872 
 
1873 
  def __ne__(self, other):
1874 
    return not (self == other)
1875 
 
4501 mandeep.dh 1876 
class getInventoryItem_result:
2832 chandransh 1877 
  """
1878 
  Attributes:
1879 
   - success
4541 mandeep.dh 1880 
   - wex
2832 chandransh 1881 
  """
1882 
 
1883 
  thrift_spec = (
4501 mandeep.dh 1884 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4541 mandeep.dh 1885 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2832 chandransh 1886 
  )
1887 
 
4541 mandeep.dh 1888 
  def __init__(self, success=None, wex=None,):
2832 chandransh 1889 
    self.success = success
4541 mandeep.dh 1890 
    self.wex = wex
2832 chandransh 1891 
 
1892 
  def read(self, iprot):
1893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1895 
      return
1896 
    iprot.readStructBegin()
1897 
    while True:
1898 
      (fname, ftype, fid) = iprot.readFieldBegin()
1899 
      if ftype == TType.STOP:
1900 
        break
1901 
      if fid == 0:
1902 
        if ftype == TType.STRUCT:
4501 mandeep.dh 1903 
          self.success = InventoryItem()
2832 chandransh 1904 
          self.success.read(iprot)
1905 
        else:
1906 
          iprot.skip(ftype)
4541 mandeep.dh 1907 
      elif fid == 1:
1908 
        if ftype == TType.STRUCT:
1909 
          self.wex = WarehouseServiceException()
1910 
          self.wex.read(iprot)
1911 
        else:
1912 
          iprot.skip(ftype)
2832 chandransh 1913 
      else:
1914 
        iprot.skip(ftype)
1915 
      iprot.readFieldEnd()
1916 
    iprot.readStructEnd()
1917 
 
1918 
  def write(self, oprot):
1919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1921 
      return
4501 mandeep.dh 1922 
    oprot.writeStructBegin('getInventoryItem_result')
3431 rajveer 1923 
    if self.success is not None:
2832 chandransh 1924 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1925 
      self.success.write(oprot)
1926 
      oprot.writeFieldEnd()
4541 mandeep.dh 1927 
    if self.wex is not None:
1928 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1929 
      self.wex.write(oprot)
1930 
      oprot.writeFieldEnd()
2832 chandransh 1931 
    oprot.writeFieldStop()
1932 
    oprot.writeStructEnd()
1933 
 
3431 rajveer 1934 
  def validate(self):
1935 
    return
1936 
 
1937 
 
2832 chandransh 1938 
  def __repr__(self):
1939 
    L = ['%s=%r' % (key, value)
1940 
      for key, value in self.__dict__.iteritems()]
1941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1942 
 
1943 
  def __eq__(self, other):
1944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1945 
 
1946 
  def __ne__(self, other):
1947 
    return not (self == other)
1948 
 
5361 mandeep.dh 1949 
class getNonSeralizedInventoryItem_args:
2821 chandransh 1950 
  """
1951 
  Attributes:
5530 mandeep.dh 1952 
   - itemNumber
4501 mandeep.dh 1953 
   - itemId
5530 mandeep.dh 1954 
   - fulfilmentWarehouseId
2821 chandransh 1955 
  """
1956 
 
1957 
  thrift_spec = (
1958 
    None, # 0
5530 mandeep.dh 1959 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
1960 
    (2, TType.I64, 'itemId', None, None, ), # 2
1961 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
2821 chandransh 1962 
  )
1963 
 
5530 mandeep.dh 1964 
  def __init__(self, itemNumber=None, itemId=None, fulfilmentWarehouseId=None,):
1965 
    self.itemNumber = itemNumber
4501 mandeep.dh 1966 
    self.itemId = itemId
5530 mandeep.dh 1967 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 1968 
 
1969 
  def read(self, iprot):
1970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1972 
      return
1973 
    iprot.readStructBegin()
1974 
    while True:
1975 
      (fname, ftype, fid) = iprot.readFieldBegin()
1976 
      if ftype == TType.STOP:
1977 
        break
1978 
      if fid == 1:
5530 mandeep.dh 1979 
        if ftype == TType.STRING:
1980 
          self.itemNumber = iprot.readString();
1981 
        else:
1982 
          iprot.skip(ftype)
1983 
      elif fid == 2:
2821 chandransh 1984 
        if ftype == TType.I64:
4501 mandeep.dh 1985 
          self.itemId = iprot.readI64();
2821 chandransh 1986 
        else:
1987 
          iprot.skip(ftype)
5530 mandeep.dh 1988 
      elif fid == 3:
4501 mandeep.dh 1989 
        if ftype == TType.I64:
5530 mandeep.dh 1990 
          self.fulfilmentWarehouseId = iprot.readI64();
2821 chandransh 1991 
        else:
1992 
          iprot.skip(ftype)
1993 
      else:
1994 
        iprot.skip(ftype)
1995 
      iprot.readFieldEnd()
1996 
    iprot.readStructEnd()
1997 
 
1998 
  def write(self, oprot):
1999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2001 
      return
5361 mandeep.dh 2002 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_args')
5530 mandeep.dh 2003 
    if self.itemNumber is not None:
2004 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2005 
      oprot.writeString(self.itemNumber)
2006 
      oprot.writeFieldEnd()
4501 mandeep.dh 2007 
    if self.itemId is not None:
5530 mandeep.dh 2008 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
4501 mandeep.dh 2009 
      oprot.writeI64(self.itemId)
2821 chandransh 2010 
      oprot.writeFieldEnd()
5530 mandeep.dh 2011 
    if self.fulfilmentWarehouseId is not None:
2012 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
2013 
      oprot.writeI64(self.fulfilmentWarehouseId)
2821 chandransh 2014 
      oprot.writeFieldEnd()
2015 
    oprot.writeFieldStop()
2016 
    oprot.writeStructEnd()
2017 
 
3431 rajveer 2018 
  def validate(self):
2019 
    return
2020 
 
2021 
 
2821 chandransh 2022 
  def __repr__(self):
2023 
    L = ['%s=%r' % (key, value)
2024 
      for key, value in self.__dict__.iteritems()]
2025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2026 
 
2027 
  def __eq__(self, other):
2028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2029 
 
2030 
  def __ne__(self, other):
2031 
    return not (self == other)
2032 
 
5361 mandeep.dh 2033 
class getNonSeralizedInventoryItem_result:
2821 chandransh 2034 
  """
2035 
  Attributes:
2036 
   - success
5361 mandeep.dh 2037 
   - wex
2821 chandransh 2038 
  """
2039 
 
2040 
  thrift_spec = (
5361 mandeep.dh 2041 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2042 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2821 chandransh 2043 
  )
2044 
 
5361 mandeep.dh 2045 
  def __init__(self, success=None, wex=None,):
2821 chandransh 2046 
    self.success = success
5361 mandeep.dh 2047 
    self.wex = wex
2821 chandransh 2048 
 
2049 
  def read(self, iprot):
2050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2052 
      return
2053 
    iprot.readStructBegin()
2054 
    while True:
2055 
      (fname, ftype, fid) = iprot.readFieldBegin()
2056 
      if ftype == TType.STOP:
2057 
        break
2058 
      if fid == 0:
5361 mandeep.dh 2059 
        if ftype == TType.STRUCT:
2060 
          self.success = InventoryItem()
2061 
          self.success.read(iprot)
2821 chandransh 2062 
        else:
2063 
          iprot.skip(ftype)
5361 mandeep.dh 2064 
      elif fid == 1:
2065 
        if ftype == TType.STRUCT:
2066 
          self.wex = WarehouseServiceException()
2067 
          self.wex.read(iprot)
2821 chandransh 2068 
        else:
2069 
          iprot.skip(ftype)
2070 
      else:
2071 
        iprot.skip(ftype)
2072 
      iprot.readFieldEnd()
2073 
    iprot.readStructEnd()
2074 
 
2075 
  def write(self, oprot):
2076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2078 
      return
5361 mandeep.dh 2079 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_result')
3431 rajveer 2080 
    if self.success is not None:
5361 mandeep.dh 2081 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2082 
      self.success.write(oprot)
2821 chandransh 2083 
      oprot.writeFieldEnd()
5361 mandeep.dh 2084 
    if self.wex is not None:
2085 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2086 
      self.wex.write(oprot)
3383 chandransh 2087 
      oprot.writeFieldEnd()
2088 
    oprot.writeFieldStop()
2089 
    oprot.writeStructEnd()
2090 
 
3431 rajveer 2091 
  def validate(self):
2092 
    return
2093 
 
2094 
 
3383 chandransh 2095 
  def __repr__(self):
2096 
    L = ['%s=%r' % (key, value)
2097 
      for key, value in self.__dict__.iteritems()]
2098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2099 
 
2100 
  def __eq__(self, other):
2101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2102 
 
2103 
  def __ne__(self, other):
2104 
    return not (self == other)
2105 
 
4501 mandeep.dh 2106 
class scan_args:
2821 chandransh 2107 
  """
2108 
  Attributes:
5361 mandeep.dh 2109 
   - inventoryItem
2821 chandransh 2110 
   - type
4501 mandeep.dh 2111 
   - quantity
5361 mandeep.dh 2112 
   - billingWarehouseId
2821 chandransh 2113 
  """
2114 
 
2115 
  thrift_spec = (
2116 
    None, # 0
5361 mandeep.dh 2117 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 2118 
    (2, TType.I32, 'type', None, None, ), # 2
2119 
    (3, TType.I64, 'quantity', None, None, ), # 3
5361 mandeep.dh 2120 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
2821 chandransh 2121 
  )
2122 
 
5361 mandeep.dh 2123 
  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None,):
2124 
    self.inventoryItem = inventoryItem
2821 chandransh 2125 
    self.type = type
4501 mandeep.dh 2126 
    self.quantity = quantity
5361 mandeep.dh 2127 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 2128 
 
2129 
  def read(self, iprot):
2130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2132 
      return
2133 
    iprot.readStructBegin()
2134 
    while True:
2135 
      (fname, ftype, fid) = iprot.readFieldBegin()
2136 
      if ftype == TType.STOP:
2137 
        break
2138 
      if fid == 1:
5361 mandeep.dh 2139 
        if ftype == TType.STRUCT:
2140 
          self.inventoryItem = InventoryItem()
2141 
          self.inventoryItem.read(iprot)
2821 chandransh 2142 
        else:
2143 
          iprot.skip(ftype)
2144 
      elif fid == 2:
4501 mandeep.dh 2145 
        if ftype == TType.I32:
2146 
          self.type = iprot.readI32();
2821 chandransh 2147 
        else:
2148 
          iprot.skip(ftype)
3383 chandransh 2149 
      elif fid == 3:
4501 mandeep.dh 2150 
        if ftype == TType.I64:
2151 
          self.quantity = iprot.readI64();
2821 chandransh 2152 
        else:
2153 
          iprot.skip(ftype)
3383 chandransh 2154 
      elif fid == 4:
4501 mandeep.dh 2155 
        if ftype == TType.I64:
5361 mandeep.dh 2156 
          self.billingWarehouseId = iprot.readI64();
2821 chandransh 2157 
        else:
2158 
          iprot.skip(ftype)
2159 
      else:
2160 
        iprot.skip(ftype)
2161 
      iprot.readFieldEnd()
2162 
    iprot.readStructEnd()
2163 
 
2164 
  def write(self, oprot):
2165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2167 
      return
4501 mandeep.dh 2168 
    oprot.writeStructBegin('scan_args')
5361 mandeep.dh 2169 
    if self.inventoryItem is not None:
2170 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
2171 
      self.inventoryItem.write(oprot)
2821 chandransh 2172 
      oprot.writeFieldEnd()
3431 rajveer 2173 
    if self.type is not None:
4501 mandeep.dh 2174 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 2175 
      oprot.writeI32(self.type)
2176 
      oprot.writeFieldEnd()
4501 mandeep.dh 2177 
    if self.quantity is not None:
2178 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
2179 
      oprot.writeI64(self.quantity)
2180 
      oprot.writeFieldEnd()
5361 mandeep.dh 2181 
    if self.billingWarehouseId is not None:
2182 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
2183 
      oprot.writeI64(self.billingWarehouseId)
4501 mandeep.dh 2184 
      oprot.writeFieldEnd()
2821 chandransh 2185 
    oprot.writeFieldStop()
2186 
    oprot.writeStructEnd()
2187 
 
3431 rajveer 2188 
  def validate(self):
2189 
    return
2190 
 
2191 
 
2821 chandransh 2192 
  def __repr__(self):
2193 
    L = ['%s=%r' % (key, value)
2194 
      for key, value in self.__dict__.iteritems()]
2195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2196 
 
2197 
  def __eq__(self, other):
2198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2199 
 
2200 
  def __ne__(self, other):
2201 
    return not (self == other)
2202 
 
4501 mandeep.dh 2203 
class scan_result:
2821 chandransh 2204 
  """
2205 
  Attributes:
2206 
   - wex
2207 
  """
2208 
 
2209 
  thrift_spec = (
2210 
    None, # 0
2211 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2212 
  )
2213 
 
2214 
  def __init__(self, wex=None,):
2215 
    self.wex = wex
2216 
 
2217 
  def read(self, iprot):
2218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2220 
      return
2221 
    iprot.readStructBegin()
2222 
    while True:
2223 
      (fname, ftype, fid) = iprot.readFieldBegin()
2224 
      if ftype == TType.STOP:
2225 
        break
2226 
      if fid == 1:
2227 
        if ftype == TType.STRUCT:
2228 
          self.wex = WarehouseServiceException()
2229 
          self.wex.read(iprot)
2230 
        else:
2231 
          iprot.skip(ftype)
2232 
      else:
2233 
        iprot.skip(ftype)
2234 
      iprot.readFieldEnd()
2235 
    iprot.readStructEnd()
2236 
 
2237 
  def write(self, oprot):
2238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2240 
      return
4501 mandeep.dh 2241 
    oprot.writeStructBegin('scan_result')
3431 rajveer 2242 
    if self.wex is not None:
2821 chandransh 2243 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2244 
      self.wex.write(oprot)
2245 
      oprot.writeFieldEnd()
2246 
    oprot.writeFieldStop()
2247 
    oprot.writeStructEnd()
2248 
 
3431 rajveer 2249 
  def validate(self):
2250 
    return
2251 
 
2252 
 
2821 chandransh 2253 
  def __repr__(self):
2254 
    L = ['%s=%r' % (key, value)
2255 
      for key, value in self.__dict__.iteritems()]
2256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2257 
 
2258 
  def __eq__(self, other):
2259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2260 
 
2261 
  def __ne__(self, other):
2262 
    return not (self == other)
2263 
 
4501 mandeep.dh 2264 
class scanSerializedItemForOrder_args:
2821 chandransh 2265 
  """
2266 
  Attributes:
4555 mandeep.dh 2267 
   - serialNumber
2821 chandransh 2268 
   - type
4501 mandeep.dh 2269 
   - orderId
5110 mandeep.dh 2270 
   - fulfilmentWarehouseId
2271 
   - quantity
2272 
   - billingWarehouseId
2821 chandransh 2273 
  """
2274 
 
2275 
  thrift_spec = (
2276 
    None, # 0
4555 mandeep.dh 2277 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
4501 mandeep.dh 2278 
    (2, TType.I32, 'type', None, None, ), # 2
2279 
    (3, TType.I64, 'orderId', None, None, ), # 3
5110 mandeep.dh 2280 
    (4, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 4
2281 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
2282 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
2821 chandransh 2283 
  )
2284 
 
5110 mandeep.dh 2285 
  def __init__(self, serialNumber=None, type=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
4555 mandeep.dh 2286 
    self.serialNumber = serialNumber
2821 chandransh 2287 
    self.type = type
4501 mandeep.dh 2288 
    self.orderId = orderId
5110 mandeep.dh 2289 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
2290 
    self.quantity = quantity
2291 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 2292 
 
2293 
  def read(self, iprot):
2294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2296 
      return
2297 
    iprot.readStructBegin()
2298 
    while True:
2299 
      (fname, ftype, fid) = iprot.readFieldBegin()
2300 
      if ftype == TType.STOP:
2301 
        break
2302 
      if fid == 1:
4555 mandeep.dh 2303 
        if ftype == TType.STRING:
2304 
          self.serialNumber = iprot.readString();
2821 chandransh 2305 
        else:
2306 
          iprot.skip(ftype)
2307 
      elif fid == 2:
4501 mandeep.dh 2308 
        if ftype == TType.I32:
2309 
          self.type = iprot.readI32();
2821 chandransh 2310 
        else:
2311 
          iprot.skip(ftype)
2312 
      elif fid == 3:
4501 mandeep.dh 2313 
        if ftype == TType.I64:
2314 
          self.orderId = iprot.readI64();
2315 
        else:
2316 
          iprot.skip(ftype)
2317 
      elif fid == 4:
2318 
        if ftype == TType.I64:
5110 mandeep.dh 2319 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 2320 
        else:
2321 
          iprot.skip(ftype)
5110 mandeep.dh 2322 
      elif fid == 5:
2323 
        if ftype == TType.DOUBLE:
2324 
          self.quantity = iprot.readDouble();
2325 
        else:
2326 
          iprot.skip(ftype)
2327 
      elif fid == 6:
2328 
        if ftype == TType.I64:
2329 
          self.billingWarehouseId = iprot.readI64();
2330 
        else:
2331 
          iprot.skip(ftype)
4501 mandeep.dh 2332 
      else:
2333 
        iprot.skip(ftype)
2334 
      iprot.readFieldEnd()
2335 
    iprot.readStructEnd()
2336 
 
2337 
  def write(self, oprot):
2338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2340 
      return
2341 
    oprot.writeStructBegin('scanSerializedItemForOrder_args')
4555 mandeep.dh 2342 
    if self.serialNumber is not None:
2343 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
2344 
      oprot.writeString(self.serialNumber)
4501 mandeep.dh 2345 
      oprot.writeFieldEnd()
2346 
    if self.type is not None:
2347 
      oprot.writeFieldBegin('type', TType.I32, 2)
2348 
      oprot.writeI32(self.type)
2349 
      oprot.writeFieldEnd()
2350 
    if self.orderId is not None:
2351 
      oprot.writeFieldBegin('orderId', TType.I64, 3)
2352 
      oprot.writeI64(self.orderId)
2353 
      oprot.writeFieldEnd()
5110 mandeep.dh 2354 
    if self.fulfilmentWarehouseId is not None:
2355 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 4)
2356 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 2357 
      oprot.writeFieldEnd()
5110 mandeep.dh 2358 
    if self.quantity is not None:
2359 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
2360 
      oprot.writeDouble(self.quantity)
2361 
      oprot.writeFieldEnd()
2362 
    if self.billingWarehouseId is not None:
2363 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
2364 
      oprot.writeI64(self.billingWarehouseId)
2365 
      oprot.writeFieldEnd()
4501 mandeep.dh 2366 
    oprot.writeFieldStop()
2367 
    oprot.writeStructEnd()
2368 
 
2369 
  def validate(self):
2370 
    return
2371 
 
2372 
 
2373 
  def __repr__(self):
2374 
    L = ['%s=%r' % (key, value)
2375 
      for key, value in self.__dict__.iteritems()]
2376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2377 
 
2378 
  def __eq__(self, other):
2379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2380 
 
2381 
  def __ne__(self, other):
2382 
    return not (self == other)
2383 
 
2384 
class scanSerializedItemForOrder_result:
2385 
  """
2386 
  Attributes:
2387 
   - success
2388 
   - wex
2389 
  """
2390 
 
2391 
  thrift_spec = (
4555 mandeep.dh 2392 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4501 mandeep.dh 2393 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2394 
  )
2395 
 
2396 
  def __init__(self, success=None, wex=None,):
2397 
    self.success = success
2398 
    self.wex = wex
2399 
 
2400 
  def read(self, iprot):
2401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2403 
      return
2404 
    iprot.readStructBegin()
2405 
    while True:
2406 
      (fname, ftype, fid) = iprot.readFieldBegin()
2407 
      if ftype == TType.STOP:
2408 
        break
2409 
      if fid == 0:
4555 mandeep.dh 2410 
        if ftype == TType.STRUCT:
2411 
          self.success = InventoryItem()
2412 
          self.success.read(iprot)
4501 mandeep.dh 2413 
        else:
2414 
          iprot.skip(ftype)
2415 
      elif fid == 1:
2416 
        if ftype == TType.STRUCT:
2417 
          self.wex = WarehouseServiceException()
2418 
          self.wex.read(iprot)
2419 
        else:
2420 
          iprot.skip(ftype)
2421 
      else:
2422 
        iprot.skip(ftype)
2423 
      iprot.readFieldEnd()
2424 
    iprot.readStructEnd()
2425 
 
2426 
  def write(self, oprot):
2427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2429 
      return
2430 
    oprot.writeStructBegin('scanSerializedItemForOrder_result')
2431 
    if self.success is not None:
4555 mandeep.dh 2432 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2433 
      self.success.write(oprot)
4501 mandeep.dh 2434 
      oprot.writeFieldEnd()
2435 
    if self.wex is not None:
2436 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2437 
      self.wex.write(oprot)
2438 
      oprot.writeFieldEnd()
2439 
    oprot.writeFieldStop()
2440 
    oprot.writeStructEnd()
2441 
 
2442 
  def validate(self):
2443 
    return
2444 
 
2445 
 
2446 
  def __repr__(self):
2447 
    L = ['%s=%r' % (key, value)
2448 
      for key, value in self.__dict__.iteritems()]
2449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2450 
 
2451 
  def __eq__(self, other):
2452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2453 
 
2454 
  def __ne__(self, other):
2455 
    return not (self == other)
2456 
 
2457 
class scanForOrder_args:
2458 
  """
2459 
  Attributes:
5361 mandeep.dh 2460 
   - inventoryItem
4501 mandeep.dh 2461 
   - type
2462 
   - quantity
2463 
   - orderId
5110 mandeep.dh 2464 
   - fulfilmentWarehouseId
5361 mandeep.dh 2465 
   - billingWarehouseId
4501 mandeep.dh 2466 
  """
2467 
 
2468 
  thrift_spec = (
2469 
    None, # 0
5361 mandeep.dh 2470 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 2471 
    (2, TType.I32, 'type', None, None, ), # 2
2472 
    (3, TType.I64, 'quantity', None, None, ), # 3
2473 
    (4, TType.I64, 'orderId', None, None, ), # 4
5110 mandeep.dh 2474 
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
5361 mandeep.dh 2475 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
4501 mandeep.dh 2476 
  )
2477 
 
5361 mandeep.dh 2478 
  def __init__(self, inventoryItem=None, type=None, quantity=None, orderId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
2479 
    self.inventoryItem = inventoryItem
4501 mandeep.dh 2480 
    self.type = type
2481 
    self.quantity = quantity
2482 
    self.orderId = orderId
5110 mandeep.dh 2483 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 2484 
    self.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 2485 
 
2486 
  def read(self, iprot):
2487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2489 
      return
2490 
    iprot.readStructBegin()
2491 
    while True:
2492 
      (fname, ftype, fid) = iprot.readFieldBegin()
2493 
      if ftype == TType.STOP:
2494 
        break
2495 
      if fid == 1:
5361 mandeep.dh 2496 
        if ftype == TType.STRUCT:
2497 
          self.inventoryItem = InventoryItem()
2498 
          self.inventoryItem.read(iprot)
4501 mandeep.dh 2499 
        else:
2500 
          iprot.skip(ftype)
2501 
      elif fid == 2:
2821 chandransh 2502 
        if ftype == TType.I32:
2503 
          self.type = iprot.readI32();
2504 
        else:
2505 
          iprot.skip(ftype)
4501 mandeep.dh 2506 
      elif fid == 3:
2507 
        if ftype == TType.I64:
2508 
          self.quantity = iprot.readI64();
2509 
        else:
2510 
          iprot.skip(ftype)
2511 
      elif fid == 4:
2512 
        if ftype == TType.I64:
2513 
          self.orderId = iprot.readI64();
2514 
        else:
2515 
          iprot.skip(ftype)
2516 
      elif fid == 5:
2517 
        if ftype == TType.I64:
5110 mandeep.dh 2518 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 2519 
        else:
2520 
          iprot.skip(ftype)
5361 mandeep.dh 2521 
      elif fid == 6:
2522 
        if ftype == TType.I64:
2523 
          self.billingWarehouseId = iprot.readI64();
2524 
        else:
2525 
          iprot.skip(ftype)
2821 chandransh 2526 
      else:
2527 
        iprot.skip(ftype)
2528 
      iprot.readFieldEnd()
2529 
    iprot.readStructEnd()
2530 
 
2531 
  def write(self, oprot):
2532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2534 
      return
4501 mandeep.dh 2535 
    oprot.writeStructBegin('scanForOrder_args')
5361 mandeep.dh 2536 
    if self.inventoryItem is not None:
2537 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
2538 
      self.inventoryItem.write(oprot)
2821 chandransh 2539 
      oprot.writeFieldEnd()
3431 rajveer 2540 
    if self.type is not None:
4501 mandeep.dh 2541 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 2542 
      oprot.writeI32(self.type)
2543 
      oprot.writeFieldEnd()
4501 mandeep.dh 2544 
    if self.quantity is not None:
2545 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
2546 
      oprot.writeI64(self.quantity)
2547 
      oprot.writeFieldEnd()
2548 
    if self.orderId is not None:
2549 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
2550 
      oprot.writeI64(self.orderId)
2551 
      oprot.writeFieldEnd()
5110 mandeep.dh 2552 
    if self.fulfilmentWarehouseId is not None:
2553 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
2554 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 2555 
      oprot.writeFieldEnd()
5361 mandeep.dh 2556 
    if self.billingWarehouseId is not None:
2557 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
2558 
      oprot.writeI64(self.billingWarehouseId)
2559 
      oprot.writeFieldEnd()
2821 chandransh 2560 
    oprot.writeFieldStop()
2561 
    oprot.writeStructEnd()
2562 
 
3431 rajveer 2563 
  def validate(self):
2564 
    return
2565 
 
2566 
 
2821 chandransh 2567 
  def __repr__(self):
2568 
    L = ['%s=%r' % (key, value)
2569 
      for key, value in self.__dict__.iteritems()]
2570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2571 
 
2572 
  def __eq__(self, other):
2573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2574 
 
2575 
  def __ne__(self, other):
2576 
    return not (self == other)
2577 
 
4501 mandeep.dh 2578 
class scanForOrder_result:
2821 chandransh 2579 
  """
2580 
  Attributes:
5361 mandeep.dh 2581 
   - success
2821 chandransh 2582 
   - wex
2583 
  """
2584 
 
2585 
  thrift_spec = (
5361 mandeep.dh 2586 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2821 chandransh 2587 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2588 
  )
2589 
 
5361 mandeep.dh 2590 
  def __init__(self, success=None, wex=None,):
2591 
    self.success = success
2821 chandransh 2592 
    self.wex = wex
2593 
 
2594 
  def read(self, iprot):
2595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2597 
      return
2598 
    iprot.readStructBegin()
2599 
    while True:
2600 
      (fname, ftype, fid) = iprot.readFieldBegin()
2601 
      if ftype == TType.STOP:
2602 
        break
5361 mandeep.dh 2603 
      if fid == 0:
2821 chandransh 2604 
        if ftype == TType.STRUCT:
5361 mandeep.dh 2605 
          self.success = InventoryItem()
2606 
          self.success.read(iprot)
2607 
        else:
2608 
          iprot.skip(ftype)
2609 
      elif fid == 1:
2610 
        if ftype == TType.STRUCT:
2821 chandransh 2611 
          self.wex = WarehouseServiceException()
2612 
          self.wex.read(iprot)
2613 
        else:
2614 
          iprot.skip(ftype)
2615 
      else:
2616 
        iprot.skip(ftype)
2617 
      iprot.readFieldEnd()
2618 
    iprot.readStructEnd()
2619 
 
2620 
  def write(self, oprot):
2621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2623 
      return
4501 mandeep.dh 2624 
    oprot.writeStructBegin('scanForOrder_result')
5361 mandeep.dh 2625 
    if self.success is not None:
2626 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2627 
      self.success.write(oprot)
2628 
      oprot.writeFieldEnd()
3431 rajveer 2629 
    if self.wex is not None:
2821 chandransh 2630 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2631 
      self.wex.write(oprot)
2632 
      oprot.writeFieldEnd()
2633 
    oprot.writeFieldStop()
2634 
    oprot.writeStructEnd()
2635 
 
3431 rajveer 2636 
  def validate(self):
2637 
    return
2638 
 
2639 
 
2821 chandransh 2640 
  def __repr__(self):
2641 
    L = ['%s=%r' % (key, value)
2642 
      for key, value in self.__dict__.iteritems()]
2643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2644 
 
2645 
  def __eq__(self, other):
2646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2647 
 
2648 
  def __ne__(self, other):
2649 
    return not (self == other)
4501 mandeep.dh 2650 
 
2651 
class createItemNumberMapping_args:
2652 
  """
2653 
  Attributes:
2654 
   - itemNumber
2655 
   - itemId
2656 
  """
2657 
 
2658 
  thrift_spec = (
2659 
    None, # 0
2660 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2661 
    (2, TType.I64, 'itemId', None, None, ), # 2
2662 
  )
2663 
 
2664 
  def __init__(self, itemNumber=None, itemId=None,):
2665 
    self.itemNumber = itemNumber
2666 
    self.itemId = itemId
2667 
 
2668 
  def read(self, iprot):
2669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2671 
      return
2672 
    iprot.readStructBegin()
2673 
    while True:
2674 
      (fname, ftype, fid) = iprot.readFieldBegin()
2675 
      if ftype == TType.STOP:
2676 
        break
2677 
      if fid == 1:
2678 
        if ftype == TType.STRING:
2679 
          self.itemNumber = iprot.readString();
2680 
        else:
2681 
          iprot.skip(ftype)
2682 
      elif fid == 2:
2683 
        if ftype == TType.I64:
2684 
          self.itemId = iprot.readI64();
2685 
        else:
2686 
          iprot.skip(ftype)
2687 
      else:
2688 
        iprot.skip(ftype)
2689 
      iprot.readFieldEnd()
2690 
    iprot.readStructEnd()
2691 
 
2692 
  def write(self, oprot):
2693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2695 
      return
2696 
    oprot.writeStructBegin('createItemNumberMapping_args')
2697 
    if self.itemNumber is not None:
2698 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2699 
      oprot.writeString(self.itemNumber)
2700 
      oprot.writeFieldEnd()
2701 
    if self.itemId is not None:
2702 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
2703 
      oprot.writeI64(self.itemId)
2704 
      oprot.writeFieldEnd()
2705 
    oprot.writeFieldStop()
2706 
    oprot.writeStructEnd()
2707 
 
2708 
  def validate(self):
2709 
    return
2710 
 
2711 
 
2712 
  def __repr__(self):
2713 
    L = ['%s=%r' % (key, value)
2714 
      for key, value in self.__dict__.iteritems()]
2715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2716 
 
2717 
  def __eq__(self, other):
2718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2719 
 
2720 
  def __ne__(self, other):
2721 
    return not (self == other)
2722 
 
2723 
class createItemNumberMapping_result:
2724 
 
2725 
  thrift_spec = (
2726 
  )
2727 
 
2728 
  def read(self, iprot):
2729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2731 
      return
2732 
    iprot.readStructBegin()
2733 
    while True:
2734 
      (fname, ftype, fid) = iprot.readFieldBegin()
2735 
      if ftype == TType.STOP:
2736 
        break
2737 
      else:
2738 
        iprot.skip(ftype)
2739 
      iprot.readFieldEnd()
2740 
    iprot.readStructEnd()
2741 
 
2742 
  def write(self, oprot):
2743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2745 
      return
2746 
    oprot.writeStructBegin('createItemNumberMapping_result')
2747 
    oprot.writeFieldStop()
2748 
    oprot.writeStructEnd()
2749 
 
2750 
  def validate(self):
2751 
    return
2752 
 
2753 
 
2754 
  def __repr__(self):
2755 
    L = ['%s=%r' % (key, value)
2756 
      for key, value in self.__dict__.iteritems()]
2757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2758 
 
2759 
  def __eq__(self, other):
2760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2761 
 
2762 
  def __ne__(self, other):
2763 
    return not (self == other)
4620 amit.gupta 2764 
 
2765 
class getItemNumbers_args:
2766 
  """
2767 
  Attributes:
2768 
   - itemId
2769 
  """
2770 
 
2771 
  thrift_spec = (
2772 
    None, # 0
2773 
    (1, TType.I64, 'itemId', None, None, ), # 1
2774 
  )
2775 
 
2776 
  def __init__(self, itemId=None,):
2777 
    self.itemId = itemId
2778 
 
2779 
  def read(self, iprot):
2780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2782 
      return
2783 
    iprot.readStructBegin()
2784 
    while True:
2785 
      (fname, ftype, fid) = iprot.readFieldBegin()
2786 
      if ftype == TType.STOP:
2787 
        break
2788 
      if fid == 1:
2789 
        if ftype == TType.I64:
2790 
          self.itemId = iprot.readI64();
2791 
        else:
2792 
          iprot.skip(ftype)
2793 
      else:
2794 
        iprot.skip(ftype)
2795 
      iprot.readFieldEnd()
2796 
    iprot.readStructEnd()
2797 
 
2798 
  def write(self, oprot):
2799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2801 
      return
2802 
    oprot.writeStructBegin('getItemNumbers_args')
2803 
    if self.itemId is not None:
2804 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
2805 
      oprot.writeI64(self.itemId)
2806 
      oprot.writeFieldEnd()
2807 
    oprot.writeFieldStop()
2808 
    oprot.writeStructEnd()
2809 
 
2810 
  def validate(self):
2811 
    return
2812 
 
2813 
 
2814 
  def __repr__(self):
2815 
    L = ['%s=%r' % (key, value)
2816 
      for key, value in self.__dict__.iteritems()]
2817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2818 
 
2819 
  def __eq__(self, other):
2820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2821 
 
2822 
  def __ne__(self, other):
2823 
    return not (self == other)
2824 
 
2825 
class getItemNumbers_result:
2826 
  """
2827 
  Attributes:
2828 
   - success
2829 
  """
2830 
 
2831 
  thrift_spec = (
2832 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
2833 
  )
2834 
 
2835 
  def __init__(self, success=None,):
2836 
    self.success = success
2837 
 
2838 
  def read(self, iprot):
2839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2841 
      return
2842 
    iprot.readStructBegin()
2843 
    while True:
2844 
      (fname, ftype, fid) = iprot.readFieldBegin()
2845 
      if ftype == TType.STOP:
2846 
        break
2847 
      if fid == 0:
2848 
        if ftype == TType.LIST:
2849 
          self.success = []
5361 mandeep.dh 2850 
          (_etype3, _size0) = iprot.readListBegin()
2851 
          for _i4 in xrange(_size0):
2852 
            _elem5 = iprot.readString();
2853 
            self.success.append(_elem5)
4620 amit.gupta 2854 
          iprot.readListEnd()
2855 
        else:
2856 
          iprot.skip(ftype)
2857 
      else:
2858 
        iprot.skip(ftype)
2859 
      iprot.readFieldEnd()
2860 
    iprot.readStructEnd()
2861 
 
2862 
  def write(self, oprot):
2863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2865 
      return
2866 
    oprot.writeStructBegin('getItemNumbers_result')
2867 
    if self.success is not None:
2868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2869 
      oprot.writeListBegin(TType.STRING, len(self.success))
5361 mandeep.dh 2870 
      for iter6 in self.success:
2871 
        oprot.writeString(iter6)
4620 amit.gupta 2872 
      oprot.writeListEnd()
2873 
      oprot.writeFieldEnd()
2874 
    oprot.writeFieldStop()
2875 
    oprot.writeStructEnd()
2876 
 
2877 
  def validate(self):
2878 
    return
2879 
 
2880 
 
2881 
  def __repr__(self):
2882 
    L = ['%s=%r' % (key, value)
2883 
      for key, value in self.__dict__.iteritems()]
2884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2885 
 
2886 
  def __eq__(self, other):
2887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2888 
 
2889 
  def __ne__(self, other):
2890 
    return not (self == other)
5110 mandeep.dh 2891 
 
2892 
class getItemIds_args:
2893 
  """
2894 
  Attributes:
2895 
   - itemNumber
2896 
  """
2897 
 
2898 
  thrift_spec = (
2899 
    None, # 0
2900 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2901 
  )
2902 
 
2903 
  def __init__(self, itemNumber=None,):
2904 
    self.itemNumber = itemNumber
2905 
 
2906 
  def read(self, iprot):
2907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2909 
      return
2910 
    iprot.readStructBegin()
2911 
    while True:
2912 
      (fname, ftype, fid) = iprot.readFieldBegin()
2913 
      if ftype == TType.STOP:
2914 
        break
2915 
      if fid == 1:
2916 
        if ftype == TType.STRING:
2917 
          self.itemNumber = iprot.readString();
2918 
        else:
2919 
          iprot.skip(ftype)
2920 
      else:
2921 
        iprot.skip(ftype)
2922 
      iprot.readFieldEnd()
2923 
    iprot.readStructEnd()
2924 
 
2925 
  def write(self, oprot):
2926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2928 
      return
2929 
    oprot.writeStructBegin('getItemIds_args')
2930 
    if self.itemNumber is not None:
2931 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2932 
      oprot.writeString(self.itemNumber)
2933 
      oprot.writeFieldEnd()
2934 
    oprot.writeFieldStop()
2935 
    oprot.writeStructEnd()
2936 
 
2937 
  def validate(self):
2938 
    return
2939 
 
2940 
 
2941 
  def __repr__(self):
2942 
    L = ['%s=%r' % (key, value)
2943 
      for key, value in self.__dict__.iteritems()]
2944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2945 
 
2946 
  def __eq__(self, other):
2947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2948 
 
2949 
  def __ne__(self, other):
2950 
    return not (self == other)
2951 
 
2952 
class getItemIds_result:
2953 
  """
2954 
  Attributes:
2955 
   - success
2956 
  """
2957 
 
2958 
  thrift_spec = (
2959 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2960 
  )
2961 
 
2962 
  def __init__(self, success=None,):
2963 
    self.success = success
2964 
 
2965 
  def read(self, iprot):
2966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2968 
      return
2969 
    iprot.readStructBegin()
2970 
    while True:
2971 
      (fname, ftype, fid) = iprot.readFieldBegin()
2972 
      if ftype == TType.STOP:
2973 
        break
2974 
      if fid == 0:
2975 
        if ftype == TType.LIST:
2976 
          self.success = []
5361 mandeep.dh 2977 
          (_etype10, _size7) = iprot.readListBegin()
2978 
          for _i11 in xrange(_size7):
2979 
            _elem12 = iprot.readI64();
2980 
            self.success.append(_elem12)
5110 mandeep.dh 2981 
          iprot.readListEnd()
2982 
        else:
2983 
          iprot.skip(ftype)
2984 
      else:
2985 
        iprot.skip(ftype)
2986 
      iprot.readFieldEnd()
2987 
    iprot.readStructEnd()
2988 
 
2989 
  def write(self, oprot):
2990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2992 
      return
2993 
    oprot.writeStructBegin('getItemIds_result')
2994 
    if self.success is not None:
2995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2996 
      oprot.writeListBegin(TType.I64, len(self.success))
5361 mandeep.dh 2997 
      for iter13 in self.success:
2998 
        oprot.writeI64(iter13)
5110 mandeep.dh 2999 
      oprot.writeListEnd()
3000 
      oprot.writeFieldEnd()
3001 
    oprot.writeFieldStop()
3002 
    oprot.writeStructEnd()
3003 
 
3004 
  def validate(self):
3005 
    return
3006 
 
3007 
 
3008 
  def __repr__(self):
3009 
    L = ['%s=%r' % (key, value)
3010 
      for key, value in self.__dict__.iteritems()]
3011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3012 
 
3013 
  def __eq__(self, other):
3014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3015 
 
3016 
  def __ne__(self, other):
3017 
    return not (self == other)
5185 mandeep.dh 3018 
 
3019 
class getInventoryItemsFromLastScanType_args:
3020 
  """
3021 
  Attributes:
3022 
   - lastScanType
3023 
  """
3024 
 
3025 
  thrift_spec = (
3026 
    None, # 0
3027 
    (1, TType.I32, 'lastScanType', None, None, ), # 1
3028 
  )
3029 
 
3030 
  def __init__(self, lastScanType=None,):
3031 
    self.lastScanType = lastScanType
3032 
 
3033 
  def read(self, iprot):
3034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3036 
      return
3037 
    iprot.readStructBegin()
3038 
    while True:
3039 
      (fname, ftype, fid) = iprot.readFieldBegin()
3040 
      if ftype == TType.STOP:
3041 
        break
3042 
      if fid == 1:
3043 
        if ftype == TType.I32:
3044 
          self.lastScanType = iprot.readI32();
3045 
        else:
3046 
          iprot.skip(ftype)
3047 
      else:
3048 
        iprot.skip(ftype)
3049 
      iprot.readFieldEnd()
3050 
    iprot.readStructEnd()
3051 
 
3052 
  def write(self, oprot):
3053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3055 
      return
3056 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_args')
3057 
    if self.lastScanType is not None:
3058 
      oprot.writeFieldBegin('lastScanType', TType.I32, 1)
3059 
      oprot.writeI32(self.lastScanType)
3060 
      oprot.writeFieldEnd()
3061 
    oprot.writeFieldStop()
3062 
    oprot.writeStructEnd()
3063 
 
3064 
  def validate(self):
3065 
    return
3066 
 
3067 
 
3068 
  def __repr__(self):
3069 
    L = ['%s=%r' % (key, value)
3070 
      for key, value in self.__dict__.iteritems()]
3071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3072 
 
3073 
  def __eq__(self, other):
3074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3075 
 
3076 
  def __ne__(self, other):
3077 
    return not (self == other)
3078 
 
3079 
class getInventoryItemsFromLastScanType_result:
3080 
  """
3081 
  Attributes:
3082 
   - success
3083 
   - wex
3084 
  """
3085 
 
3086 
  thrift_spec = (
3087 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
3088 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3089 
  )
3090 
 
3091 
  def __init__(self, success=None, wex=None,):
3092 
    self.success = success
3093 
    self.wex = wex
3094 
 
3095 
  def read(self, iprot):
3096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3098 
      return
3099 
    iprot.readStructBegin()
3100 
    while True:
3101 
      (fname, ftype, fid) = iprot.readFieldBegin()
3102 
      if ftype == TType.STOP:
3103 
        break
3104 
      if fid == 0:
3105 
        if ftype == TType.LIST:
3106 
          self.success = []
5361 mandeep.dh 3107 
          (_etype17, _size14) = iprot.readListBegin()
3108 
          for _i18 in xrange(_size14):
3109 
            _elem19 = InventoryItem()
3110 
            _elem19.read(iprot)
3111 
            self.success.append(_elem19)
5185 mandeep.dh 3112 
          iprot.readListEnd()
3113 
        else:
3114 
          iprot.skip(ftype)
3115 
      elif fid == 1:
3116 
        if ftype == TType.STRUCT:
3117 
          self.wex = WarehouseServiceException()
3118 
          self.wex.read(iprot)
3119 
        else:
3120 
          iprot.skip(ftype)
3121 
      else:
3122 
        iprot.skip(ftype)
3123 
      iprot.readFieldEnd()
3124 
    iprot.readStructEnd()
3125 
 
3126 
  def write(self, oprot):
3127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3129 
      return
3130 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_result')
3131 
    if self.success is not None:
3132 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3133 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5361 mandeep.dh 3134 
      for iter20 in self.success:
3135 
        iter20.write(oprot)
5185 mandeep.dh 3136 
      oprot.writeListEnd()
3137 
      oprot.writeFieldEnd()
3138 
    if self.wex is not None:
3139 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
3140 
      self.wex.write(oprot)
3141 
      oprot.writeFieldEnd()
3142 
    oprot.writeFieldStop()
3143 
    oprot.writeStructEnd()
3144 
 
3145 
  def validate(self):
3146 
    return
3147 
 
3148 
 
3149 
  def __repr__(self):
3150 
    L = ['%s=%r' % (key, value)
3151 
      for key, value in self.__dict__.iteritems()]
3152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3153 
 
3154 
  def __eq__(self, other):
3155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3156 
 
3157 
  def __ne__(self, other):
3158 
    return not (self == other)
3159 
 
3160 
class getInventoryItemFromId_args:
3161 
  """
3162 
  Attributes:
3163 
   - inventoryItemId
3164 
  """
3165 
 
3166 
  thrift_spec = (
3167 
    None, # 0
3168 
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
3169 
  )
3170 
 
3171 
  def __init__(self, inventoryItemId=None,):
3172 
    self.inventoryItemId = inventoryItemId
3173 
 
3174 
  def read(self, iprot):
3175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3177 
      return
3178 
    iprot.readStructBegin()
3179 
    while True:
3180 
      (fname, ftype, fid) = iprot.readFieldBegin()
3181 
      if ftype == TType.STOP:
3182 
        break
3183 
      if fid == 1:
3184 
        if ftype == TType.I64:
3185 
          self.inventoryItemId = iprot.readI64();
3186 
        else:
3187 
          iprot.skip(ftype)
3188 
      else:
3189 
        iprot.skip(ftype)
3190 
      iprot.readFieldEnd()
3191 
    iprot.readStructEnd()
3192 
 
3193 
  def write(self, oprot):
3194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3196 
      return
3197 
    oprot.writeStructBegin('getInventoryItemFromId_args')
3198 
    if self.inventoryItemId is not None:
3199 
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
3200 
      oprot.writeI64(self.inventoryItemId)
3201 
      oprot.writeFieldEnd()
3202 
    oprot.writeFieldStop()
3203 
    oprot.writeStructEnd()
3204 
 
3205 
  def validate(self):
3206 
    return
3207 
 
3208 
 
3209 
  def __repr__(self):
3210 
    L = ['%s=%r' % (key, value)
3211 
      for key, value in self.__dict__.iteritems()]
3212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3213 
 
3214 
  def __eq__(self, other):
3215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3216 
 
3217 
  def __ne__(self, other):
3218 
    return not (self == other)
3219 
 
3220 
class getInventoryItemFromId_result:
3221 
  """
3222 
  Attributes:
3223 
   - success
3224 
   - wex
3225 
  """
3226 
 
3227 
  thrift_spec = (
3228 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3229 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3230 
  )
3231 
 
3232 
  def __init__(self, success=None, wex=None,):
3233 
    self.success = success
3234 
    self.wex = wex
3235 
 
3236 
  def read(self, iprot):
3237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3239 
      return
3240 
    iprot.readStructBegin()
3241 
    while True:
3242 
      (fname, ftype, fid) = iprot.readFieldBegin()
3243 
      if ftype == TType.STOP:
3244 
        break
3245 
      if fid == 0:
3246 
        if ftype == TType.STRUCT:
3247 
          self.success = InventoryItem()
3248 
          self.success.read(iprot)
3249 
        else:
3250 
          iprot.skip(ftype)
3251 
      elif fid == 1:
3252 
        if ftype == TType.STRUCT:
3253 
          self.wex = WarehouseServiceException()
3254 
          self.wex.read(iprot)
3255 
        else:
3256 
          iprot.skip(ftype)
3257 
      else:
3258 
        iprot.skip(ftype)
3259 
      iprot.readFieldEnd()
3260 
    iprot.readStructEnd()
3261 
 
3262 
  def write(self, oprot):
3263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3265 
      return
3266 
    oprot.writeStructBegin('getInventoryItemFromId_result')
3267 
    if self.success is not None:
3268 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3269 
      self.success.write(oprot)
3270 
      oprot.writeFieldEnd()
3271 
    if self.wex is not None:
3272 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
3273 
      self.wex.write(oprot)
3274 
      oprot.writeFieldEnd()
3275 
    oprot.writeFieldStop()
3276 
    oprot.writeStructEnd()
3277 
 
3278 
  def validate(self):
3279 
    return
3280 
 
3281 
 
3282 
  def __repr__(self):
3283 
    L = ['%s=%r' % (key, value)
3284 
      for key, value in self.__dict__.iteritems()]
3285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3286 
 
3287 
  def __eq__(self, other):
3288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3289 
 
3290 
  def __ne__(self, other):
3291 
    return not (self == other)
5372 mandeep.dh 3292 
 
3293 
class getPurchaseScans_args:
3294 
  """
3295 
  Attributes:
3296 
   - startDate
3297 
   - endDate
3298 
  """
3299 
 
3300 
  thrift_spec = (
3301 
    None, # 0
3302 
    (1, TType.I64, 'startDate', None, None, ), # 1
3303 
    (2, TType.I64, 'endDate', None, None, ), # 2
3304 
  )
3305 
 
3306 
  def __init__(self, startDate=None, endDate=None,):
3307 
    self.startDate = startDate
3308 
    self.endDate = endDate
3309 
 
3310 
  def read(self, iprot):
3311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3313 
      return
3314 
    iprot.readStructBegin()
3315 
    while True:
3316 
      (fname, ftype, fid) = iprot.readFieldBegin()
3317 
      if ftype == TType.STOP:
3318 
        break
3319 
      if fid == 1:
3320 
        if ftype == TType.I64:
3321 
          self.startDate = iprot.readI64();
3322 
        else:
3323 
          iprot.skip(ftype)
3324 
      elif fid == 2:
3325 
        if ftype == TType.I64:
3326 
          self.endDate = iprot.readI64();
3327 
        else:
3328 
          iprot.skip(ftype)
3329 
      else:
3330 
        iprot.skip(ftype)
3331 
      iprot.readFieldEnd()
3332 
    iprot.readStructEnd()
3333 
 
3334 
  def write(self, oprot):
3335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3337 
      return
3338 
    oprot.writeStructBegin('getPurchaseScans_args')
3339 
    if self.startDate is not None:
3340 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
3341 
      oprot.writeI64(self.startDate)
3342 
      oprot.writeFieldEnd()
3343 
    if self.endDate is not None:
3344 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
3345 
      oprot.writeI64(self.endDate)
3346 
      oprot.writeFieldEnd()
3347 
    oprot.writeFieldStop()
3348 
    oprot.writeStructEnd()
3349 
 
3350 
  def validate(self):
3351 
    return
3352 
 
3353 
 
3354 
  def __repr__(self):
3355 
    L = ['%s=%r' % (key, value)
3356 
      for key, value in self.__dict__.iteritems()]
3357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3358 
 
3359 
  def __eq__(self, other):
3360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3361 
 
3362 
  def __ne__(self, other):
3363 
    return not (self == other)
3364 
 
3365 
class getPurchaseScans_result:
3366 
  """
3367 
  Attributes:
3368 
   - success
3369 
  """
3370 
 
3371 
  thrift_spec = (
3372 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
3373 
  )
3374 
 
3375 
  def __init__(self, success=None,):
3376 
    self.success = success
3377 
 
3378 
  def read(self, iprot):
3379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3381 
      return
3382 
    iprot.readStructBegin()
3383 
    while True:
3384 
      (fname, ftype, fid) = iprot.readFieldBegin()
3385 
      if ftype == TType.STOP:
3386 
        break
3387 
      if fid == 0:
3388 
        if ftype == TType.LIST:
3389 
          self.success = []
3390 
          (_etype24, _size21) = iprot.readListBegin()
3391 
          for _i25 in xrange(_size21):
3392 
            _elem26 = DetailedPurchaseScan()
3393 
            _elem26.read(iprot)
3394 
            self.success.append(_elem26)
3395 
          iprot.readListEnd()
3396 
        else:
3397 
          iprot.skip(ftype)
3398 
      else:
3399 
        iprot.skip(ftype)
3400 
      iprot.readFieldEnd()
3401 
    iprot.readStructEnd()
3402 
 
3403 
  def write(self, oprot):
3404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3406 
      return
3407 
    oprot.writeStructBegin('getPurchaseScans_result')
3408 
    if self.success is not None:
3409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3411 
      for iter27 in self.success:
3412 
        iter27.write(oprot)
3413 
      oprot.writeListEnd()
3414 
      oprot.writeFieldEnd()
3415 
    oprot.writeFieldStop()
3416 
    oprot.writeStructEnd()
3417 
 
3418 
  def validate(self):
3419 
    return
3420 
 
3421 
 
3422 
  def __repr__(self):
3423 
    L = ['%s=%r' % (key, value)
3424 
      for key, value in self.__dict__.iteritems()]
3425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3426 
 
3427 
  def __eq__(self, other):
3428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3429 
 
3430 
  def __ne__(self, other):
3431 
    return not (self == other)
5496 mandeep.dh 3432 
 
7216 amar.kumar 3433 
class getPurchaseScansByGrnDate_args:
3434 
  """
3435 
  Attributes:
3436 
   - startDate
3437 
   - endDate
3438 
  """
3439 
 
3440 
  thrift_spec = (
3441 
    None, # 0
3442 
    (1, TType.I64, 'startDate', None, None, ), # 1
3443 
    (2, TType.I64, 'endDate', None, None, ), # 2
3444 
  )
3445 
 
3446 
  def __init__(self, startDate=None, endDate=None,):
3447 
    self.startDate = startDate
3448 
    self.endDate = endDate
3449 
 
3450 
  def read(self, iprot):
3451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3453 
      return
3454 
    iprot.readStructBegin()
3455 
    while True:
3456 
      (fname, ftype, fid) = iprot.readFieldBegin()
3457 
      if ftype == TType.STOP:
3458 
        break
3459 
      if fid == 1:
3460 
        if ftype == TType.I64:
3461 
          self.startDate = iprot.readI64();
3462 
        else:
3463 
          iprot.skip(ftype)
3464 
      elif fid == 2:
3465 
        if ftype == TType.I64:
3466 
          self.endDate = iprot.readI64();
3467 
        else:
3468 
          iprot.skip(ftype)
3469 
      else:
3470 
        iprot.skip(ftype)
3471 
      iprot.readFieldEnd()
3472 
    iprot.readStructEnd()
3473 
 
3474 
  def write(self, oprot):
3475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3477 
      return
3478 
    oprot.writeStructBegin('getPurchaseScansByGrnDate_args')
3479 
    if self.startDate is not None:
3480 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
3481 
      oprot.writeI64(self.startDate)
3482 
      oprot.writeFieldEnd()
3483 
    if self.endDate is not None:
3484 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
3485 
      oprot.writeI64(self.endDate)
3486 
      oprot.writeFieldEnd()
3487 
    oprot.writeFieldStop()
3488 
    oprot.writeStructEnd()
3489 
 
3490 
  def validate(self):
3491 
    return
3492 
 
3493 
 
3494 
  def __repr__(self):
3495 
    L = ['%s=%r' % (key, value)
3496 
      for key, value in self.__dict__.iteritems()]
3497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3498 
 
3499 
  def __eq__(self, other):
3500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3501 
 
3502 
  def __ne__(self, other):
3503 
    return not (self == other)
3504 
 
3505 
class getPurchaseScansByGrnDate_result:
3506 
  """
3507 
  Attributes:
3508 
   - success
3509 
  """
3510 
 
3511 
  thrift_spec = (
3512 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
3513 
  )
3514 
 
3515 
  def __init__(self, success=None,):
3516 
    self.success = success
3517 
 
3518 
  def read(self, iprot):
3519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3521 
      return
3522 
    iprot.readStructBegin()
3523 
    while True:
3524 
      (fname, ftype, fid) = iprot.readFieldBegin()
3525 
      if ftype == TType.STOP:
3526 
        break
3527 
      if fid == 0:
3528 
        if ftype == TType.LIST:
3529 
          self.success = []
3530 
          (_etype31, _size28) = iprot.readListBegin()
3531 
          for _i32 in xrange(_size28):
3532 
            _elem33 = DetailedPurchaseScan()
3533 
            _elem33.read(iprot)
3534 
            self.success.append(_elem33)
3535 
          iprot.readListEnd()
3536 
        else:
3537 
          iprot.skip(ftype)
3538 
      else:
3539 
        iprot.skip(ftype)
3540 
      iprot.readFieldEnd()
3541 
    iprot.readStructEnd()
3542 
 
3543 
  def write(self, oprot):
3544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3546 
      return
3547 
    oprot.writeStructBegin('getPurchaseScansByGrnDate_result')
3548 
    if self.success is not None:
3549 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3550 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3551 
      for iter34 in self.success:
3552 
        iter34.write(oprot)
3553 
      oprot.writeListEnd()
3554 
      oprot.writeFieldEnd()
3555 
    oprot.writeFieldStop()
3556 
    oprot.writeStructEnd()
3557 
 
3558 
  def validate(self):
3559 
    return
3560 
 
3561 
 
3562 
  def __repr__(self):
3563 
    L = ['%s=%r' % (key, value)
3564 
      for key, value in self.__dict__.iteritems()]
3565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3566 
 
3567 
  def __eq__(self, other):
3568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3569 
 
3570 
  def __ne__(self, other):
3571 
    return not (self == other)
3572 
 
5496 mandeep.dh 3573 
class fetchScansPerInvoiceNumber_args:
3574 
  """
3575 
  Attributes:
3576 
   - date
3577 
  """
3578 
 
3579 
  thrift_spec = (
3580 
    None, # 0
3581 
    (1, TType.I64, 'date', None, None, ), # 1
3582 
  )
3583 
 
3584 
  def __init__(self, date=None,):
3585 
    self.date = date
3586 
 
3587 
  def read(self, iprot):
3588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3590 
      return
3591 
    iprot.readStructBegin()
3592 
    while True:
3593 
      (fname, ftype, fid) = iprot.readFieldBegin()
3594 
      if ftype == TType.STOP:
3595 
        break
3596 
      if fid == 1:
3597 
        if ftype == TType.I64:
3598 
          self.date = iprot.readI64();
3599 
        else:
3600 
          iprot.skip(ftype)
3601 
      else:
3602 
        iprot.skip(ftype)
3603 
      iprot.readFieldEnd()
3604 
    iprot.readStructEnd()
3605 
 
3606 
  def write(self, oprot):
3607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3609 
      return
3610 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_args')
3611 
    if self.date is not None:
3612 
      oprot.writeFieldBegin('date', TType.I64, 1)
3613 
      oprot.writeI64(self.date)
3614 
      oprot.writeFieldEnd()
3615 
    oprot.writeFieldStop()
3616 
    oprot.writeStructEnd()
3617 
 
3618 
  def validate(self):
3619 
    return
3620 
 
3621 
 
3622 
  def __repr__(self):
3623 
    L = ['%s=%r' % (key, value)
3624 
      for key, value in self.__dict__.iteritems()]
3625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3626 
 
3627 
  def __eq__(self, other):
3628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3629 
 
3630 
  def __ne__(self, other):
3631 
    return not (self == other)
3632 
 
3633 
class fetchScansPerInvoiceNumber_result:
3634 
  """
3635 
  Attributes:
3636 
   - success
3637 
  """
3638 
 
3639 
  thrift_spec = (
3640 
    (0, TType.LIST, 'success', (TType.STRUCT,(InvoiceScan, InvoiceScan.thrift_spec)), None, ), # 0
3641 
  )
3642 
 
3643 
  def __init__(self, success=None,):
3644 
    self.success = success
3645 
 
3646 
  def read(self, iprot):
3647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3649 
      return
3650 
    iprot.readStructBegin()
3651 
    while True:
3652 
      (fname, ftype, fid) = iprot.readFieldBegin()
3653 
      if ftype == TType.STOP:
3654 
        break
3655 
      if fid == 0:
3656 
        if ftype == TType.LIST:
3657 
          self.success = []
7216 amar.kumar 3658 
          (_etype38, _size35) = iprot.readListBegin()
3659 
          for _i39 in xrange(_size35):
3660 
            _elem40 = InvoiceScan()
3661 
            _elem40.read(iprot)
3662 
            self.success.append(_elem40)
5496 mandeep.dh 3663 
          iprot.readListEnd()
3664 
        else:
3665 
          iprot.skip(ftype)
3666 
      else:
3667 
        iprot.skip(ftype)
3668 
      iprot.readFieldEnd()
3669 
    iprot.readStructEnd()
3670 
 
3671 
  def write(self, oprot):
3672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3674 
      return
3675 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_result')
3676 
    if self.success is not None:
3677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3678 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 3679 
      for iter41 in self.success:
3680 
        iter41.write(oprot)
5496 mandeep.dh 3681 
      oprot.writeListEnd()
3682 
      oprot.writeFieldEnd()
3683 
    oprot.writeFieldStop()
3684 
    oprot.writeStructEnd()
3685 
 
3686 
  def validate(self):
3687 
    return
3688 
 
3689 
 
3690 
  def __repr__(self):
3691 
    L = ['%s=%r' % (key, value)
3692 
      for key, value in self.__dict__.iteritems()]
3693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3694 
 
3695 
  def __eq__(self, other):
3696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3697 
 
3698 
  def __ne__(self, other):
3699 
    return not (self == other)
5620 mandeep.dh 3700 
 
3701 
class getInventoryItemFromOrder_args:
3702 
  """
3703 
  Attributes:
3704 
   - orderId
3705 
  """
3706 
 
3707 
  thrift_spec = (
3708 
    None, # 0
3709 
    (1, TType.I64, 'orderId', None, None, ), # 1
3710 
  )
3711 
 
3712 
  def __init__(self, orderId=None,):
3713 
    self.orderId = orderId
3714 
 
3715 
  def read(self, iprot):
3716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3718 
      return
3719 
    iprot.readStructBegin()
3720 
    while True:
3721 
      (fname, ftype, fid) = iprot.readFieldBegin()
3722 
      if ftype == TType.STOP:
3723 
        break
3724 
      if fid == 1:
3725 
        if ftype == TType.I64:
3726 
          self.orderId = iprot.readI64();
3727 
        else:
3728 
          iprot.skip(ftype)
3729 
      else:
3730 
        iprot.skip(ftype)
3731 
      iprot.readFieldEnd()
3732 
    iprot.readStructEnd()
3733 
 
3734 
  def write(self, oprot):
3735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3737 
      return
3738 
    oprot.writeStructBegin('getInventoryItemFromOrder_args')
3739 
    if self.orderId is not None:
3740 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3741 
      oprot.writeI64(self.orderId)
3742 
      oprot.writeFieldEnd()
3743 
    oprot.writeFieldStop()
3744 
    oprot.writeStructEnd()
3745 
 
3746 
  def validate(self):
3747 
    return
3748 
 
3749 
 
3750 
  def __repr__(self):
3751 
    L = ['%s=%r' % (key, value)
3752 
      for key, value in self.__dict__.iteritems()]
3753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3754 
 
3755 
  def __eq__(self, other):
3756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3757 
 
3758 
  def __ne__(self, other):
3759 
    return not (self == other)
3760 
 
3761 
class getInventoryItemFromOrder_result:
3762 
  """
3763 
  Attributes:
3764 
   - success
3765 
   - we
3766 
  """
3767 
 
3768 
  thrift_spec = (
3769 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3770 
    (1, TType.STRUCT, 'we', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3771 
  )
3772 
 
3773 
  def __init__(self, success=None, we=None,):
3774 
    self.success = success
3775 
    self.we = we
3776 
 
3777 
  def read(self, iprot):
3778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3780 
      return
3781 
    iprot.readStructBegin()
3782 
    while True:
3783 
      (fname, ftype, fid) = iprot.readFieldBegin()
3784 
      if ftype == TType.STOP:
3785 
        break
3786 
      if fid == 0:
3787 
        if ftype == TType.STRUCT:
3788 
          self.success = InventoryItem()
3789 
          self.success.read(iprot)
3790 
        else:
3791 
          iprot.skip(ftype)
3792 
      elif fid == 1:
3793 
        if ftype == TType.STRUCT:
3794 
          self.we = WarehouseServiceException()
3795 
          self.we.read(iprot)
3796 
        else:
3797 
          iprot.skip(ftype)
3798 
      else:
3799 
        iprot.skip(ftype)
3800 
      iprot.readFieldEnd()
3801 
    iprot.readStructEnd()
3802 
 
3803 
  def write(self, oprot):
3804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3806 
      return
3807 
    oprot.writeStructBegin('getInventoryItemFromOrder_result')
3808 
    if self.success is not None:
3809 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3810 
      self.success.write(oprot)
3811 
      oprot.writeFieldEnd()
3812 
    if self.we is not None:
3813 
      oprot.writeFieldBegin('we', TType.STRUCT, 1)
3814 
      self.we.write(oprot)
3815 
      oprot.writeFieldEnd()
3816 
    oprot.writeFieldStop()
3817 
    oprot.writeStructEnd()
3818 
 
3819 
  def validate(self):
3820 
    return
3821 
 
3822 
 
3823 
  def __repr__(self):
3824 
    L = ['%s=%r' % (key, value)
3825 
      for key, value in self.__dict__.iteritems()]
3826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3827 
 
3828 
  def __eq__(self, other):
3829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3830 
 
3831 
  def __ne__(self, other):
3832 
    return not (self == other)
5711 mandeep.dh 3833 
 
3834 
class getInventoryAge_args:
3835 
 
3836 
  thrift_spec = (
3837 
  )
3838 
 
3839 
  def read(self, iprot):
3840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3842 
      return
3843 
    iprot.readStructBegin()
3844 
    while True:
3845 
      (fname, ftype, fid) = iprot.readFieldBegin()
3846 
      if ftype == TType.STOP:
3847 
        break
3848 
      else:
3849 
        iprot.skip(ftype)
3850 
      iprot.readFieldEnd()
3851 
    iprot.readStructEnd()
3852 
 
3853 
  def write(self, oprot):
3854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3856 
      return
3857 
    oprot.writeStructBegin('getInventoryAge_args')
3858 
    oprot.writeFieldStop()
3859 
    oprot.writeStructEnd()
3860 
 
3861 
  def validate(self):
3862 
    return
3863 
 
3864 
 
3865 
  def __repr__(self):
3866 
    L = ['%s=%r' % (key, value)
3867 
      for key, value in self.__dict__.iteritems()]
3868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3869 
 
3870 
  def __eq__(self, other):
3871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3872 
 
3873 
  def __ne__(self, other):
3874 
    return not (self == other)
3875 
 
3876 
class getInventoryAge_result:
3877 
  """
3878 
  Attributes:
3879 
   - success
3880 
  """
3881 
 
3882 
  thrift_spec = (
3883 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAge, InventoryAge.thrift_spec)), None, ), # 0
3884 
  )
3885 
 
3886 
  def __init__(self, success=None,):
3887 
    self.success = success
3888 
 
3889 
  def read(self, iprot):
3890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3892 
      return
3893 
    iprot.readStructBegin()
3894 
    while True:
3895 
      (fname, ftype, fid) = iprot.readFieldBegin()
3896 
      if ftype == TType.STOP:
3897 
        break
3898 
      if fid == 0:
3899 
        if ftype == TType.LIST:
3900 
          self.success = []
7216 amar.kumar 3901 
          (_etype45, _size42) = iprot.readListBegin()
3902 
          for _i46 in xrange(_size42):
3903 
            _elem47 = InventoryAge()
3904 
            _elem47.read(iprot)
3905 
            self.success.append(_elem47)
5711 mandeep.dh 3906 
          iprot.readListEnd()
3907 
        else:
3908 
          iprot.skip(ftype)
3909 
      else:
3910 
        iprot.skip(ftype)
3911 
      iprot.readFieldEnd()
3912 
    iprot.readStructEnd()
3913 
 
3914 
  def write(self, oprot):
3915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3917 
      return
3918 
    oprot.writeStructBegin('getInventoryAge_result')
3919 
    if self.success is not None:
3920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 3922 
      for iter48 in self.success:
3923 
        iter48.write(oprot)
5711 mandeep.dh 3924 
      oprot.writeListEnd()
3925 
      oprot.writeFieldEnd()
3926 
    oprot.writeFieldStop()
3927 
    oprot.writeStructEnd()
3928 
 
3929 
  def validate(self):
3930 
    return
3931 
 
3932 
 
3933 
  def __repr__(self):
3934 
    L = ['%s=%r' % (key, value)
3935 
      for key, value in self.__dict__.iteritems()]
3936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3937 
 
3938 
  def __eq__(self, other):
3939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3940 
 
3941 
  def __ne__(self, other):
3942 
    return not (self == other)
6361 rajveer 3943 
 
3944 
class getInventoryScansForItem_args:
3945 
  """
3946 
  Attributes:
3947 
   - itemId
3948 
   - fromDate
3949 
   - toDate
3950 
  """
3951 
 
3952 
  thrift_spec = (
3953 
    None, # 0
3954 
    (1, TType.I64, 'itemId', None, None, ), # 1
3955 
    (2, TType.I64, 'fromDate', None, None, ), # 2
3956 
    (3, TType.I64, 'toDate', None, None, ), # 3
3957 
  )
3958 
 
3959 
  def __init__(self, itemId=None, fromDate=None, toDate=None,):
3960 
    self.itemId = itemId
3961 
    self.fromDate = fromDate
3962 
    self.toDate = toDate
3963 
 
3964 
  def read(self, iprot):
3965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3967 
      return
3968 
    iprot.readStructBegin()
3969 
    while True:
3970 
      (fname, ftype, fid) = iprot.readFieldBegin()
3971 
      if ftype == TType.STOP:
3972 
        break
3973 
      if fid == 1:
3974 
        if ftype == TType.I64:
3975 
          self.itemId = iprot.readI64();
3976 
        else:
3977 
          iprot.skip(ftype)
3978 
      elif fid == 2:
3979 
        if ftype == TType.I64:
3980 
          self.fromDate = iprot.readI64();
3981 
        else:
3982 
          iprot.skip(ftype)
3983 
      elif fid == 3:
3984 
        if ftype == TType.I64:
3985 
          self.toDate = iprot.readI64();
3986 
        else:
3987 
          iprot.skip(ftype)
3988 
      else:
3989 
        iprot.skip(ftype)
3990 
      iprot.readFieldEnd()
3991 
    iprot.readStructEnd()
3992 
 
3993 
  def write(self, oprot):
3994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3996 
      return
3997 
    oprot.writeStructBegin('getInventoryScansForItem_args')
3998 
    if self.itemId is not None:
3999 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
4000 
      oprot.writeI64(self.itemId)
4001 
      oprot.writeFieldEnd()
4002 
    if self.fromDate is not None:
4003 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
4004 
      oprot.writeI64(self.fromDate)
4005 
      oprot.writeFieldEnd()
4006 
    if self.toDate is not None:
4007 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
4008 
      oprot.writeI64(self.toDate)
4009 
      oprot.writeFieldEnd()
4010 
    oprot.writeFieldStop()
4011 
    oprot.writeStructEnd()
4012 
 
4013 
  def validate(self):
4014 
    return
4015 
 
4016 
 
4017 
  def __repr__(self):
4018 
    L = ['%s=%r' % (key, value)
4019 
      for key, value in self.__dict__.iteritems()]
4020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4021 
 
4022 
  def __eq__(self, other):
4023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4024 
 
4025 
  def __ne__(self, other):
4026 
    return not (self == other)
4027 
 
4028 
class getInventoryScansForItem_result:
4029 
  """
4030 
  Attributes:
4031 
   - success
4032 
  """
4033 
 
4034 
  thrift_spec = (
4035 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
4036 
  )
4037 
 
4038 
  def __init__(self, success=None,):
4039 
    self.success = success
4040 
 
4041 
  def read(self, iprot):
4042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4044 
      return
4045 
    iprot.readStructBegin()
4046 
    while True:
4047 
      (fname, ftype, fid) = iprot.readFieldBegin()
4048 
      if ftype == TType.STOP:
4049 
        break
4050 
      if fid == 0:
4051 
        if ftype == TType.LIST:
4052 
          self.success = []
7216 amar.kumar 4053 
          (_etype52, _size49) = iprot.readListBegin()
4054 
          for _i53 in xrange(_size49):
4055 
            _elem54 = Scan()
4056 
            _elem54.read(iprot)
4057 
            self.success.append(_elem54)
6361 rajveer 4058 
          iprot.readListEnd()
4059 
        else:
4060 
          iprot.skip(ftype)
4061 
      else:
4062 
        iprot.skip(ftype)
4063 
      iprot.readFieldEnd()
4064 
    iprot.readStructEnd()
4065 
 
4066 
  def write(self, oprot):
4067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4069 
      return
4070 
    oprot.writeStructBegin('getInventoryScansForItem_result')
4071 
    if self.success is not None:
4072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4074 
      for iter55 in self.success:
4075 
        iter55.write(oprot)
6361 rajveer 4076 
      oprot.writeListEnd()
4077 
      oprot.writeFieldEnd()
4078 
    oprot.writeFieldStop()
4079 
    oprot.writeStructEnd()
4080 
 
4081 
  def validate(self):
4082 
    return
4083 
 
4084 
 
4085 
  def __repr__(self):
4086 
    L = ['%s=%r' % (key, value)
4087 
      for key, value in self.__dict__.iteritems()]
4088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4089 
 
4090 
  def __eq__(self, other):
4091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4092 
 
4093 
  def __ne__(self, other):
4094 
    return not (self == other)
4095 
 
4096 
class getScanRecordsForSerialNumber_args:
4097 
  """
4098 
  Attributes:
4099 
   - serialNumber
4100 
  """
4101 
 
4102 
  thrift_spec = (
4103 
    None, # 0
4104 
    (1, TType.I64, 'serialNumber', None, None, ), # 1
4105 
  )
4106 
 
4107 
  def __init__(self, serialNumber=None,):
4108 
    self.serialNumber = serialNumber
4109 
 
4110 
  def read(self, iprot):
4111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4113 
      return
4114 
    iprot.readStructBegin()
4115 
    while True:
4116 
      (fname, ftype, fid) = iprot.readFieldBegin()
4117 
      if ftype == TType.STOP:
4118 
        break
4119 
      if fid == 1:
4120 
        if ftype == TType.I64:
4121 
          self.serialNumber = iprot.readI64();
4122 
        else:
4123 
          iprot.skip(ftype)
4124 
      else:
4125 
        iprot.skip(ftype)
4126 
      iprot.readFieldEnd()
4127 
    iprot.readStructEnd()
4128 
 
4129 
  def write(self, oprot):
4130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4132 
      return
4133 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_args')
4134 
    if self.serialNumber is not None:
4135 
      oprot.writeFieldBegin('serialNumber', TType.I64, 1)
4136 
      oprot.writeI64(self.serialNumber)
4137 
      oprot.writeFieldEnd()
4138 
    oprot.writeFieldStop()
4139 
    oprot.writeStructEnd()
4140 
 
4141 
  def validate(self):
4142 
    return
4143 
 
4144 
 
4145 
  def __repr__(self):
4146 
    L = ['%s=%r' % (key, value)
4147 
      for key, value in self.__dict__.iteritems()]
4148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4149 
 
4150 
  def __eq__(self, other):
4151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4152 
 
4153 
  def __ne__(self, other):
4154 
    return not (self == other)
4155 
 
4156 
class getScanRecordsForSerialNumber_result:
4157 
  """
4158 
  Attributes:
4159 
   - success
4160 
  """
4161 
 
4162 
  thrift_spec = (
4163 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
4164 
  )
4165 
 
4166 
  def __init__(self, success=None,):
4167 
    self.success = success
4168 
 
4169 
  def read(self, iprot):
4170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4172 
      return
4173 
    iprot.readStructBegin()
4174 
    while True:
4175 
      (fname, ftype, fid) = iprot.readFieldBegin()
4176 
      if ftype == TType.STOP:
4177 
        break
4178 
      if fid == 0:
4179 
        if ftype == TType.LIST:
4180 
          self.success = []
7216 amar.kumar 4181 
          (_etype59, _size56) = iprot.readListBegin()
4182 
          for _i60 in xrange(_size56):
4183 
            _elem61 = Scan()
4184 
            _elem61.read(iprot)
4185 
            self.success.append(_elem61)
6361 rajveer 4186 
          iprot.readListEnd()
4187 
        else:
4188 
          iprot.skip(ftype)
4189 
      else:
4190 
        iprot.skip(ftype)
4191 
      iprot.readFieldEnd()
4192 
    iprot.readStructEnd()
4193 
 
4194 
  def write(self, oprot):
4195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4197 
      return
4198 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_result')
4199 
    if self.success is not None:
4200 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4201 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4202 
      for iter62 in self.success:
4203 
        iter62.write(oprot)
6361 rajveer 4204 
      oprot.writeListEnd()
4205 
      oprot.writeFieldEnd()
4206 
    oprot.writeFieldStop()
4207 
    oprot.writeStructEnd()
4208 
 
4209 
  def validate(self):
4210 
    return
4211 
 
4212 
 
4213 
  def __repr__(self):
4214 
    L = ['%s=%r' % (key, value)
4215 
      for key, value in self.__dict__.iteritems()]
4216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4217 
 
4218 
  def __eq__(self, other):
4219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4220 
 
4221 
  def __ne__(self, other):
4222 
    return not (self == other)
6467 amar.kumar 4223 
 
4224 
class scanForPurchaseReturn_args:
4225 
  """
4226 
  Attributes:
4227 
   - saleReturnItems
4228 
   - vendorId
4229 
  """
4230 
 
4231 
  thrift_spec = (
4232 
    None, # 0
4233 
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
4234 
    (2, TType.I64, 'vendorId', None, None, ), # 2
4235 
  )
4236 
 
4237 
  def __init__(self, saleReturnItems=None, vendorId=None,):
4238 
    self.saleReturnItems = saleReturnItems
4239 
    self.vendorId = vendorId
4240 
 
4241 
  def read(self, iprot):
4242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4244 
      return
4245 
    iprot.readStructBegin()
4246 
    while True:
4247 
      (fname, ftype, fid) = iprot.readFieldBegin()
4248 
      if ftype == TType.STOP:
4249 
        break
4250 
      if fid == 1:
4251 
        if ftype == TType.LIST:
4252 
          self.saleReturnItems = []
7216 amar.kumar 4253 
          (_etype66, _size63) = iprot.readListBegin()
4254 
          for _i67 in xrange(_size63):
4255 
            _elem68 = InventoryItem()
4256 
            _elem68.read(iprot)
4257 
            self.saleReturnItems.append(_elem68)
6467 amar.kumar 4258 
          iprot.readListEnd()
4259 
        else:
4260 
          iprot.skip(ftype)
4261 
      elif fid == 2:
4262 
        if ftype == TType.I64:
4263 
          self.vendorId = iprot.readI64();
4264 
        else:
4265 
          iprot.skip(ftype)
4266 
      else:
4267 
        iprot.skip(ftype)
4268 
      iprot.readFieldEnd()
4269 
    iprot.readStructEnd()
4270 
 
4271 
  def write(self, oprot):
4272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4274 
      return
4275 
    oprot.writeStructBegin('scanForPurchaseReturn_args')
4276 
    if self.saleReturnItems is not None:
4277 
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
4278 
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
7216 amar.kumar 4279 
      for iter69 in self.saleReturnItems:
4280 
        iter69.write(oprot)
6467 amar.kumar 4281 
      oprot.writeListEnd()
4282 
      oprot.writeFieldEnd()
4283 
    if self.vendorId is not None:
4284 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
4285 
      oprot.writeI64(self.vendorId)
4286 
      oprot.writeFieldEnd()
4287 
    oprot.writeFieldStop()
4288 
    oprot.writeStructEnd()
4289 
 
4290 
  def validate(self):
4291 
    return
4292 
 
4293 
 
4294 
  def __repr__(self):
4295 
    L = ['%s=%r' % (key, value)
4296 
      for key, value in self.__dict__.iteritems()]
4297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4298 
 
4299 
  def __eq__(self, other):
4300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4301 
 
4302 
  def __ne__(self, other):
4303 
    return not (self == other)
4304 
 
4305 
class scanForPurchaseReturn_result:
4306 
  """
4307 
  Attributes:
4308 
   - ex
4309 
  """
4310 
 
4311 
  thrift_spec = (
4312 
    None, # 0
4313 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4314 
  )
4315 
 
4316 
  def __init__(self, ex=None,):
4317 
    self.ex = ex
4318 
 
4319 
  def read(self, iprot):
4320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4322 
      return
4323 
    iprot.readStructBegin()
4324 
    while True:
4325 
      (fname, ftype, fid) = iprot.readFieldBegin()
4326 
      if ftype == TType.STOP:
4327 
        break
4328 
      if fid == 1:
4329 
        if ftype == TType.STRUCT:
4330 
          self.ex = WarehouseServiceException()
4331 
          self.ex.read(iprot)
4332 
        else:
4333 
          iprot.skip(ftype)
4334 
      else:
4335 
        iprot.skip(ftype)
4336 
      iprot.readFieldEnd()
4337 
    iprot.readStructEnd()
4338 
 
4339 
  def write(self, oprot):
4340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4342 
      return
4343 
    oprot.writeStructBegin('scanForPurchaseReturn_result')
4344 
    if self.ex is not None:
4345 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4346 
      self.ex.write(oprot)
4347 
      oprot.writeFieldEnd()
4348 
    oprot.writeFieldStop()
4349 
    oprot.writeStructEnd()
4350 
 
4351 
  def validate(self):
4352 
    return
4353 
 
4354 
 
4355 
  def __repr__(self):
4356 
    L = ['%s=%r' % (key, value)
4357 
      for key, value in self.__dict__.iteritems()]
4358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4359 
 
4360 
  def __eq__(self, other):
4361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4362 
 
4363 
  def __ne__(self, other):
4364 
    return not (self == other)
6630 amar.kumar 4365 
 
4366 
class scanForLostItem_args:
4367 
  """
4368 
  Attributes:
4369 
   - lostItems
4370 
   - vendorId
4371 
  """
4372 
 
4373 
  thrift_spec = (
4374 
    None, # 0
4375 
    (1, TType.LIST, 'lostItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
4376 
    (2, TType.I64, 'vendorId', None, None, ), # 2
4377 
  )
4378 
 
4379 
  def __init__(self, lostItems=None, vendorId=None,):
4380 
    self.lostItems = lostItems
4381 
    self.vendorId = vendorId
4382 
 
4383 
  def read(self, iprot):
4384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4386 
      return
4387 
    iprot.readStructBegin()
4388 
    while True:
4389 
      (fname, ftype, fid) = iprot.readFieldBegin()
4390 
      if ftype == TType.STOP:
4391 
        break
4392 
      if fid == 1:
4393 
        if ftype == TType.LIST:
4394 
          self.lostItems = []
7216 amar.kumar 4395 
          (_etype73, _size70) = iprot.readListBegin()
4396 
          for _i74 in xrange(_size70):
4397 
            _elem75 = InventoryItem()
4398 
            _elem75.read(iprot)
4399 
            self.lostItems.append(_elem75)
6630 amar.kumar 4400 
          iprot.readListEnd()
4401 
        else:
4402 
          iprot.skip(ftype)
4403 
      elif fid == 2:
4404 
        if ftype == TType.I64:
4405 
          self.vendorId = iprot.readI64();
4406 
        else:
4407 
          iprot.skip(ftype)
4408 
      else:
4409 
        iprot.skip(ftype)
4410 
      iprot.readFieldEnd()
4411 
    iprot.readStructEnd()
4412 
 
4413 
  def write(self, oprot):
4414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4416 
      return
4417 
    oprot.writeStructBegin('scanForLostItem_args')
4418 
    if self.lostItems is not None:
4419 
      oprot.writeFieldBegin('lostItems', TType.LIST, 1)
4420 
      oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
7216 amar.kumar 4421 
      for iter76 in self.lostItems:
4422 
        iter76.write(oprot)
6630 amar.kumar 4423 
      oprot.writeListEnd()
4424 
      oprot.writeFieldEnd()
4425 
    if self.vendorId is not None:
4426 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
4427 
      oprot.writeI64(self.vendorId)
4428 
      oprot.writeFieldEnd()
4429 
    oprot.writeFieldStop()
4430 
    oprot.writeStructEnd()
4431 
 
4432 
  def validate(self):
4433 
    return
4434 
 
4435 
 
4436 
  def __repr__(self):
4437 
    L = ['%s=%r' % (key, value)
4438 
      for key, value in self.__dict__.iteritems()]
4439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4440 
 
4441 
  def __eq__(self, other):
4442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4443 
 
4444 
  def __ne__(self, other):
4445 
    return not (self == other)
4446 
 
4447 
class scanForLostItem_result:
4448 
  """
4449 
  Attributes:
4450 
   - ex
4451 
  """
4452 
 
4453 
  thrift_spec = (
4454 
    None, # 0
4455 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4456 
  )
4457 
 
4458 
  def __init__(self, ex=None,):
4459 
    self.ex = ex
4460 
 
4461 
  def read(self, iprot):
4462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4464 
      return
4465 
    iprot.readStructBegin()
4466 
    while True:
4467 
      (fname, ftype, fid) = iprot.readFieldBegin()
4468 
      if ftype == TType.STOP:
4469 
        break
4470 
      if fid == 1:
4471 
        if ftype == TType.STRUCT:
4472 
          self.ex = WarehouseServiceException()
4473 
          self.ex.read(iprot)
4474 
        else:
4475 
          iprot.skip(ftype)
4476 
      else:
4477 
        iprot.skip(ftype)
4478 
      iprot.readFieldEnd()
4479 
    iprot.readStructEnd()
4480 
 
4481 
  def write(self, oprot):
4482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4484 
      return
4485 
    oprot.writeStructBegin('scanForLostItem_result')
4486 
    if self.ex is not None:
4487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4488 
      self.ex.write(oprot)
4489 
      oprot.writeFieldEnd()
4490 
    oprot.writeFieldStop()
4491 
    oprot.writeStructEnd()
4492 
 
4493 
  def validate(self):
4494 
    return
4495 
 
4496 
 
4497 
  def __repr__(self):
4498 
    L = ['%s=%r' % (key, value)
4499 
      for key, value in self.__dict__.iteritems()]
4500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4501 
 
4502 
  def __eq__(self, other):
4503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4504 
 
4505 
  def __ne__(self, other):
4506 
    return not (self == other)
4507 
 
4508 
class getCurrentSerializedInventoryByScans_args:
4509 
 
4510 
  thrift_spec = (
4511 
  )
4512 
 
4513 
  def read(self, iprot):
4514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4516 
      return
4517 
    iprot.readStructBegin()
4518 
    while True:
4519 
      (fname, ftype, fid) = iprot.readFieldBegin()
4520 
      if ftype == TType.STOP:
4521 
        break
4522 
      else:
4523 
        iprot.skip(ftype)
4524 
      iprot.readFieldEnd()
4525 
    iprot.readStructEnd()
4526 
 
4527 
  def write(self, oprot):
4528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4530 
      return
4531 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_args')
4532 
    oprot.writeFieldStop()
4533 
    oprot.writeStructEnd()
4534 
 
4535 
  def validate(self):
4536 
    return
4537 
 
4538 
 
4539 
  def __repr__(self):
4540 
    L = ['%s=%r' % (key, value)
4541 
      for key, value in self.__dict__.iteritems()]
4542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4543 
 
4544 
  def __eq__(self, other):
4545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4546 
 
4547 
  def __ne__(self, other):
4548 
    return not (self == other)
4549 
 
4550 
class getCurrentSerializedInventoryByScans_result:
4551 
  """
4552 
  Attributes:
4553 
   - success
4554 
  """
4555 
 
4556 
  thrift_spec = (
4557 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4558 
  )
4559 
 
4560 
  def __init__(self, success=None,):
4561 
    self.success = success
4562 
 
4563 
  def read(self, iprot):
4564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4566 
      return
4567 
    iprot.readStructBegin()
4568 
    while True:
4569 
      (fname, ftype, fid) = iprot.readFieldBegin()
4570 
      if ftype == TType.STOP:
4571 
        break
4572 
      if fid == 0:
4573 
        if ftype == TType.LIST:
4574 
          self.success = []
7216 amar.kumar 4575 
          (_etype80, _size77) = iprot.readListBegin()
4576 
          for _i81 in xrange(_size77):
4577 
            _elem82 = InventoryAvailability()
4578 
            _elem82.read(iprot)
4579 
            self.success.append(_elem82)
6630 amar.kumar 4580 
          iprot.readListEnd()
4581 
        else:
4582 
          iprot.skip(ftype)
4583 
      else:
4584 
        iprot.skip(ftype)
4585 
      iprot.readFieldEnd()
4586 
    iprot.readStructEnd()
4587 
 
4588 
  def write(self, oprot):
4589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4591 
      return
4592 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_result')
4593 
    if self.success is not None:
4594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4596 
      for iter83 in self.success:
4597 
        iter83.write(oprot)
6630 amar.kumar 4598 
      oprot.writeListEnd()
4599 
      oprot.writeFieldEnd()
4600 
    oprot.writeFieldStop()
4601 
    oprot.writeStructEnd()
4602 
 
4603 
  def validate(self):
4604 
    return
4605 
 
4606 
 
4607 
  def __repr__(self):
4608 
    L = ['%s=%r' % (key, value)
4609 
      for key, value in self.__dict__.iteritems()]
4610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4611 
 
4612 
  def __eq__(self, other):
4613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4614 
 
4615 
  def __ne__(self, other):
4616 
    return not (self == other)
4617 
 
4618 
class getCurrentNonSerializedInventoryByScans_args:
4619 
 
4620 
  thrift_spec = (
4621 
  )
4622 
 
4623 
  def read(self, iprot):
4624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4626 
      return
4627 
    iprot.readStructBegin()
4628 
    while True:
4629 
      (fname, ftype, fid) = iprot.readFieldBegin()
4630 
      if ftype == TType.STOP:
4631 
        break
4632 
      else:
4633 
        iprot.skip(ftype)
4634 
      iprot.readFieldEnd()
4635 
    iprot.readStructEnd()
4636 
 
4637 
  def write(self, oprot):
4638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4640 
      return
4641 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_args')
4642 
    oprot.writeFieldStop()
4643 
    oprot.writeStructEnd()
4644 
 
4645 
  def validate(self):
4646 
    return
4647 
 
4648 
 
4649 
  def __repr__(self):
4650 
    L = ['%s=%r' % (key, value)
4651 
      for key, value in self.__dict__.iteritems()]
4652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4653 
 
4654 
  def __eq__(self, other):
4655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4656 
 
4657 
  def __ne__(self, other):
4658 
    return not (self == other)
4659 
 
4660 
class getCurrentNonSerializedInventoryByScans_result:
4661 
  """
4662 
  Attributes:
4663 
   - success
4664 
  """
4665 
 
4666 
  thrift_spec = (
4667 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4668 
  )
4669 
 
4670 
  def __init__(self, success=None,):
4671 
    self.success = success
4672 
 
4673 
  def read(self, iprot):
4674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4676 
      return
4677 
    iprot.readStructBegin()
4678 
    while True:
4679 
      (fname, ftype, fid) = iprot.readFieldBegin()
4680 
      if ftype == TType.STOP:
4681 
        break
4682 
      if fid == 0:
4683 
        if ftype == TType.LIST:
4684 
          self.success = []
7216 amar.kumar 4685 
          (_etype87, _size84) = iprot.readListBegin()
4686 
          for _i88 in xrange(_size84):
4687 
            _elem89 = InventoryAvailability()
4688 
            _elem89.read(iprot)
4689 
            self.success.append(_elem89)
6630 amar.kumar 4690 
          iprot.readListEnd()
4691 
        else:
4692 
          iprot.skip(ftype)
4693 
      else:
4694 
        iprot.skip(ftype)
4695 
      iprot.readFieldEnd()
4696 
    iprot.readStructEnd()
4697 
 
4698 
  def write(self, oprot):
4699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4701 
      return
4702 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_result')
4703 
    if self.success is not None:
4704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4706 
      for iter90 in self.success:
4707 
        iter90.write(oprot)
6630 amar.kumar 4708 
      oprot.writeListEnd()
4709 
      oprot.writeFieldEnd()
4710 
    oprot.writeFieldStop()
4711 
    oprot.writeStructEnd()
4712 
 
4713 
  def validate(self):
4714 
    return
4715 
 
4716 
 
4717 
  def __repr__(self):
4718 
    L = ['%s=%r' % (key, value)
4719 
      for key, value in self.__dict__.iteritems()]
4720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4721 
 
4722 
  def __eq__(self, other):
4723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4724 
 
4725 
  def __ne__(self, other):
4726 
    return not (self == other)
6762 amar.kumar 4727 
 
4728 
class getHistoricSerializedInventoryByScans_args:
4729 
  """
4730 
  Attributes:
4731 
   - date
4732 
  """
4733 
 
4734 
  thrift_spec = (
4735 
    None, # 0
4736 
    (1, TType.I64, 'date', None, None, ), # 1
4737 
  )
4738 
 
4739 
  def __init__(self, date=None,):
4740 
    self.date = date
4741 
 
4742 
  def read(self, iprot):
4743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4745 
      return
4746 
    iprot.readStructBegin()
4747 
    while True:
4748 
      (fname, ftype, fid) = iprot.readFieldBegin()
4749 
      if ftype == TType.STOP:
4750 
        break
4751 
      if fid == 1:
4752 
        if ftype == TType.I64:
4753 
          self.date = iprot.readI64();
4754 
        else:
4755 
          iprot.skip(ftype)
4756 
      else:
4757 
        iprot.skip(ftype)
4758 
      iprot.readFieldEnd()
4759 
    iprot.readStructEnd()
4760 
 
4761 
  def write(self, oprot):
4762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4764 
      return
4765 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_args')
4766 
    if self.date is not None:
4767 
      oprot.writeFieldBegin('date', TType.I64, 1)
4768 
      oprot.writeI64(self.date)
4769 
      oprot.writeFieldEnd()
4770 
    oprot.writeFieldStop()
4771 
    oprot.writeStructEnd()
4772 
 
4773 
  def validate(self):
4774 
    return
4775 
 
4776 
 
4777 
  def __repr__(self):
4778 
    L = ['%s=%r' % (key, value)
4779 
      for key, value in self.__dict__.iteritems()]
4780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4781 
 
4782 
  def __eq__(self, other):
4783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4784 
 
4785 
  def __ne__(self, other):
4786 
    return not (self == other)
4787 
 
4788 
class getHistoricSerializedInventoryByScans_result:
4789 
  """
4790 
  Attributes:
4791 
   - success
4792 
  """
4793 
 
4794 
  thrift_spec = (
4795 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4796 
  )
4797 
 
4798 
  def __init__(self, success=None,):
4799 
    self.success = success
4800 
 
4801 
  def read(self, iprot):
4802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4804 
      return
4805 
    iprot.readStructBegin()
4806 
    while True:
4807 
      (fname, ftype, fid) = iprot.readFieldBegin()
4808 
      if ftype == TType.STOP:
4809 
        break
4810 
      if fid == 0:
4811 
        if ftype == TType.LIST:
4812 
          self.success = []
7216 amar.kumar 4813 
          (_etype94, _size91) = iprot.readListBegin()
4814 
          for _i95 in xrange(_size91):
4815 
            _elem96 = InventoryAvailability()
4816 
            _elem96.read(iprot)
4817 
            self.success.append(_elem96)
6762 amar.kumar 4818 
          iprot.readListEnd()
4819 
        else:
4820 
          iprot.skip(ftype)
4821 
      else:
4822 
        iprot.skip(ftype)
4823 
      iprot.readFieldEnd()
4824 
    iprot.readStructEnd()
4825 
 
4826 
  def write(self, oprot):
4827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4829 
      return
4830 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_result')
4831 
    if self.success is not None:
4832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4834 
      for iter97 in self.success:
4835 
        iter97.write(oprot)
6762 amar.kumar 4836 
      oprot.writeListEnd()
4837 
      oprot.writeFieldEnd()
4838 
    oprot.writeFieldStop()
4839 
    oprot.writeStructEnd()
4840 
 
4841 
  def validate(self):
4842 
    return
4843 
 
4844 
 
4845 
  def __repr__(self):
4846 
    L = ['%s=%r' % (key, value)
4847 
      for key, value in self.__dict__.iteritems()]
4848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4849 
 
4850 
  def __eq__(self, other):
4851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4852 
 
4853 
  def __ne__(self, other):
4854 
    return not (self == other)
4855 
 
4856 
class getHistoricNonSerializedInventoryByScans_args:
4857 
  """
4858 
  Attributes:
4859 
   - date
4860 
  """
4861 
 
4862 
  thrift_spec = (
4863 
    None, # 0
4864 
    (1, TType.I64, 'date', None, None, ), # 1
4865 
  )
4866 
 
4867 
  def __init__(self, date=None,):
4868 
    self.date = date
4869 
 
4870 
  def read(self, iprot):
4871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4873 
      return
4874 
    iprot.readStructBegin()
4875 
    while True:
4876 
      (fname, ftype, fid) = iprot.readFieldBegin()
4877 
      if ftype == TType.STOP:
4878 
        break
4879 
      if fid == 1:
4880 
        if ftype == TType.I64:
4881 
          self.date = iprot.readI64();
4882 
        else:
4883 
          iprot.skip(ftype)
4884 
      else:
4885 
        iprot.skip(ftype)
4886 
      iprot.readFieldEnd()
4887 
    iprot.readStructEnd()
4888 
 
4889 
  def write(self, oprot):
4890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4892 
      return
4893 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_args')
4894 
    if self.date is not None:
4895 
      oprot.writeFieldBegin('date', TType.I64, 1)
4896 
      oprot.writeI64(self.date)
4897 
      oprot.writeFieldEnd()
4898 
    oprot.writeFieldStop()
4899 
    oprot.writeStructEnd()
4900 
 
4901 
  def validate(self):
4902 
    return
4903 
 
4904 
 
4905 
  def __repr__(self):
4906 
    L = ['%s=%r' % (key, value)
4907 
      for key, value in self.__dict__.iteritems()]
4908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4909 
 
4910 
  def __eq__(self, other):
4911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4912 
 
4913 
  def __ne__(self, other):
4914 
    return not (self == other)
4915 
 
4916 
class getHistoricNonSerializedInventoryByScans_result:
4917 
  """
4918 
  Attributes:
4919 
   - success
4920 
  """
4921 
 
4922 
  thrift_spec = (
4923 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4924 
  )
4925 
 
4926 
  def __init__(self, success=None,):
4927 
    self.success = success
4928 
 
4929 
  def read(self, iprot):
4930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4932 
      return
4933 
    iprot.readStructBegin()
4934 
    while True:
4935 
      (fname, ftype, fid) = iprot.readFieldBegin()
4936 
      if ftype == TType.STOP:
4937 
        break
4938 
      if fid == 0:
4939 
        if ftype == TType.LIST:
4940 
          self.success = []
7216 amar.kumar 4941 
          (_etype101, _size98) = iprot.readListBegin()
4942 
          for _i102 in xrange(_size98):
4943 
            _elem103 = InventoryAvailability()
4944 
            _elem103.read(iprot)
4945 
            self.success.append(_elem103)
6762 amar.kumar 4946 
          iprot.readListEnd()
4947 
        else:
4948 
          iprot.skip(ftype)
4949 
      else:
4950 
        iprot.skip(ftype)
4951 
      iprot.readFieldEnd()
4952 
    iprot.readStructEnd()
4953 
 
4954 
  def write(self, oprot):
4955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4957 
      return
4958 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_result')
4959 
    if self.success is not None:
4960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 4962 
      for iter104 in self.success:
4963 
        iter104.write(oprot)
6762 amar.kumar 4964 
      oprot.writeListEnd()
4965 
      oprot.writeFieldEnd()
4966 
    oprot.writeFieldStop()
4967 
    oprot.writeStructEnd()
4968 
 
4969 
  def validate(self):
4970 
    return
4971 
 
4972 
 
4973 
  def __repr__(self):
4974 
    L = ['%s=%r' % (key, value)
4975 
      for key, value in self.__dict__.iteritems()]
4976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4977 
 
4978 
  def __eq__(self, other):
4979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4980 
 
4981 
  def __ne__(self, other):
4982 
    return not (self == other)
4983 
 
4984 
class scanForOursExternalSale_args:
4985 
  """
4986 
  Attributes:
4987 
   - itemId
4988 
   - serialNumber
4989 
   - itemNumber
4990 
   - invoiceNumber
4991 
   - warehouseId
4992 
   - unitPrice
4993 
   - orderId
4994 
  """
4995 
 
4996 
  thrift_spec = (
4997 
    None, # 0
4998 
    (1, TType.I64, 'itemId', None, None, ), # 1
4999 
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
5000 
    (3, TType.STRING, 'itemNumber', None, None, ), # 3
5001 
    (4, TType.STRING, 'invoiceNumber', None, None, ), # 4
5002 
    (5, TType.I64, 'warehouseId', None, None, ), # 5
5003 
    (6, TType.DOUBLE, 'unitPrice', None, None, ), # 6
5004 
    (7, TType.I64, 'orderId', None, None, ), # 7
5005 
  )
5006 
 
5007 
  def __init__(self, itemId=None, serialNumber=None, itemNumber=None, invoiceNumber=None, warehouseId=None, unitPrice=None, orderId=None,):
5008 
    self.itemId = itemId
5009 
    self.serialNumber = serialNumber
5010 
    self.itemNumber = itemNumber
5011 
    self.invoiceNumber = invoiceNumber
5012 
    self.warehouseId = warehouseId
5013 
    self.unitPrice = unitPrice
5014 
    self.orderId = orderId
5015 
 
5016 
  def read(self, iprot):
5017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5019 
      return
5020 
    iprot.readStructBegin()
5021 
    while True:
5022 
      (fname, ftype, fid) = iprot.readFieldBegin()
5023 
      if ftype == TType.STOP:
5024 
        break
5025 
      if fid == 1:
5026 
        if ftype == TType.I64:
5027 
          self.itemId = iprot.readI64();
5028 
        else:
5029 
          iprot.skip(ftype)
5030 
      elif fid == 2:
5031 
        if ftype == TType.STRING:
5032 
          self.serialNumber = iprot.readString();
5033 
        else:
5034 
          iprot.skip(ftype)
5035 
      elif fid == 3:
5036 
        if ftype == TType.STRING:
5037 
          self.itemNumber = iprot.readString();
5038 
        else:
5039 
          iprot.skip(ftype)
5040 
      elif fid == 4:
5041 
        if ftype == TType.STRING:
5042 
          self.invoiceNumber = iprot.readString();
5043 
        else:
5044 
          iprot.skip(ftype)
5045 
      elif fid == 5:
5046 
        if ftype == TType.I64:
5047 
          self.warehouseId = iprot.readI64();
5048 
        else:
5049 
          iprot.skip(ftype)
5050 
      elif fid == 6:
5051 
        if ftype == TType.DOUBLE:
5052 
          self.unitPrice = iprot.readDouble();
5053 
        else:
5054 
          iprot.skip(ftype)
5055 
      elif fid == 7:
5056 
        if ftype == TType.I64:
5057 
          self.orderId = iprot.readI64();
5058 
        else:
5059 
          iprot.skip(ftype)
5060 
      else:
5061 
        iprot.skip(ftype)
5062 
      iprot.readFieldEnd()
5063 
    iprot.readStructEnd()
5064 
 
5065 
  def write(self, oprot):
5066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5068 
      return
5069 
    oprot.writeStructBegin('scanForOursExternalSale_args')
5070 
    if self.itemId is not None:
5071 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
5072 
      oprot.writeI64(self.itemId)
5073 
      oprot.writeFieldEnd()
5074 
    if self.serialNumber is not None:
5075 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
5076 
      oprot.writeString(self.serialNumber)
5077 
      oprot.writeFieldEnd()
5078 
    if self.itemNumber is not None:
5079 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 3)
5080 
      oprot.writeString(self.itemNumber)
5081 
      oprot.writeFieldEnd()
5082 
    if self.invoiceNumber is not None:
5083 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 4)
5084 
      oprot.writeString(self.invoiceNumber)
5085 
      oprot.writeFieldEnd()
5086 
    if self.warehouseId is not None:
5087 
      oprot.writeFieldBegin('warehouseId', TType.I64, 5)
5088 
      oprot.writeI64(self.warehouseId)
5089 
      oprot.writeFieldEnd()
5090 
    if self.unitPrice is not None:
5091 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 6)
5092 
      oprot.writeDouble(self.unitPrice)
5093 
      oprot.writeFieldEnd()
5094 
    if self.orderId is not None:
5095 
      oprot.writeFieldBegin('orderId', TType.I64, 7)
5096 
      oprot.writeI64(self.orderId)
5097 
      oprot.writeFieldEnd()
5098 
    oprot.writeFieldStop()
5099 
    oprot.writeStructEnd()
5100 
 
5101 
  def validate(self):
5102 
    return
5103 
 
5104 
 
5105 
  def __repr__(self):
5106 
    L = ['%s=%r' % (key, value)
5107 
      for key, value in self.__dict__.iteritems()]
5108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5109 
 
5110 
  def __eq__(self, other):
5111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5112 
 
5113 
  def __ne__(self, other):
5114 
    return not (self == other)
5115 
 
5116 
class scanForOursExternalSale_result:
5117 
  """
5118 
  Attributes:
5119 
   - success
5120 
   - ex
5121 
  """
5122 
 
5123 
  thrift_spec = (
5124 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
5125 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5126 
  )
5127 
 
5128 
  def __init__(self, success=None, ex=None,):
5129 
    self.success = success
5130 
    self.ex = ex
5131 
 
5132 
  def read(self, iprot):
5133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5135 
      return
5136 
    iprot.readStructBegin()
5137 
    while True:
5138 
      (fname, ftype, fid) = iprot.readFieldBegin()
5139 
      if ftype == TType.STOP:
5140 
        break
5141 
      if fid == 0:
5142 
        if ftype == TType.STRUCT:
5143 
          self.success = InventoryItem()
5144 
          self.success.read(iprot)
5145 
        else:
5146 
          iprot.skip(ftype)
5147 
      elif fid == 1:
5148 
        if ftype == TType.STRUCT:
5149 
          self.ex = WarehouseServiceException()
5150 
          self.ex.read(iprot)
5151 
        else:
5152 
          iprot.skip(ftype)
5153 
      else:
5154 
        iprot.skip(ftype)
5155 
      iprot.readFieldEnd()
5156 
    iprot.readStructEnd()
5157 
 
5158 
  def write(self, oprot):
5159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5161 
      return
5162 
    oprot.writeStructBegin('scanForOursExternalSale_result')
5163 
    if self.success is not None:
5164 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5165 
      self.success.write(oprot)
5166 
      oprot.writeFieldEnd()
5167 
    if self.ex is not None:
5168 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5169 
      self.ex.write(oprot)
5170 
      oprot.writeFieldEnd()
5171 
    oprot.writeFieldStop()
5172 
    oprot.writeStructEnd()
5173 
 
5174 
  def validate(self):
5175 
    return
5176 
 
5177 
 
5178 
  def __repr__(self):
5179 
    L = ['%s=%r' % (key, value)
5180 
      for key, value in self.__dict__.iteritems()]
5181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5182 
 
5183 
  def __eq__(self, other):
5184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5185 
 
5186 
  def __ne__(self, other):
5187 
    return not (self == other)
5188 
 
5189 
class scanForOursExternalSaleReturn_args:
5190 
  """
5191 
  Attributes:
5192 
   - orderId
5193 
   - unitPrice
5194 
  """
5195 
 
5196 
  thrift_spec = (
5197 
    None, # 0
5198 
    (1, TType.I64, 'orderId', None, None, ), # 1
5199 
    (2, TType.DOUBLE, 'unitPrice', None, None, ), # 2
5200 
  )
5201 
 
5202 
  def __init__(self, orderId=None, unitPrice=None,):
5203 
    self.orderId = orderId
5204 
    self.unitPrice = unitPrice
5205 
 
5206 
  def read(self, iprot):
5207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5209 
      return
5210 
    iprot.readStructBegin()
5211 
    while True:
5212 
      (fname, ftype, fid) = iprot.readFieldBegin()
5213 
      if ftype == TType.STOP:
5214 
        break
5215 
      if fid == 1:
5216 
        if ftype == TType.I64:
5217 
          self.orderId = iprot.readI64();
5218 
        else:
5219 
          iprot.skip(ftype)
5220 
      elif fid == 2:
5221 
        if ftype == TType.DOUBLE:
5222 
          self.unitPrice = iprot.readDouble();
5223 
        else:
5224 
          iprot.skip(ftype)
5225 
      else:
5226 
        iprot.skip(ftype)
5227 
      iprot.readFieldEnd()
5228 
    iprot.readStructEnd()
5229 
 
5230 
  def write(self, oprot):
5231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5233 
      return
5234 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_args')
5235 
    if self.orderId is not None:
5236 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5237 
      oprot.writeI64(self.orderId)
5238 
      oprot.writeFieldEnd()
5239 
    if self.unitPrice is not None:
5240 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 2)
5241 
      oprot.writeDouble(self.unitPrice)
5242 
      oprot.writeFieldEnd()
5243 
    oprot.writeFieldStop()
5244 
    oprot.writeStructEnd()
5245 
 
5246 
  def validate(self):
5247 
    return
5248 
 
5249 
 
5250 
  def __repr__(self):
5251 
    L = ['%s=%r' % (key, value)
5252 
      for key, value in self.__dict__.iteritems()]
5253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5254 
 
5255 
  def __eq__(self, other):
5256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5257 
 
5258 
  def __ne__(self, other):
5259 
    return not (self == other)
5260 
 
5261 
class scanForOursExternalSaleReturn_result:
5262 
 
5263 
  thrift_spec = (
5264 
  )
5265 
 
5266 
  def read(self, iprot):
5267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5269 
      return
5270 
    iprot.readStructBegin()
5271 
    while True:
5272 
      (fname, ftype, fid) = iprot.readFieldBegin()
5273 
      if ftype == TType.STOP:
5274 
        break
5275 
      else:
5276 
        iprot.skip(ftype)
5277 
      iprot.readFieldEnd()
5278 
    iprot.readStructEnd()
5279 
 
5280 
  def write(self, oprot):
5281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5283 
      return
5284 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_result')
5285 
    oprot.writeFieldStop()
5286 
    oprot.writeStructEnd()
5287 
 
5288 
  def validate(self):
5289 
    return
5290 
 
5291 
 
5292 
  def __repr__(self):
5293 
    L = ['%s=%r' % (key, value)
5294 
      for key, value in self.__dict__.iteritems()]
5295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5296 
 
5297 
  def __eq__(self, other):
5298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5299 
 
5300 
  def __ne__(self, other):
5301 
    return not (self == other)
6880 amar.kumar 5302 
 
5303 
class getMovementNonSerializedInventoryByScans_args:
5304 
  """
5305 
  Attributes:
5306 
   - startDate
5307 
   - endDate
5308 
  """
5309 
 
5310 
  thrift_spec = (
5311 
    None, # 0
5312 
    (1, TType.I64, 'startDate', None, None, ), # 1
5313 
    (2, TType.I64, 'endDate', None, None, ), # 2
5314 
  )
5315 
 
5316 
  def __init__(self, startDate=None, endDate=None,):
5317 
    self.startDate = startDate
5318 
    self.endDate = endDate
5319 
 
5320 
  def read(self, iprot):
5321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5323 
      return
5324 
    iprot.readStructBegin()
5325 
    while True:
5326 
      (fname, ftype, fid) = iprot.readFieldBegin()
5327 
      if ftype == TType.STOP:
5328 
        break
5329 
      if fid == 1:
5330 
        if ftype == TType.I64:
5331 
          self.startDate = iprot.readI64();
5332 
        else:
5333 
          iprot.skip(ftype)
5334 
      elif fid == 2:
5335 
        if ftype == TType.I64:
5336 
          self.endDate = iprot.readI64();
5337 
        else:
5338 
          iprot.skip(ftype)
5339 
      else:
5340 
        iprot.skip(ftype)
5341 
      iprot.readFieldEnd()
5342 
    iprot.readStructEnd()
5343 
 
5344 
  def write(self, oprot):
5345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5347 
      return
5348 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_args')
5349 
    if self.startDate is not None:
5350 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5351 
      oprot.writeI64(self.startDate)
5352 
      oprot.writeFieldEnd()
5353 
    if self.endDate is not None:
5354 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5355 
      oprot.writeI64(self.endDate)
5356 
      oprot.writeFieldEnd()
5357 
    oprot.writeFieldStop()
5358 
    oprot.writeStructEnd()
5359 
 
5360 
  def validate(self):
5361 
    return
5362 
 
5363 
 
5364 
  def __repr__(self):
5365 
    L = ['%s=%r' % (key, value)
5366 
      for key, value in self.__dict__.iteritems()]
5367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5368 
 
5369 
  def __eq__(self, other):
5370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5371 
 
5372 
  def __ne__(self, other):
5373 
    return not (self == other)
5374 
 
5375 
class getMovementNonSerializedInventoryByScans_result:
5376 
  """
5377 
  Attributes:
5378 
   - success
5379 
  """
5380 
 
5381 
  thrift_spec = (
5382 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5383 
  )
5384 
 
5385 
  def __init__(self, success=None,):
5386 
    self.success = success
5387 
 
5388 
  def read(self, iprot):
5389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5391 
      return
5392 
    iprot.readStructBegin()
5393 
    while True:
5394 
      (fname, ftype, fid) = iprot.readFieldBegin()
5395 
      if ftype == TType.STOP:
5396 
        break
5397 
      if fid == 0:
5398 
        if ftype == TType.LIST:
5399 
          self.success = []
7216 amar.kumar 5400 
          (_etype108, _size105) = iprot.readListBegin()
5401 
          for _i109 in xrange(_size105):
5402 
            _elem110 = InventoryMovement()
5403 
            _elem110.read(iprot)
5404 
            self.success.append(_elem110)
6880 amar.kumar 5405 
          iprot.readListEnd()
5406 
        else:
5407 
          iprot.skip(ftype)
5408 
      else:
5409 
        iprot.skip(ftype)
5410 
      iprot.readFieldEnd()
5411 
    iprot.readStructEnd()
5412 
 
5413 
  def write(self, oprot):
5414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5416 
      return
5417 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_result')
5418 
    if self.success is not None:
5419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 5421 
      for iter111 in self.success:
5422 
        iter111.write(oprot)
6880 amar.kumar 5423 
      oprot.writeListEnd()
5424 
      oprot.writeFieldEnd()
5425 
    oprot.writeFieldStop()
5426 
    oprot.writeStructEnd()
5427 
 
5428 
  def validate(self):
5429 
    return
5430 
 
5431 
 
5432 
  def __repr__(self):
5433 
    L = ['%s=%r' % (key, value)
5434 
      for key, value in self.__dict__.iteritems()]
5435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5436 
 
5437 
  def __eq__(self, other):
5438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5439 
 
5440 
  def __ne__(self, other):
5441 
    return not (self == other)
5442 
 
5443 
class getMovementSerializedInventoryByScans_args:
5444 
  """
5445 
  Attributes:
5446 
   - startDate
5447 
   - endDate
5448 
  """
5449 
 
5450 
  thrift_spec = (
5451 
    None, # 0
5452 
    (1, TType.I64, 'startDate', None, None, ), # 1
5453 
    (2, TType.I64, 'endDate', None, None, ), # 2
5454 
  )
5455 
 
5456 
  def __init__(self, startDate=None, endDate=None,):
5457 
    self.startDate = startDate
5458 
    self.endDate = endDate
5459 
 
5460 
  def read(self, iprot):
5461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5463 
      return
5464 
    iprot.readStructBegin()
5465 
    while True:
5466 
      (fname, ftype, fid) = iprot.readFieldBegin()
5467 
      if ftype == TType.STOP:
5468 
        break
5469 
      if fid == 1:
5470 
        if ftype == TType.I64:
5471 
          self.startDate = iprot.readI64();
5472 
        else:
5473 
          iprot.skip(ftype)
5474 
      elif fid == 2:
5475 
        if ftype == TType.I64:
5476 
          self.endDate = iprot.readI64();
5477 
        else:
5478 
          iprot.skip(ftype)
5479 
      else:
5480 
        iprot.skip(ftype)
5481 
      iprot.readFieldEnd()
5482 
    iprot.readStructEnd()
5483 
 
5484 
  def write(self, oprot):
5485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5487 
      return
5488 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_args')
5489 
    if self.startDate is not None:
5490 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5491 
      oprot.writeI64(self.startDate)
5492 
      oprot.writeFieldEnd()
5493 
    if self.endDate is not None:
5494 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5495 
      oprot.writeI64(self.endDate)
5496 
      oprot.writeFieldEnd()
5497 
    oprot.writeFieldStop()
5498 
    oprot.writeStructEnd()
5499 
 
5500 
  def validate(self):
5501 
    return
5502 
 
5503 
 
5504 
  def __repr__(self):
5505 
    L = ['%s=%r' % (key, value)
5506 
      for key, value in self.__dict__.iteritems()]
5507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5508 
 
5509 
  def __eq__(self, other):
5510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5511 
 
5512 
  def __ne__(self, other):
5513 
    return not (self == other)
5514 
 
5515 
class getMovementSerializedInventoryByScans_result:
5516 
  """
5517 
  Attributes:
5518 
   - success
5519 
  """
5520 
 
5521 
  thrift_spec = (
5522 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5523 
  )
5524 
 
5525 
  def __init__(self, success=None,):
5526 
    self.success = success
5527 
 
5528 
  def read(self, iprot):
5529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5531 
      return
5532 
    iprot.readStructBegin()
5533 
    while True:
5534 
      (fname, ftype, fid) = iprot.readFieldBegin()
5535 
      if ftype == TType.STOP:
5536 
        break
5537 
      if fid == 0:
5538 
        if ftype == TType.LIST:
5539 
          self.success = []
7216 amar.kumar 5540 
          (_etype115, _size112) = iprot.readListBegin()
5541 
          for _i116 in xrange(_size112):
5542 
            _elem117 = InventoryMovement()
5543 
            _elem117.read(iprot)
5544 
            self.success.append(_elem117)
6880 amar.kumar 5545 
          iprot.readListEnd()
5546 
        else:
5547 
          iprot.skip(ftype)
5548 
      else:
5549 
        iprot.skip(ftype)
5550 
      iprot.readFieldEnd()
5551 
    iprot.readStructEnd()
5552 
 
5553 
  def write(self, oprot):
5554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5556 
      return
5557 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_result')
5558 
    if self.success is not None:
5559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7216 amar.kumar 5561 
      for iter118 in self.success:
5562 
        iter118.write(oprot)
6880 amar.kumar 5563 
      oprot.writeListEnd()
5564 
      oprot.writeFieldEnd()
5565 
    oprot.writeFieldStop()
5566 
    oprot.writeStructEnd()
5567 
 
5568 
  def validate(self):
5569 
    return
5570 
 
5571 
 
5572 
  def __repr__(self):
5573 
    L = ['%s=%r' % (key, value)
5574 
      for key, value in self.__dict__.iteritems()]
5575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5576 
 
5577 
  def __eq__(self, other):
5578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5579 
 
5580 
  def __ne__(self, other):
5581 
    return not (self == other)
7190 amar.kumar 5582 
 
7216 amar.kumar 5583 
class getCompleteMovementSerializedInventoryByScans_args:
5584 
  """
5585 
  Attributes:
5586 
   - startDate
5587 
   - endDate
5588 
  """
5589 
 
5590 
  thrift_spec = (
5591 
    None, # 0
5592 
    (1, TType.I64, 'startDate', None, None, ), # 1
5593 
    (2, TType.I64, 'endDate', None, None, ), # 2
5594 
  )
5595 
 
5596 
  def __init__(self, startDate=None, endDate=None,):
5597 
    self.startDate = startDate
5598 
    self.endDate = endDate
5599 
 
5600 
  def read(self, iprot):
5601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5603 
      return
5604 
    iprot.readStructBegin()
5605 
    while True:
5606 
      (fname, ftype, fid) = iprot.readFieldBegin()
5607 
      if ftype == TType.STOP:
5608 
        break
5609 
      if fid == 1:
5610 
        if ftype == TType.I64:
5611 
          self.startDate = iprot.readI64();
5612 
        else:
5613 
          iprot.skip(ftype)
5614 
      elif fid == 2:
5615 
        if ftype == TType.I64:
5616 
          self.endDate = iprot.readI64();
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('getCompleteMovementSerializedInventoryByScans_args')
5629 
    if self.startDate is not None:
5630 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5631 
      oprot.writeI64(self.startDate)
5632 
      oprot.writeFieldEnd()
5633 
    if self.endDate is not None:
5634 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5635 
      oprot.writeI64(self.endDate)
5636 
      oprot.writeFieldEnd()
5637 
    oprot.writeFieldStop()
5638 
    oprot.writeStructEnd()
5639 
 
5640 
  def validate(self):
5641 
    return
5642 
 
5643 
 
5644 
  def __repr__(self):
5645 
    L = ['%s=%r' % (key, value)
5646 
      for key, value in self.__dict__.iteritems()]
5647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5648 
 
5649 
  def __eq__(self, other):
5650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5651 
 
5652 
  def __ne__(self, other):
5653 
    return not (self == other)
5654 
 
5655 
class getCompleteMovementSerializedInventoryByScans_result:
5656 
  """
5657 
  Attributes:
5658 
   - success
5659 
  """
5660 
 
5661 
  thrift_spec = (
5662 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5663 
  )
5664 
 
5665 
  def __init__(self, success=None,):
5666 
    self.success = success
5667 
 
5668 
  def read(self, iprot):
5669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5671 
      return
5672 
    iprot.readStructBegin()
5673 
    while True:
5674 
      (fname, ftype, fid) = iprot.readFieldBegin()
5675 
      if ftype == TType.STOP:
5676 
        break
5677 
      if fid == 0:
5678 
        if ftype == TType.LIST:
5679 
          self.success = []
5680 
          (_etype122, _size119) = iprot.readListBegin()
5681 
          for _i123 in xrange(_size119):
5682 
            _elem124 = InventoryMovement()
5683 
            _elem124.read(iprot)
5684 
            self.success.append(_elem124)
5685 
          iprot.readListEnd()
5686 
        else:
5687 
          iprot.skip(ftype)
5688 
      else:
5689 
        iprot.skip(ftype)
5690 
      iprot.readFieldEnd()
5691 
    iprot.readStructEnd()
5692 
 
5693 
  def write(self, oprot):
5694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5696 
      return
5697 
    oprot.writeStructBegin('getCompleteMovementSerializedInventoryByScans_result')
5698 
    if self.success is not None:
5699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5701 
      for iter125 in self.success:
5702 
        iter125.write(oprot)
5703 
      oprot.writeListEnd()
5704 
      oprot.writeFieldEnd()
5705 
    oprot.writeFieldStop()
5706 
    oprot.writeStructEnd()
5707 
 
5708 
  def validate(self):
5709 
    return
5710 
 
5711 
 
5712 
  def __repr__(self):
5713 
    L = ['%s=%r' % (key, value)
5714 
      for key, value in self.__dict__.iteritems()]
5715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5716 
 
5717 
  def __eq__(self, other):
5718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5719 
 
5720 
  def __ne__(self, other):
5721 
    return not (self == other)
5722 
 
5723 
class getCompleteMovementNonSerializedInventoryByScans_args:
5724 
  """
5725 
  Attributes:
5726 
   - startDate
5727 
   - endDate
5728 
  """
5729 
 
5730 
  thrift_spec = (
5731 
    None, # 0
5732 
    (1, TType.I64, 'startDate', None, None, ), # 1
5733 
    (2, TType.I64, 'endDate', None, None, ), # 2
5734 
  )
5735 
 
5736 
  def __init__(self, startDate=None, endDate=None,):
5737 
    self.startDate = startDate
5738 
    self.endDate = endDate
5739 
 
5740 
  def read(self, iprot):
5741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5743 
      return
5744 
    iprot.readStructBegin()
5745 
    while True:
5746 
      (fname, ftype, fid) = iprot.readFieldBegin()
5747 
      if ftype == TType.STOP:
5748 
        break
5749 
      if fid == 1:
5750 
        if ftype == TType.I64:
5751 
          self.startDate = iprot.readI64();
5752 
        else:
5753 
          iprot.skip(ftype)
5754 
      elif fid == 2:
5755 
        if ftype == TType.I64:
5756 
          self.endDate = iprot.readI64();
5757 
        else:
5758 
          iprot.skip(ftype)
5759 
      else:
5760 
        iprot.skip(ftype)
5761 
      iprot.readFieldEnd()
5762 
    iprot.readStructEnd()
5763 
 
5764 
  def write(self, oprot):
5765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5767 
      return
5768 
    oprot.writeStructBegin('getCompleteMovementNonSerializedInventoryByScans_args')
5769 
    if self.startDate is not None:
5770 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5771 
      oprot.writeI64(self.startDate)
5772 
      oprot.writeFieldEnd()
5773 
    if self.endDate is not None:
5774 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5775 
      oprot.writeI64(self.endDate)
5776 
      oprot.writeFieldEnd()
5777 
    oprot.writeFieldStop()
5778 
    oprot.writeStructEnd()
5779 
 
5780 
  def validate(self):
5781 
    return
5782 
 
5783 
 
5784 
  def __repr__(self):
5785 
    L = ['%s=%r' % (key, value)
5786 
      for key, value in self.__dict__.iteritems()]
5787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5788 
 
5789 
  def __eq__(self, other):
5790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5791 
 
5792 
  def __ne__(self, other):
5793 
    return not (self == other)
5794 
 
5795 
class getCompleteMovementNonSerializedInventoryByScans_result:
5796 
  """
5797 
  Attributes:
5798 
   - success
5799 
  """
5800 
 
5801 
  thrift_spec = (
5802 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5803 
  )
5804 
 
5805 
  def __init__(self, success=None,):
5806 
    self.success = success
5807 
 
5808 
  def read(self, iprot):
5809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5811 
      return
5812 
    iprot.readStructBegin()
5813 
    while True:
5814 
      (fname, ftype, fid) = iprot.readFieldBegin()
5815 
      if ftype == TType.STOP:
5816 
        break
5817 
      if fid == 0:
5818 
        if ftype == TType.LIST:
5819 
          self.success = []
5820 
          (_etype129, _size126) = iprot.readListBegin()
5821 
          for _i130 in xrange(_size126):
5822 
            _elem131 = InventoryMovement()
5823 
            _elem131.read(iprot)
5824 
            self.success.append(_elem131)
5825 
          iprot.readListEnd()
5826 
        else:
5827 
          iprot.skip(ftype)
5828 
      else:
5829 
        iprot.skip(ftype)
5830 
      iprot.readFieldEnd()
5831 
    iprot.readStructEnd()
5832 
 
5833 
  def write(self, oprot):
5834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5836 
      return
5837 
    oprot.writeStructBegin('getCompleteMovementNonSerializedInventoryByScans_result')
5838 
    if self.success is not None:
5839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5841 
      for iter132 in self.success:
5842 
        iter132.write(oprot)
5843 
      oprot.writeListEnd()
5844 
      oprot.writeFieldEnd()
5845 
    oprot.writeFieldStop()
5846 
    oprot.writeStructEnd()
5847 
 
5848 
  def validate(self):
5849 
    return
5850 
 
5851 
 
5852 
  def __repr__(self):
5853 
    L = ['%s=%r' % (key, value)
5854 
      for key, value in self.__dict__.iteritems()]
5855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5856 
 
5857 
  def __eq__(self, other):
5858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5859 
 
5860 
  def __ne__(self, other):
5861 
    return not (self == other)
5862 
 
7190 amar.kumar 5863 
class scanfreebie_args:
5864 
  """
5865 
  Attributes:
5866 
   - orderId
5867 
   - freebieItemId
5868 
   - freebieWarehouseId
5869 
   - scanType
5870 
  """
5871 
 
5872 
  thrift_spec = (
5873 
    None, # 0
5874 
    (1, TType.I64, 'orderId', None, None, ), # 1
5875 
    (2, TType.I64, 'freebieItemId', None, None, ), # 2
5876 
    (3, TType.I64, 'freebieWarehouseId', None, None, ), # 3
5877 
    (4, TType.I32, 'scanType', None, None, ), # 4
5878 
  )
5879 
 
5880 
  def __init__(self, orderId=None, freebieItemId=None, freebieWarehouseId=None, scanType=None,):
5881 
    self.orderId = orderId
5882 
    self.freebieItemId = freebieItemId
5883 
    self.freebieWarehouseId = freebieWarehouseId
5884 
    self.scanType = scanType
5885 
 
5886 
  def read(self, iprot):
5887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5889 
      return
5890 
    iprot.readStructBegin()
5891 
    while True:
5892 
      (fname, ftype, fid) = iprot.readFieldBegin()
5893 
      if ftype == TType.STOP:
5894 
        break
5895 
      if fid == 1:
5896 
        if ftype == TType.I64:
5897 
          self.orderId = iprot.readI64();
5898 
        else:
5899 
          iprot.skip(ftype)
5900 
      elif fid == 2:
5901 
        if ftype == TType.I64:
5902 
          self.freebieItemId = iprot.readI64();
5903 
        else:
5904 
          iprot.skip(ftype)
5905 
      elif fid == 3:
5906 
        if ftype == TType.I64:
5907 
          self.freebieWarehouseId = iprot.readI64();
5908 
        else:
5909 
          iprot.skip(ftype)
5910 
      elif fid == 4:
5911 
        if ftype == TType.I32:
5912 
          self.scanType = iprot.readI32();
5913 
        else:
5914 
          iprot.skip(ftype)
5915 
      else:
5916 
        iprot.skip(ftype)
5917 
      iprot.readFieldEnd()
5918 
    iprot.readStructEnd()
5919 
 
5920 
  def write(self, oprot):
5921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5923 
      return
5924 
    oprot.writeStructBegin('scanfreebie_args')
5925 
    if self.orderId is not None:
5926 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5927 
      oprot.writeI64(self.orderId)
5928 
      oprot.writeFieldEnd()
5929 
    if self.freebieItemId is not None:
5930 
      oprot.writeFieldBegin('freebieItemId', TType.I64, 2)
5931 
      oprot.writeI64(self.freebieItemId)
5932 
      oprot.writeFieldEnd()
5933 
    if self.freebieWarehouseId is not None:
5934 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 3)
5935 
      oprot.writeI64(self.freebieWarehouseId)
5936 
      oprot.writeFieldEnd()
5937 
    if self.scanType is not None:
5938 
      oprot.writeFieldBegin('scanType', TType.I32, 4)
5939 
      oprot.writeI32(self.scanType)
5940 
      oprot.writeFieldEnd()
5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
5944 
  def validate(self):
5945 
    return
5946 
 
5947 
 
5948 
  def __repr__(self):
5949 
    L = ['%s=%r' % (key, value)
5950 
      for key, value in self.__dict__.iteritems()]
5951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5952 
 
5953 
  def __eq__(self, other):
5954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5955 
 
5956 
  def __ne__(self, other):
5957 
    return not (self == other)
5958 
 
5959 
class scanfreebie_result:
5960 
  """
5961 
  Attributes:
5962 
   - success
5963 
   - wex
5964 
  """
5965 
 
5966 
  thrift_spec = (
5967 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
5968 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5969 
  )
5970 
 
5971 
  def __init__(self, success=None, wex=None,):
5972 
    self.success = success
5973 
    self.wex = wex
5974 
 
5975 
  def read(self, iprot):
5976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5978 
      return
5979 
    iprot.readStructBegin()
5980 
    while True:
5981 
      (fname, ftype, fid) = iprot.readFieldBegin()
5982 
      if ftype == TType.STOP:
5983 
        break
5984 
      if fid == 0:
5985 
        if ftype == TType.STRUCT:
5986 
          self.success = InventoryItem()
5987 
          self.success.read(iprot)
5988 
        else:
5989 
          iprot.skip(ftype)
5990 
      elif fid == 1:
5991 
        if ftype == TType.STRUCT:
5992 
          self.wex = WarehouseServiceException()
5993 
          self.wex.read(iprot)
5994 
        else:
5995 
          iprot.skip(ftype)
5996 
      else:
5997 
        iprot.skip(ftype)
5998 
      iprot.readFieldEnd()
5999 
    iprot.readStructEnd()
6000 
 
6001 
  def write(self, oprot):
6002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6004 
      return
6005 
    oprot.writeStructBegin('scanfreebie_result')
6006 
    if self.success is not None:
6007 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6008 
      self.success.write(oprot)
6009 
      oprot.writeFieldEnd()
6010 
    if self.wex is not None:
6011 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
6012 
      self.wex.write(oprot)
6013 
      oprot.writeFieldEnd()
6014 
    oprot.writeFieldStop()
6015 
    oprot.writeStructEnd()
6016 
 
6017 
  def validate(self):
6018 
    return
6019 
 
6020 
 
6021 
  def __repr__(self):
6022 
    L = ['%s=%r' % (key, value)
6023 
      for key, value in self.__dict__.iteritems()]
6024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6025 
 
6026 
  def __eq__(self, other):
6027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6028 
 
6029 
  def __ne__(self, other):
6030 
    return not (self == other)
7199 amar.kumar 6031 
 
6032 
class reshipfreebie_args:
6033 
  """
6034 
  Attributes:
6035 
   - oldOrderId
6036 
   - newOrderId
6037 
   - freebieItemId
6038 
   - scanType
6039 
  """
6040 
 
6041 
  thrift_spec = (
6042 
    None, # 0
6043 
    (1, TType.I64, 'oldOrderId', None, None, ), # 1
6044 
    (2, TType.I64, 'newOrderId', None, None, ), # 2
6045 
    (3, TType.I64, 'freebieItemId', None, None, ), # 3
6046 
    (4, TType.I32, 'scanType', None, None, ), # 4
6047 
  )
6048 
 
6049 
  def __init__(self, oldOrderId=None, newOrderId=None, freebieItemId=None, scanType=None,):
6050 
    self.oldOrderId = oldOrderId
6051 
    self.newOrderId = newOrderId
6052 
    self.freebieItemId = freebieItemId
6053 
    self.scanType = scanType
6054 
 
6055 
  def read(self, iprot):
6056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6058 
      return
6059 
    iprot.readStructBegin()
6060 
    while True:
6061 
      (fname, ftype, fid) = iprot.readFieldBegin()
6062 
      if ftype == TType.STOP:
6063 
        break
6064 
      if fid == 1:
6065 
        if ftype == TType.I64:
6066 
          self.oldOrderId = iprot.readI64();
6067 
        else:
6068 
          iprot.skip(ftype)
6069 
      elif fid == 2:
6070 
        if ftype == TType.I64:
6071 
          self.newOrderId = iprot.readI64();
6072 
        else:
6073 
          iprot.skip(ftype)
6074 
      elif fid == 3:
6075 
        if ftype == TType.I64:
6076 
          self.freebieItemId = iprot.readI64();
6077 
        else:
6078 
          iprot.skip(ftype)
6079 
      elif fid == 4:
6080 
        if ftype == TType.I32:
6081 
          self.scanType = iprot.readI32();
6082 
        else:
6083 
          iprot.skip(ftype)
6084 
      else:
6085 
        iprot.skip(ftype)
6086 
      iprot.readFieldEnd()
6087 
    iprot.readStructEnd()
6088 
 
6089 
  def write(self, oprot):
6090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6092 
      return
6093 
    oprot.writeStructBegin('reshipfreebie_args')
6094 
    if self.oldOrderId is not None:
6095 
      oprot.writeFieldBegin('oldOrderId', TType.I64, 1)
6096 
      oprot.writeI64(self.oldOrderId)
6097 
      oprot.writeFieldEnd()
6098 
    if self.newOrderId is not None:
6099 
      oprot.writeFieldBegin('newOrderId', TType.I64, 2)
6100 
      oprot.writeI64(self.newOrderId)
6101 
      oprot.writeFieldEnd()
6102 
    if self.freebieItemId is not None:
6103 
      oprot.writeFieldBegin('freebieItemId', TType.I64, 3)
6104 
      oprot.writeI64(self.freebieItemId)
6105 
      oprot.writeFieldEnd()
6106 
    if self.scanType is not None:
6107 
      oprot.writeFieldBegin('scanType', TType.I32, 4)
6108 
      oprot.writeI32(self.scanType)
6109 
      oprot.writeFieldEnd()
6110 
    oprot.writeFieldStop()
6111 
    oprot.writeStructEnd()
6112 
 
6113 
  def validate(self):
6114 
    return
6115 
 
6116 
 
6117 
  def __repr__(self):
6118 
    L = ['%s=%r' % (key, value)
6119 
      for key, value in self.__dict__.iteritems()]
6120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6121 
 
6122 
  def __eq__(self, other):
6123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6124 
 
6125 
  def __ne__(self, other):
6126 
    return not (self == other)
6127 
 
6128 
class reshipfreebie_result:
6129 
  """
6130 
  Attributes:
6131 
   - wex
6132 
  """
6133 
 
6134 
  thrift_spec = (
6135 
    None, # 0
6136 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
6137 
  )
6138 
 
6139 
  def __init__(self, wex=None,):
6140 
    self.wex = wex
6141 
 
6142 
  def read(self, iprot):
6143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6145 
      return
6146 
    iprot.readStructBegin()
6147 
    while True:
6148 
      (fname, ftype, fid) = iprot.readFieldBegin()
6149 
      if ftype == TType.STOP:
6150 
        break
6151 
      if fid == 1:
6152 
        if ftype == TType.STRUCT:
6153 
          self.wex = WarehouseServiceException()
6154 
          self.wex.read(iprot)
6155 
        else:
6156 
          iprot.skip(ftype)
6157 
      else:
6158 
        iprot.skip(ftype)
6159 
      iprot.readFieldEnd()
6160 
    iprot.readStructEnd()
6161 
 
6162 
  def write(self, oprot):
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6165 
      return
6166 
    oprot.writeStructBegin('reshipfreebie_result')
6167 
    if self.wex is not None:
6168 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
6169 
      self.wex.write(oprot)
6170 
      oprot.writeFieldEnd()
6171 
    oprot.writeFieldStop()
6172 
    oprot.writeStructEnd()
6173 
 
6174 
  def validate(self):
6175 
    return
6176 
 
6177 
 
6178 
  def __repr__(self):
6179 
    L = ['%s=%r' % (key, value)
6180 
      for key, value in self.__dict__.iteritems()]
6181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6182 
 
6183 
  def __eq__(self, other):
6184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6185 
 
6186 
  def __ne__(self, other):
6187 
    return not (self == other)