Subversion Repositories SmartDukaan

Rev

Rev 6467 | Rev 6762 | 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 
 
5496 mandeep.dh 136 
  def fetchScansPerInvoiceNumber(self, date):
137 
    """
138 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 139 
 
5496 mandeep.dh 140 
    Parameters:
141 
     - date
142 
    """
143 
    pass
144 
 
5620 mandeep.dh 145 
  def getInventoryItemFromOrder(self, orderId):
146 
    """
147 
    Returns inventory item for a given order
5496 mandeep.dh 148 
 
5620 mandeep.dh 149 
    Parameters:
150 
     - orderId
151 
    """
152 
    pass
153 
 
5711 mandeep.dh 154 
  def getInventoryAge(self, ):
155 
    """
156 
    Fetches the stock inventory age week-wise
157 
    """
158 
    pass
5620 mandeep.dh 159 
 
6361 rajveer 160 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
161 
    """
162 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 163 
 
6361 rajveer 164 
    Parameters:
165 
     - itemId
166 
     - fromDate
167 
     - toDate
168 
    """
169 
    pass
170 
 
171 
  def getScanRecordsForSerialNumber(self, serialNumber):
172 
    """
173 
    Fetches the scanRecords for a given serialNumber for a given time interval
174 
 
175 
    Parameters:
176 
     - serialNumber
177 
    """
178 
    pass
179 
 
6467 amar.kumar 180 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
181 
    """
6630 amar.kumar 182 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 183 
 
6467 amar.kumar 184 
    Parameters:
185 
     - saleReturnItems
186 
     - vendorId
187 
    """
188 
    pass
189 
 
6630 amar.kumar 190 
  def scanForLostItem(self, lostItems, vendorId):
191 
    """
192 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 193 
 
6630 amar.kumar 194 
    Parameters:
195 
     - lostItems
196 
     - vendorId
197 
    """
198 
    pass
199 
 
200 
  def getCurrentSerializedInventoryByScans(self, ):
201 
    """
202 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
203 
    """
204 
    pass
205 
 
206 
  def getCurrentNonSerializedInventoryByScans(self, ):
207 
    """
208 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
209 
    """
210 
    pass
211 
 
212 
 
3376 rajveer 213 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
2821 chandransh 214 
  def __init__(self, iprot, oprot=None):
3376 rajveer 215 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
2821 chandransh 216 
 
4501 mandeep.dh 217 
  def getInventoryItem(self, serialNumber):
2832 chandransh 218 
    """
4501 mandeep.dh 219 
    Retrieves serialized inventory item given a serial number
3431 rajveer 220 
 
2832 chandransh 221 
    Parameters:
4501 mandeep.dh 222 
     - serialNumber
2832 chandransh 223 
    """
4501 mandeep.dh 224 
    self.send_getInventoryItem(serialNumber)
225 
    return self.recv_getInventoryItem()
2832 chandransh 226 
 
4501 mandeep.dh 227 
  def send_getInventoryItem(self, serialNumber):
228 
    self._oprot.writeMessageBegin('getInventoryItem', TMessageType.CALL, self._seqid)
229 
    args = getInventoryItem_args()
230 
    args.serialNumber = serialNumber
2832 chandransh 231 
    args.write(self._oprot)
232 
    self._oprot.writeMessageEnd()
233 
    self._oprot.trans.flush()
234 
 
4501 mandeep.dh 235 
  def recv_getInventoryItem(self, ):
2832 chandransh 236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
237 
    if mtype == TMessageType.EXCEPTION:
238 
      x = TApplicationException()
239 
      x.read(self._iprot)
240 
      self._iprot.readMessageEnd()
241 
      raise x
4501 mandeep.dh 242 
    result = getInventoryItem_result()
2832 chandransh 243 
    result.read(self._iprot)
244 
    self._iprot.readMessageEnd()
3431 rajveer 245 
    if result.success is not None:
2832 chandransh 246 
      return result.success
4541 mandeep.dh 247 
    if result.wex is not None:
248 
      raise result.wex
4501 mandeep.dh 249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItem failed: unknown result");
2832 chandransh 250 
 
5530 mandeep.dh 251 
  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
2821 chandransh 252 
    """
5361 mandeep.dh 253 
    Retrieves non-serialized inventory item from a given supplier
3431 rajveer 254 
 
2821 chandransh 255 
    Parameters:
5530 mandeep.dh 256 
     - itemNumber
4501 mandeep.dh 257 
     - itemId
5530 mandeep.dh 258 
     - fulfilmentWarehouseId
2821 chandransh 259 
    """
5530 mandeep.dh 260 
    self.send_getNonSeralizedInventoryItem(itemNumber, itemId, fulfilmentWarehouseId)
5361 mandeep.dh 261 
    return self.recv_getNonSeralizedInventoryItem()
2821 chandransh 262 
 
5530 mandeep.dh 263 
  def send_getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
5361 mandeep.dh 264 
    self._oprot.writeMessageBegin('getNonSeralizedInventoryItem', TMessageType.CALL, self._seqid)
265 
    args = getNonSeralizedInventoryItem_args()
5530 mandeep.dh 266 
    args.itemNumber = itemNumber
4501 mandeep.dh 267 
    args.itemId = itemId
5530 mandeep.dh 268 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 269 
    args.write(self._oprot)
270 
    self._oprot.writeMessageEnd()
271 
    self._oprot.trans.flush()
272 
 
5361 mandeep.dh 273 
  def recv_getNonSeralizedInventoryItem(self, ):
2821 chandransh 274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
275 
    if mtype == TMessageType.EXCEPTION:
276 
      x = TApplicationException()
277 
      x.read(self._iprot)
278 
      self._iprot.readMessageEnd()
279 
      raise x
5361 mandeep.dh 280 
    result = getNonSeralizedInventoryItem_result()
2821 chandransh 281 
    result.read(self._iprot)
282 
    self._iprot.readMessageEnd()
3431 rajveer 283 
    if result.success is not None:
2821 chandransh 284 
      return result.success
5361 mandeep.dh 285 
    if result.wex is not None:
286 
      raise result.wex
287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");
2821 chandransh 288 
 
5361 mandeep.dh 289 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
3383 chandransh 290 
    """
4501 mandeep.dh 291 
    Scan non-serialized items.
3431 rajveer 292 
 
2821 chandransh 293 
    Parameters:
5361 mandeep.dh 294 
     - inventoryItem
2821 chandransh 295 
     - type
4501 mandeep.dh 296 
     - quantity
5361 mandeep.dh 297 
     - billingWarehouseId
2821 chandransh 298 
    """
5361 mandeep.dh 299 
    self.send_scan(inventoryItem, type, quantity, billingWarehouseId)
4501 mandeep.dh 300 
    self.recv_scan()
2821 chandransh 301 
 
5361 mandeep.dh 302 
  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId):
4501 mandeep.dh 303 
    self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
304 
    args = scan_args()
5361 mandeep.dh 305 
    args.inventoryItem = inventoryItem
2821 chandransh 306 
    args.type = type
4501 mandeep.dh 307 
    args.quantity = quantity
5361 mandeep.dh 308 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 309 
    args.write(self._oprot)
310 
    self._oprot.writeMessageEnd()
311 
    self._oprot.trans.flush()
312 
 
4501 mandeep.dh 313 
  def recv_scan(self, ):
2821 chandransh 314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
315 
    if mtype == TMessageType.EXCEPTION:
316 
      x = TApplicationException()
317 
      x.read(self._iprot)
318 
      self._iprot.readMessageEnd()
319 
      raise x
4501 mandeep.dh 320 
    result = scan_result()
2821 chandransh 321 
    result.read(self._iprot)
322 
    self._iprot.readMessageEnd()
3431 rajveer 323 
    if result.wex is not None:
2821 chandransh 324 
      raise result.wex
325 
    return
326 
 
5110 mandeep.dh 327 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
2821 chandransh 328 
    """
4501 mandeep.dh 329 
    Scan serialized items linked with an order. Returns its price.
3431 rajveer 330 
 
2821 chandransh 331 
    Parameters:
4555 mandeep.dh 332 
     - serialNumber
2821 chandransh 333 
     - type
4501 mandeep.dh 334 
     - orderId
5110 mandeep.dh 335 
     - fulfilmentWarehouseId
336 
     - quantity
337 
     - billingWarehouseId
2821 chandransh 338 
    """
5110 mandeep.dh 339 
    self.send_scanSerializedItemForOrder(serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
4501 mandeep.dh 340 
    return self.recv_scanSerializedItemForOrder()
2821 chandransh 341 
 
5110 mandeep.dh 342 
  def send_scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 343 
    self._oprot.writeMessageBegin('scanSerializedItemForOrder', TMessageType.CALL, self._seqid)
344 
    args = scanSerializedItemForOrder_args()
4555 mandeep.dh 345 
    args.serialNumber = serialNumber
2821 chandransh 346 
    args.type = type
4501 mandeep.dh 347 
    args.orderId = orderId
5110 mandeep.dh 348 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
349 
    args.quantity = quantity
350 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 351 
    args.write(self._oprot)
352 
    self._oprot.writeMessageEnd()
353 
    self._oprot.trans.flush()
354 
 
4501 mandeep.dh 355 
  def recv_scanSerializedItemForOrder(self, ):
2821 chandransh 356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
357 
    if mtype == TMessageType.EXCEPTION:
358 
      x = TApplicationException()
359 
      x.read(self._iprot)
360 
      self._iprot.readMessageEnd()
361 
      raise x
4501 mandeep.dh 362 
    result = scanSerializedItemForOrder_result()
2821 chandransh 363 
    result.read(self._iprot)
364 
    self._iprot.readMessageEnd()
4501 mandeep.dh 365 
    if result.success is not None:
366 
      return result.success
3431 rajveer 367 
    if result.wex is not None:
2821 chandransh 368 
      raise result.wex
4501 mandeep.dh 369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanSerializedItemForOrder failed: unknown result");
370 
 
5361 mandeep.dh 371 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 372 
    """
373 
    Scan non-serialized items linked with an order.
374 
 
375 
    Parameters:
5361 mandeep.dh 376 
     - inventoryItem
4501 mandeep.dh 377 
     - type
378 
     - quantity
379 
     - orderId
5110 mandeep.dh 380 
     - fulfilmentWarehouseId
5361 mandeep.dh 381 
     - billingWarehouseId
4501 mandeep.dh 382 
    """
5361 mandeep.dh 383 
    self.send_scanForOrder(inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId)
384 
    return self.recv_scanForOrder()
4501 mandeep.dh 385 
 
5361 mandeep.dh 386 
  def send_scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 387 
    self._oprot.writeMessageBegin('scanForOrder', TMessageType.CALL, self._seqid)
388 
    args = scanForOrder_args()
5361 mandeep.dh 389 
    args.inventoryItem = inventoryItem
4501 mandeep.dh 390 
    args.type = type
391 
    args.quantity = quantity
392 
    args.orderId = orderId
5110 mandeep.dh 393 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 394 
    args.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 395 
    args.write(self._oprot)
396 
    self._oprot.writeMessageEnd()
397 
    self._oprot.trans.flush()
398 
 
399 
  def recv_scanForOrder(self, ):
400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
401 
    if mtype == TMessageType.EXCEPTION:
402 
      x = TApplicationException()
403 
      x.read(self._iprot)
404 
      self._iprot.readMessageEnd()
405 
      raise x
406 
    result = scanForOrder_result()
407 
    result.read(self._iprot)
408 
    self._iprot.readMessageEnd()
5361 mandeep.dh 409 
    if result.success is not None:
410 
      return result.success
4501 mandeep.dh 411 
    if result.wex is not None:
412 
      raise result.wex
5361 mandeep.dh 413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOrder failed: unknown result");
2821 chandransh 414 
 
4501 mandeep.dh 415 
  def createItemNumberMapping(self, itemNumber, itemId):
416 
    """
417 
    Created item number to item id mapping
2821 chandransh 418 
 
4501 mandeep.dh 419 
    Parameters:
420 
     - itemNumber
421 
     - itemId
422 
    """
423 
    self.send_createItemNumberMapping(itemNumber, itemId)
424 
    self.recv_createItemNumberMapping()
425 
 
426 
  def send_createItemNumberMapping(self, itemNumber, itemId):
427 
    self._oprot.writeMessageBegin('createItemNumberMapping', TMessageType.CALL, self._seqid)
428 
    args = createItemNumberMapping_args()
429 
    args.itemNumber = itemNumber
430 
    args.itemId = itemId
431 
    args.write(self._oprot)
432 
    self._oprot.writeMessageEnd()
433 
    self._oprot.trans.flush()
434 
 
435 
  def recv_createItemNumberMapping(self, ):
436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
437 
    if mtype == TMessageType.EXCEPTION:
438 
      x = TApplicationException()
439 
      x.read(self._iprot)
440 
      self._iprot.readMessageEnd()
441 
      raise x
442 
    result = createItemNumberMapping_result()
443 
    result.read(self._iprot)
444 
    self._iprot.readMessageEnd()
445 
    return
446 
 
4620 amit.gupta 447 
  def getItemNumbers(self, itemId):
448 
    """
449 
    Get itemNumber mappings for itemId
4501 mandeep.dh 450 
 
4620 amit.gupta 451 
    Parameters:
452 
     - itemId
453 
    """
454 
    self.send_getItemNumbers(itemId)
455 
    return self.recv_getItemNumbers()
456 
 
457 
  def send_getItemNumbers(self, itemId):
458 
    self._oprot.writeMessageBegin('getItemNumbers', TMessageType.CALL, self._seqid)
459 
    args = getItemNumbers_args()
460 
    args.itemId = itemId
461 
    args.write(self._oprot)
462 
    self._oprot.writeMessageEnd()
463 
    self._oprot.trans.flush()
464 
 
465 
  def recv_getItemNumbers(self, ):
466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
467 
    if mtype == TMessageType.EXCEPTION:
468 
      x = TApplicationException()
469 
      x.read(self._iprot)
470 
      self._iprot.readMessageEnd()
471 
      raise x
472 
    result = getItemNumbers_result()
473 
    result.read(self._iprot)
474 
    self._iprot.readMessageEnd()
475 
    if result.success is not None:
476 
      return result.success
477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemNumbers failed: unknown result");
478 
 
5110 mandeep.dh 479 
  def getItemIds(self, itemNumber):
480 
    """
481 
    Gets item ids for a given item number
4620 amit.gupta 482 
 
5110 mandeep.dh 483 
    Parameters:
484 
     - itemNumber
485 
    """
486 
    self.send_getItemIds(itemNumber)
487 
    return self.recv_getItemIds()
488 
 
489 
  def send_getItemIds(self, itemNumber):
490 
    self._oprot.writeMessageBegin('getItemIds', TMessageType.CALL, self._seqid)
491 
    args = getItemIds_args()
492 
    args.itemNumber = itemNumber
493 
    args.write(self._oprot)
494 
    self._oprot.writeMessageEnd()
495 
    self._oprot.trans.flush()
496 
 
497 
  def recv_getItemIds(self, ):
498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
499 
    if mtype == TMessageType.EXCEPTION:
500 
      x = TApplicationException()
501 
      x.read(self._iprot)
502 
      self._iprot.readMessageEnd()
503 
      raise x
504 
    result = getItemIds_result()
505 
    result.read(self._iprot)
506 
    self._iprot.readMessageEnd()
507 
    if result.success is not None:
508 
      return result.success
509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemIds failed: unknown result");
510 
 
5185 mandeep.dh 511 
  def getInventoryItemsFromLastScanType(self, lastScanType):
512 
    """
513 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 514 
 
5185 mandeep.dh 515 
    Parameters:
516 
     - lastScanType
517 
    """
518 
    self.send_getInventoryItemsFromLastScanType(lastScanType)
519 
    return self.recv_getInventoryItemsFromLastScanType()
520 
 
521 
  def send_getInventoryItemsFromLastScanType(self, lastScanType):
522 
    self._oprot.writeMessageBegin('getInventoryItemsFromLastScanType', TMessageType.CALL, self._seqid)
523 
    args = getInventoryItemsFromLastScanType_args()
524 
    args.lastScanType = lastScanType
525 
    args.write(self._oprot)
526 
    self._oprot.writeMessageEnd()
527 
    self._oprot.trans.flush()
528 
 
529 
  def recv_getInventoryItemsFromLastScanType(self, ):
530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
531 
    if mtype == TMessageType.EXCEPTION:
532 
      x = TApplicationException()
533 
      x.read(self._iprot)
534 
      self._iprot.readMessageEnd()
535 
      raise x
536 
    result = getInventoryItemsFromLastScanType_result()
537 
    result.read(self._iprot)
538 
    self._iprot.readMessageEnd()
539 
    if result.success is not None:
540 
      return result.success
541 
    if result.wex is not None:
542 
      raise result.wex
543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsFromLastScanType failed: unknown result");
544 
 
545 
  def getInventoryItemFromId(self, inventoryItemId):
546 
    """
547 
    Retrieves inventory item given a inventoryItem id
548 
 
549 
    Parameters:
550 
     - inventoryItemId
551 
    """
552 
    self.send_getInventoryItemFromId(inventoryItemId)
553 
    return self.recv_getInventoryItemFromId()
554 
 
555 
  def send_getInventoryItemFromId(self, inventoryItemId):
556 
    self._oprot.writeMessageBegin('getInventoryItemFromId', TMessageType.CALL, self._seqid)
557 
    args = getInventoryItemFromId_args()
558 
    args.inventoryItemId = inventoryItemId
559 
    args.write(self._oprot)
560 
    self._oprot.writeMessageEnd()
561 
    self._oprot.trans.flush()
562 
 
563 
  def recv_getInventoryItemFromId(self, ):
564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
565 
    if mtype == TMessageType.EXCEPTION:
566 
      x = TApplicationException()
567 
      x.read(self._iprot)
568 
      self._iprot.readMessageEnd()
569 
      raise x
570 
    result = getInventoryItemFromId_result()
571 
    result.read(self._iprot)
572 
    self._iprot.readMessageEnd()
573 
    if result.success is not None:
574 
      return result.success
575 
    if result.wex is not None:
576 
      raise result.wex
577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromId failed: unknown result");
578 
 
5372 mandeep.dh 579 
  def getPurchaseScans(self, startDate, endDate):
580 
    """
581 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 582 
 
5372 mandeep.dh 583 
    Parameters:
584 
     - startDate
585 
     - endDate
586 
    """
587 
    self.send_getPurchaseScans(startDate, endDate)
588 
    return self.recv_getPurchaseScans()
589 
 
590 
  def send_getPurchaseScans(self, startDate, endDate):
591 
    self._oprot.writeMessageBegin('getPurchaseScans', TMessageType.CALL, self._seqid)
592 
    args = getPurchaseScans_args()
593 
    args.startDate = startDate
594 
    args.endDate = endDate
595 
    args.write(self._oprot)
596 
    self._oprot.writeMessageEnd()
597 
    self._oprot.trans.flush()
598 
 
599 
  def recv_getPurchaseScans(self, ):
600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
601 
    if mtype == TMessageType.EXCEPTION:
602 
      x = TApplicationException()
603 
      x.read(self._iprot)
604 
      self._iprot.readMessageEnd()
605 
      raise x
606 
    result = getPurchaseScans_result()
607 
    result.read(self._iprot)
608 
    self._iprot.readMessageEnd()
609 
    if result.success is not None:
610 
      return result.success
611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScans failed: unknown result");
612 
 
5496 mandeep.dh 613 
  def fetchScansPerInvoiceNumber(self, date):
614 
    """
615 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 616 
 
5496 mandeep.dh 617 
    Parameters:
618 
     - date
619 
    """
620 
    self.send_fetchScansPerInvoiceNumber(date)
621 
    return self.recv_fetchScansPerInvoiceNumber()
622 
 
623 
  def send_fetchScansPerInvoiceNumber(self, date):
624 
    self._oprot.writeMessageBegin('fetchScansPerInvoiceNumber', TMessageType.CALL, self._seqid)
625 
    args = fetchScansPerInvoiceNumber_args()
626 
    args.date = date
627 
    args.write(self._oprot)
628 
    self._oprot.writeMessageEnd()
629 
    self._oprot.trans.flush()
630 
 
631 
  def recv_fetchScansPerInvoiceNumber(self, ):
632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
633 
    if mtype == TMessageType.EXCEPTION:
634 
      x = TApplicationException()
635 
      x.read(self._iprot)
636 
      self._iprot.readMessageEnd()
637 
      raise x
638 
    result = fetchScansPerInvoiceNumber_result()
639 
    result.read(self._iprot)
640 
    self._iprot.readMessageEnd()
641 
    if result.success is not None:
642 
      return result.success
643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerInvoiceNumber failed: unknown result");
644 
 
5620 mandeep.dh 645 
  def getInventoryItemFromOrder(self, orderId):
646 
    """
647 
    Returns inventory item for a given order
5496 mandeep.dh 648 
 
5620 mandeep.dh 649 
    Parameters:
650 
     - orderId
651 
    """
652 
    self.send_getInventoryItemFromOrder(orderId)
653 
    return self.recv_getInventoryItemFromOrder()
654 
 
655 
  def send_getInventoryItemFromOrder(self, orderId):
656 
    self._oprot.writeMessageBegin('getInventoryItemFromOrder', TMessageType.CALL, self._seqid)
657 
    args = getInventoryItemFromOrder_args()
658 
    args.orderId = orderId
659 
    args.write(self._oprot)
660 
    self._oprot.writeMessageEnd()
661 
    self._oprot.trans.flush()
662 
 
663 
  def recv_getInventoryItemFromOrder(self, ):
664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
665 
    if mtype == TMessageType.EXCEPTION:
666 
      x = TApplicationException()
667 
      x.read(self._iprot)
668 
      self._iprot.readMessageEnd()
669 
      raise x
670 
    result = getInventoryItemFromOrder_result()
671 
    result.read(self._iprot)
672 
    self._iprot.readMessageEnd()
673 
    if result.success is not None:
674 
      return result.success
675 
    if result.we is not None:
676 
      raise result.we
677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromOrder failed: unknown result");
678 
 
5711 mandeep.dh 679 
  def getInventoryAge(self, ):
680 
    """
681 
    Fetches the stock inventory age week-wise
682 
    """
683 
    self.send_getInventoryAge()
684 
    return self.recv_getInventoryAge()
5620 mandeep.dh 685 
 
5711 mandeep.dh 686 
  def send_getInventoryAge(self, ):
687 
    self._oprot.writeMessageBegin('getInventoryAge', TMessageType.CALL, self._seqid)
688 
    args = getInventoryAge_args()
689 
    args.write(self._oprot)
690 
    self._oprot.writeMessageEnd()
691 
    self._oprot.trans.flush()
692 
 
693 
  def recv_getInventoryAge(self, ):
694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
695 
    if mtype == TMessageType.EXCEPTION:
696 
      x = TApplicationException()
697 
      x.read(self._iprot)
698 
      self._iprot.readMessageEnd()
699 
      raise x
700 
    result = getInventoryAge_result()
701 
    result.read(self._iprot)
702 
    self._iprot.readMessageEnd()
703 
    if result.success is not None:
704 
      return result.success
705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAge failed: unknown result");
706 
 
6361 rajveer 707 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
708 
    """
709 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 710 
 
6361 rajveer 711 
    Parameters:
712 
     - itemId
713 
     - fromDate
714 
     - toDate
715 
    """
716 
    self.send_getInventoryScansForItem(itemId, fromDate, toDate)
717 
    return self.recv_getInventoryScansForItem()
718 
 
719 
  def send_getInventoryScansForItem(self, itemId, fromDate, toDate):
720 
    self._oprot.writeMessageBegin('getInventoryScansForItem', TMessageType.CALL, self._seqid)
721 
    args = getInventoryScansForItem_args()
722 
    args.itemId = itemId
723 
    args.fromDate = fromDate
724 
    args.toDate = toDate
725 
    args.write(self._oprot)
726 
    self._oprot.writeMessageEnd()
727 
    self._oprot.trans.flush()
728 
 
729 
  def recv_getInventoryScansForItem(self, ):
730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
731 
    if mtype == TMessageType.EXCEPTION:
732 
      x = TApplicationException()
733 
      x.read(self._iprot)
734 
      self._iprot.readMessageEnd()
735 
      raise x
736 
    result = getInventoryScansForItem_result()
737 
    result.read(self._iprot)
738 
    self._iprot.readMessageEnd()
739 
    if result.success is not None:
740 
      return result.success
741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryScansForItem failed: unknown result");
742 
 
743 
  def getScanRecordsForSerialNumber(self, serialNumber):
744 
    """
745 
    Fetches the scanRecords for a given serialNumber for a given time interval
746 
 
747 
    Parameters:
748 
     - serialNumber
749 
    """
750 
    self.send_getScanRecordsForSerialNumber(serialNumber)
751 
    return self.recv_getScanRecordsForSerialNumber()
752 
 
753 
  def send_getScanRecordsForSerialNumber(self, serialNumber):
754 
    self._oprot.writeMessageBegin('getScanRecordsForSerialNumber', TMessageType.CALL, self._seqid)
755 
    args = getScanRecordsForSerialNumber_args()
756 
    args.serialNumber = serialNumber
757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
761 
  def recv_getScanRecordsForSerialNumber(self, ):
762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
768 
    result = getScanRecordsForSerialNumber_result()
769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
771 
    if result.success is not None:
772 
      return result.success
773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScanRecordsForSerialNumber failed: unknown result");
774 
 
6467 amar.kumar 775 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
776 
    """
6630 amar.kumar 777 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 778 
 
6467 amar.kumar 779 
    Parameters:
780 
     - saleReturnItems
781 
     - vendorId
782 
    """
783 
    self.send_scanForPurchaseReturn(saleReturnItems, vendorId)
784 
    self.recv_scanForPurchaseReturn()
785 
 
786 
  def send_scanForPurchaseReturn(self, saleReturnItems, vendorId):
787 
    self._oprot.writeMessageBegin('scanForPurchaseReturn', TMessageType.CALL, self._seqid)
788 
    args = scanForPurchaseReturn_args()
789 
    args.saleReturnItems = saleReturnItems
790 
    args.vendorId = vendorId
791 
    args.write(self._oprot)
792 
    self._oprot.writeMessageEnd()
793 
    self._oprot.trans.flush()
794 
 
795 
  def recv_scanForPurchaseReturn(self, ):
796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
797 
    if mtype == TMessageType.EXCEPTION:
798 
      x = TApplicationException()
799 
      x.read(self._iprot)
800 
      self._iprot.readMessageEnd()
801 
      raise x
802 
    result = scanForPurchaseReturn_result()
803 
    result.read(self._iprot)
804 
    self._iprot.readMessageEnd()
805 
    if result.ex is not None:
806 
      raise result.ex
807 
    return
808 
 
6630 amar.kumar 809 
  def scanForLostItem(self, lostItems, vendorId):
810 
    """
811 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 812 
 
6630 amar.kumar 813 
    Parameters:
814 
     - lostItems
815 
     - vendorId
816 
    """
817 
    self.send_scanForLostItem(lostItems, vendorId)
818 
    self.recv_scanForLostItem()
819 
 
820 
  def send_scanForLostItem(self, lostItems, vendorId):
821 
    self._oprot.writeMessageBegin('scanForLostItem', TMessageType.CALL, self._seqid)
822 
    args = scanForLostItem_args()
823 
    args.lostItems = lostItems
824 
    args.vendorId = vendorId
825 
    args.write(self._oprot)
826 
    self._oprot.writeMessageEnd()
827 
    self._oprot.trans.flush()
828 
 
829 
  def recv_scanForLostItem(self, ):
830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
831 
    if mtype == TMessageType.EXCEPTION:
832 
      x = TApplicationException()
833 
      x.read(self._iprot)
834 
      self._iprot.readMessageEnd()
835 
      raise x
836 
    result = scanForLostItem_result()
837 
    result.read(self._iprot)
838 
    self._iprot.readMessageEnd()
839 
    if result.ex is not None:
840 
      raise result.ex
841 
    return
842 
 
843 
  def getCurrentSerializedInventoryByScans(self, ):
844 
    """
845 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
846 
    """
847 
    self.send_getCurrentSerializedInventoryByScans()
848 
    return self.recv_getCurrentSerializedInventoryByScans()
849 
 
850 
  def send_getCurrentSerializedInventoryByScans(self, ):
851 
    self._oprot.writeMessageBegin('getCurrentSerializedInventoryByScans', TMessageType.CALL, self._seqid)
852 
    args = getCurrentSerializedInventoryByScans_args()
853 
    args.write(self._oprot)
854 
    self._oprot.writeMessageEnd()
855 
    self._oprot.trans.flush()
856 
 
857 
  def recv_getCurrentSerializedInventoryByScans(self, ):
858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
859 
    if mtype == TMessageType.EXCEPTION:
860 
      x = TApplicationException()
861 
      x.read(self._iprot)
862 
      self._iprot.readMessageEnd()
863 
      raise x
864 
    result = getCurrentSerializedInventoryByScans_result()
865 
    result.read(self._iprot)
866 
    self._iprot.readMessageEnd()
867 
    if result.success is not None:
868 
      return result.success
869 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentSerializedInventoryByScans failed: unknown result");
870 
 
871 
  def getCurrentNonSerializedInventoryByScans(self, ):
872 
    """
873 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
874 
    """
875 
    self.send_getCurrentNonSerializedInventoryByScans()
876 
    return self.recv_getCurrentNonSerializedInventoryByScans()
877 
 
878 
  def send_getCurrentNonSerializedInventoryByScans(self, ):
879 
    self._oprot.writeMessageBegin('getCurrentNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
880 
    args = getCurrentNonSerializedInventoryByScans_args()
881 
    args.write(self._oprot)
882 
    self._oprot.writeMessageEnd()
883 
    self._oprot.trans.flush()
884 
 
885 
  def recv_getCurrentNonSerializedInventoryByScans(self, ):
886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
887 
    if mtype == TMessageType.EXCEPTION:
888 
      x = TApplicationException()
889 
      x.read(self._iprot)
890 
      self._iprot.readMessageEnd()
891 
      raise x
892 
    result = getCurrentNonSerializedInventoryByScans_result()
893 
    result.read(self._iprot)
894 
    self._iprot.readMessageEnd()
895 
    if result.success is not None:
896 
      return result.success
897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentNonSerializedInventoryByScans failed: unknown result");
898 
 
899 
 
3376 rajveer 900 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
2821 chandransh 901 
  def __init__(self, handler):
3376 rajveer 902 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4501 mandeep.dh 903 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
5361 mandeep.dh 904 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
4501 mandeep.dh 905 
    self._processMap["scan"] = Processor.process_scan
906 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
907 
    self._processMap["scanForOrder"] = Processor.process_scanForOrder
908 
    self._processMap["createItemNumberMapping"] = Processor.process_createItemNumberMapping
4620 amit.gupta 909 
    self._processMap["getItemNumbers"] = Processor.process_getItemNumbers
5110 mandeep.dh 910 
    self._processMap["getItemIds"] = Processor.process_getItemIds
5185 mandeep.dh 911 
    self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
912 
    self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
5372 mandeep.dh 913 
    self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
5496 mandeep.dh 914 
    self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
5620 mandeep.dh 915 
    self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
5711 mandeep.dh 916 
    self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
6361 rajveer 917 
    self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
918 
    self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
6467 amar.kumar 919 
    self._processMap["scanForPurchaseReturn"] = Processor.process_scanForPurchaseReturn
6630 amar.kumar 920 
    self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
921 
    self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
922 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
2821 chandransh 923 
 
924 
  def process(self, iprot, oprot):
925 
    (name, type, seqid) = iprot.readMessageBegin()
926 
    if name not in self._processMap:
927 
      iprot.skip(TType.STRUCT)
928 
      iprot.readMessageEnd()
929 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
930 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
931 
      x.write(oprot)
932 
      oprot.writeMessageEnd()
933 
      oprot.trans.flush()
934 
      return
935 
    else:
936 
      self._processMap[name](self, seqid, iprot, oprot)
937 
    return True
938 
 
4501 mandeep.dh 939 
  def process_getInventoryItem(self, seqid, iprot, oprot):
940 
    args = getInventoryItem_args()
2832 chandransh 941 
    args.read(iprot)
942 
    iprot.readMessageEnd()
4501 mandeep.dh 943 
    result = getInventoryItem_result()
4541 mandeep.dh 944 
    try:
945 
      result.success = self._handler.getInventoryItem(args.serialNumber)
946 
    except WarehouseServiceException, wex:
947 
      result.wex = wex
4501 mandeep.dh 948 
    oprot.writeMessageBegin("getInventoryItem", TMessageType.REPLY, seqid)
2832 chandransh 949 
    result.write(oprot)
950 
    oprot.writeMessageEnd()
951 
    oprot.trans.flush()
952 
 
5361 mandeep.dh 953 
  def process_getNonSeralizedInventoryItem(self, seqid, iprot, oprot):
954 
    args = getNonSeralizedInventoryItem_args()
2821 chandransh 955 
    args.read(iprot)
956 
    iprot.readMessageEnd()
5361 mandeep.dh 957 
    result = getNonSeralizedInventoryItem_result()
958 
    try:
5530 mandeep.dh 959 
      result.success = self._handler.getNonSeralizedInventoryItem(args.itemNumber, args.itemId, args.fulfilmentWarehouseId)
5361 mandeep.dh 960 
    except WarehouseServiceException, wex:
961 
      result.wex = wex
962 
    oprot.writeMessageBegin("getNonSeralizedInventoryItem", TMessageType.REPLY, seqid)
2821 chandransh 963 
    result.write(oprot)
964 
    oprot.writeMessageEnd()
965 
    oprot.trans.flush()
966 
 
4501 mandeep.dh 967 
  def process_scan(self, seqid, iprot, oprot):
968 
    args = scan_args()
3383 chandransh 969 
    args.read(iprot)
970 
    iprot.readMessageEnd()
4501 mandeep.dh 971 
    result = scan_result()
3383 chandransh 972 
    try:
5361 mandeep.dh 973 
      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId)
3383 chandransh 974 
    except WarehouseServiceException, wex:
975 
      result.wex = wex
4501 mandeep.dh 976 
    oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
3383 chandransh 977 
    result.write(oprot)
978 
    oprot.writeMessageEnd()
979 
    oprot.trans.flush()
980 
 
4501 mandeep.dh 981 
  def process_scanSerializedItemForOrder(self, seqid, iprot, oprot):
982 
    args = scanSerializedItemForOrder_args()
2821 chandransh 983 
    args.read(iprot)
984 
    iprot.readMessageEnd()
4501 mandeep.dh 985 
    result = scanSerializedItemForOrder_result()
2821 chandransh 986 
    try:
5110 mandeep.dh 987 
      result.success = self._handler.scanSerializedItemForOrder(args.serialNumber, args.type, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
2821 chandransh 988 
    except WarehouseServiceException, wex:
989 
      result.wex = wex
4501 mandeep.dh 990 
    oprot.writeMessageBegin("scanSerializedItemForOrder", TMessageType.REPLY, seqid)
2821 chandransh 991 
    result.write(oprot)
992 
    oprot.writeMessageEnd()
993 
    oprot.trans.flush()
994 
 
4501 mandeep.dh 995 
  def process_scanForOrder(self, seqid, iprot, oprot):
996 
    args = scanForOrder_args()
2821 chandransh 997 
    args.read(iprot)
998 
    iprot.readMessageEnd()
4501 mandeep.dh 999 
    result = scanForOrder_result()
2821 chandransh 1000 
    try:
5361 mandeep.dh 1001 
      result.success = self._handler.scanForOrder(args.inventoryItem, args.type, args.quantity, args.orderId, args.fulfilmentWarehouseId, args.billingWarehouseId)
2821 chandransh 1002 
    except WarehouseServiceException, wex:
1003 
      result.wex = wex
4501 mandeep.dh 1004 
    oprot.writeMessageBegin("scanForOrder", TMessageType.REPLY, seqid)
2821 chandransh 1005 
    result.write(oprot)
1006 
    oprot.writeMessageEnd()
1007 
    oprot.trans.flush()
1008 
 
4501 mandeep.dh 1009 
  def process_createItemNumberMapping(self, seqid, iprot, oprot):
1010 
    args = createItemNumberMapping_args()
1011 
    args.read(iprot)
1012 
    iprot.readMessageEnd()
1013 
    result = createItemNumberMapping_result()
1014 
    self._handler.createItemNumberMapping(args.itemNumber, args.itemId)
1015 
    oprot.writeMessageBegin("createItemNumberMapping", TMessageType.REPLY, seqid)
1016 
    result.write(oprot)
1017 
    oprot.writeMessageEnd()
1018 
    oprot.trans.flush()
2821 chandransh 1019 
 
4620 amit.gupta 1020 
  def process_getItemNumbers(self, seqid, iprot, oprot):
1021 
    args = getItemNumbers_args()
1022 
    args.read(iprot)
1023 
    iprot.readMessageEnd()
1024 
    result = getItemNumbers_result()
1025 
    result.success = self._handler.getItemNumbers(args.itemId)
1026 
    oprot.writeMessageBegin("getItemNumbers", TMessageType.REPLY, seqid)
1027 
    result.write(oprot)
1028 
    oprot.writeMessageEnd()
1029 
    oprot.trans.flush()
4501 mandeep.dh 1030 
 
5110 mandeep.dh 1031 
  def process_getItemIds(self, seqid, iprot, oprot):
1032 
    args = getItemIds_args()
1033 
    args.read(iprot)
1034 
    iprot.readMessageEnd()
1035 
    result = getItemIds_result()
1036 
    result.success = self._handler.getItemIds(args.itemNumber)
1037 
    oprot.writeMessageBegin("getItemIds", TMessageType.REPLY, seqid)
1038 
    result.write(oprot)
1039 
    oprot.writeMessageEnd()
1040 
    oprot.trans.flush()
4620 amit.gupta 1041 
 
5185 mandeep.dh 1042 
  def process_getInventoryItemsFromLastScanType(self, seqid, iprot, oprot):
1043 
    args = getInventoryItemsFromLastScanType_args()
1044 
    args.read(iprot)
1045 
    iprot.readMessageEnd()
1046 
    result = getInventoryItemsFromLastScanType_result()
1047 
    try:
1048 
      result.success = self._handler.getInventoryItemsFromLastScanType(args.lastScanType)
1049 
    except WarehouseServiceException, wex:
1050 
      result.wex = wex
1051 
    oprot.writeMessageBegin("getInventoryItemsFromLastScanType", TMessageType.REPLY, seqid)
1052 
    result.write(oprot)
1053 
    oprot.writeMessageEnd()
1054 
    oprot.trans.flush()
5110 mandeep.dh 1055 
 
5185 mandeep.dh 1056 
  def process_getInventoryItemFromId(self, seqid, iprot, oprot):
1057 
    args = getInventoryItemFromId_args()
1058 
    args.read(iprot)
1059 
    iprot.readMessageEnd()
1060 
    result = getInventoryItemFromId_result()
1061 
    try:
1062 
      result.success = self._handler.getInventoryItemFromId(args.inventoryItemId)
1063 
    except WarehouseServiceException, wex:
1064 
      result.wex = wex
1065 
    oprot.writeMessageBegin("getInventoryItemFromId", TMessageType.REPLY, seqid)
1066 
    result.write(oprot)
1067 
    oprot.writeMessageEnd()
1068 
    oprot.trans.flush()
1069 
 
5372 mandeep.dh 1070 
  def process_getPurchaseScans(self, seqid, iprot, oprot):
1071 
    args = getPurchaseScans_args()
1072 
    args.read(iprot)
1073 
    iprot.readMessageEnd()
1074 
    result = getPurchaseScans_result()
1075 
    result.success = self._handler.getPurchaseScans(args.startDate, args.endDate)
1076 
    oprot.writeMessageBegin("getPurchaseScans", TMessageType.REPLY, seqid)
1077 
    result.write(oprot)
1078 
    oprot.writeMessageEnd()
1079 
    oprot.trans.flush()
5185 mandeep.dh 1080 
 
5496 mandeep.dh 1081 
  def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
1082 
    args = fetchScansPerInvoiceNumber_args()
1083 
    args.read(iprot)
1084 
    iprot.readMessageEnd()
1085 
    result = fetchScansPerInvoiceNumber_result()
1086 
    result.success = self._handler.fetchScansPerInvoiceNumber(args.date)
1087 
    oprot.writeMessageBegin("fetchScansPerInvoiceNumber", TMessageType.REPLY, seqid)
1088 
    result.write(oprot)
1089 
    oprot.writeMessageEnd()
1090 
    oprot.trans.flush()
5372 mandeep.dh 1091 
 
5620 mandeep.dh 1092 
  def process_getInventoryItemFromOrder(self, seqid, iprot, oprot):
1093 
    args = getInventoryItemFromOrder_args()
1094 
    args.read(iprot)
1095 
    iprot.readMessageEnd()
1096 
    result = getInventoryItemFromOrder_result()
1097 
    try:
1098 
      result.success = self._handler.getInventoryItemFromOrder(args.orderId)
1099 
    except WarehouseServiceException, we:
1100 
      result.we = we
1101 
    oprot.writeMessageBegin("getInventoryItemFromOrder", TMessageType.REPLY, seqid)
1102 
    result.write(oprot)
1103 
    oprot.writeMessageEnd()
1104 
    oprot.trans.flush()
5496 mandeep.dh 1105 
 
5711 mandeep.dh 1106 
  def process_getInventoryAge(self, seqid, iprot, oprot):
1107 
    args = getInventoryAge_args()
1108 
    args.read(iprot)
1109 
    iprot.readMessageEnd()
1110 
    result = getInventoryAge_result()
1111 
    result.success = self._handler.getInventoryAge()
1112 
    oprot.writeMessageBegin("getInventoryAge", TMessageType.REPLY, seqid)
1113 
    result.write(oprot)
1114 
    oprot.writeMessageEnd()
1115 
    oprot.trans.flush()
5620 mandeep.dh 1116 
 
6361 rajveer 1117 
  def process_getInventoryScansForItem(self, seqid, iprot, oprot):
1118 
    args = getInventoryScansForItem_args()
1119 
    args.read(iprot)
1120 
    iprot.readMessageEnd()
1121 
    result = getInventoryScansForItem_result()
1122 
    result.success = self._handler.getInventoryScansForItem(args.itemId, args.fromDate, args.toDate)
1123 
    oprot.writeMessageBegin("getInventoryScansForItem", TMessageType.REPLY, seqid)
1124 
    result.write(oprot)
1125 
    oprot.writeMessageEnd()
1126 
    oprot.trans.flush()
5711 mandeep.dh 1127 
 
6361 rajveer 1128 
  def process_getScanRecordsForSerialNumber(self, seqid, iprot, oprot):
1129 
    args = getScanRecordsForSerialNumber_args()
1130 
    args.read(iprot)
1131 
    iprot.readMessageEnd()
1132 
    result = getScanRecordsForSerialNumber_result()
1133 
    result.success = self._handler.getScanRecordsForSerialNumber(args.serialNumber)
1134 
    oprot.writeMessageBegin("getScanRecordsForSerialNumber", TMessageType.REPLY, seqid)
1135 
    result.write(oprot)
1136 
    oprot.writeMessageEnd()
1137 
    oprot.trans.flush()
1138 
 
6467 amar.kumar 1139 
  def process_scanForPurchaseReturn(self, seqid, iprot, oprot):
1140 
    args = scanForPurchaseReturn_args()
1141 
    args.read(iprot)
1142 
    iprot.readMessageEnd()
1143 
    result = scanForPurchaseReturn_result()
1144 
    try:
1145 
      self._handler.scanForPurchaseReturn(args.saleReturnItems, args.vendorId)
1146 
    except WarehouseServiceException, ex:
1147 
      result.ex = ex
1148 
    oprot.writeMessageBegin("scanForPurchaseReturn", TMessageType.REPLY, seqid)
1149 
    result.write(oprot)
1150 
    oprot.writeMessageEnd()
1151 
    oprot.trans.flush()
6361 rajveer 1152 
 
6630 amar.kumar 1153 
  def process_scanForLostItem(self, seqid, iprot, oprot):
1154 
    args = scanForLostItem_args()
1155 
    args.read(iprot)
1156 
    iprot.readMessageEnd()
1157 
    result = scanForLostItem_result()
1158 
    try:
1159 
      self._handler.scanForLostItem(args.lostItems, args.vendorId)
1160 
    except WarehouseServiceException, ex:
1161 
      result.ex = ex
1162 
    oprot.writeMessageBegin("scanForLostItem", TMessageType.REPLY, seqid)
1163 
    result.write(oprot)
1164 
    oprot.writeMessageEnd()
1165 
    oprot.trans.flush()
6467 amar.kumar 1166 
 
6630 amar.kumar 1167 
  def process_getCurrentSerializedInventoryByScans(self, seqid, iprot, oprot):
1168 
    args = getCurrentSerializedInventoryByScans_args()
1169 
    args.read(iprot)
1170 
    iprot.readMessageEnd()
1171 
    result = getCurrentSerializedInventoryByScans_result()
1172 
    result.success = self._handler.getCurrentSerializedInventoryByScans()
1173 
    oprot.writeMessageBegin("getCurrentSerializedInventoryByScans", TMessageType.REPLY, seqid)
1174 
    result.write(oprot)
1175 
    oprot.writeMessageEnd()
1176 
    oprot.trans.flush()
1177 
 
1178 
  def process_getCurrentNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1179 
    args = getCurrentNonSerializedInventoryByScans_args()
1180 
    args.read(iprot)
1181 
    iprot.readMessageEnd()
1182 
    result = getCurrentNonSerializedInventoryByScans_result()
1183 
    result.success = self._handler.getCurrentNonSerializedInventoryByScans()
1184 
    oprot.writeMessageBegin("getCurrentNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1185 
    result.write(oprot)
1186 
    oprot.writeMessageEnd()
1187 
    oprot.trans.flush()
1188 
 
1189 
 
2821 chandransh 1190 
# HELPER FUNCTIONS AND STRUCTURES
1191 
 
4501 mandeep.dh 1192 
class getInventoryItem_args:
2832 chandransh 1193 
  """
1194 
  Attributes:
4501 mandeep.dh 1195 
   - serialNumber
2832 chandransh 1196 
  """
1197 
 
1198 
  thrift_spec = (
1199 
    None, # 0
4501 mandeep.dh 1200 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
2832 chandransh 1201 
  )
1202 
 
4501 mandeep.dh 1203 
  def __init__(self, serialNumber=None,):
1204 
    self.serialNumber = serialNumber
2832 chandransh 1205 
 
1206 
  def read(self, iprot):
1207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1209 
      return
1210 
    iprot.readStructBegin()
1211 
    while True:
1212 
      (fname, ftype, fid) = iprot.readFieldBegin()
1213 
      if ftype == TType.STOP:
1214 
        break
1215 
      if fid == 1:
4501 mandeep.dh 1216 
        if ftype == TType.STRING:
1217 
          self.serialNumber = iprot.readString();
2832 chandransh 1218 
        else:
1219 
          iprot.skip(ftype)
1220 
      else:
1221 
        iprot.skip(ftype)
1222 
      iprot.readFieldEnd()
1223 
    iprot.readStructEnd()
1224 
 
1225 
  def write(self, oprot):
1226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1228 
      return
4501 mandeep.dh 1229 
    oprot.writeStructBegin('getInventoryItem_args')
1230 
    if self.serialNumber is not None:
1231 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
1232 
      oprot.writeString(self.serialNumber)
2832 chandransh 1233 
      oprot.writeFieldEnd()
1234 
    oprot.writeFieldStop()
1235 
    oprot.writeStructEnd()
1236 
 
3431 rajveer 1237 
  def validate(self):
1238 
    return
1239 
 
1240 
 
2832 chandransh 1241 
  def __repr__(self):
1242 
    L = ['%s=%r' % (key, value)
1243 
      for key, value in self.__dict__.iteritems()]
1244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1245 
 
1246 
  def __eq__(self, other):
1247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1248 
 
1249 
  def __ne__(self, other):
1250 
    return not (self == other)
1251 
 
4501 mandeep.dh 1252 
class getInventoryItem_result:
2832 chandransh 1253 
  """
1254 
  Attributes:
1255 
   - success
4541 mandeep.dh 1256 
   - wex
2832 chandransh 1257 
  """
1258 
 
1259 
  thrift_spec = (
4501 mandeep.dh 1260 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4541 mandeep.dh 1261 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2832 chandransh 1262 
  )
1263 
 
4541 mandeep.dh 1264 
  def __init__(self, success=None, wex=None,):
2832 chandransh 1265 
    self.success = success
4541 mandeep.dh 1266 
    self.wex = wex
2832 chandransh 1267 
 
1268 
  def read(self, iprot):
1269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1271 
      return
1272 
    iprot.readStructBegin()
1273 
    while True:
1274 
      (fname, ftype, fid) = iprot.readFieldBegin()
1275 
      if ftype == TType.STOP:
1276 
        break
1277 
      if fid == 0:
1278 
        if ftype == TType.STRUCT:
4501 mandeep.dh 1279 
          self.success = InventoryItem()
2832 chandransh 1280 
          self.success.read(iprot)
1281 
        else:
1282 
          iprot.skip(ftype)
4541 mandeep.dh 1283 
      elif fid == 1:
1284 
        if ftype == TType.STRUCT:
1285 
          self.wex = WarehouseServiceException()
1286 
          self.wex.read(iprot)
1287 
        else:
1288 
          iprot.skip(ftype)
2832 chandransh 1289 
      else:
1290 
        iprot.skip(ftype)
1291 
      iprot.readFieldEnd()
1292 
    iprot.readStructEnd()
1293 
 
1294 
  def write(self, oprot):
1295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1297 
      return
4501 mandeep.dh 1298 
    oprot.writeStructBegin('getInventoryItem_result')
3431 rajveer 1299 
    if self.success is not None:
2832 chandransh 1300 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1301 
      self.success.write(oprot)
1302 
      oprot.writeFieldEnd()
4541 mandeep.dh 1303 
    if self.wex is not None:
1304 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1305 
      self.wex.write(oprot)
1306 
      oprot.writeFieldEnd()
2832 chandransh 1307 
    oprot.writeFieldStop()
1308 
    oprot.writeStructEnd()
1309 
 
3431 rajveer 1310 
  def validate(self):
1311 
    return
1312 
 
1313 
 
2832 chandransh 1314 
  def __repr__(self):
1315 
    L = ['%s=%r' % (key, value)
1316 
      for key, value in self.__dict__.iteritems()]
1317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1318 
 
1319 
  def __eq__(self, other):
1320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1321 
 
1322 
  def __ne__(self, other):
1323 
    return not (self == other)
1324 
 
5361 mandeep.dh 1325 
class getNonSeralizedInventoryItem_args:
2821 chandransh 1326 
  """
1327 
  Attributes:
5530 mandeep.dh 1328 
   - itemNumber
4501 mandeep.dh 1329 
   - itemId
5530 mandeep.dh 1330 
   - fulfilmentWarehouseId
2821 chandransh 1331 
  """
1332 
 
1333 
  thrift_spec = (
1334 
    None, # 0
5530 mandeep.dh 1335 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
1336 
    (2, TType.I64, 'itemId', None, None, ), # 2
1337 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
2821 chandransh 1338 
  )
1339 
 
5530 mandeep.dh 1340 
  def __init__(self, itemNumber=None, itemId=None, fulfilmentWarehouseId=None,):
1341 
    self.itemNumber = itemNumber
4501 mandeep.dh 1342 
    self.itemId = itemId
5530 mandeep.dh 1343 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 1344 
 
1345 
  def read(self, iprot):
1346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1348 
      return
1349 
    iprot.readStructBegin()
1350 
    while True:
1351 
      (fname, ftype, fid) = iprot.readFieldBegin()
1352 
      if ftype == TType.STOP:
1353 
        break
1354 
      if fid == 1:
5530 mandeep.dh 1355 
        if ftype == TType.STRING:
1356 
          self.itemNumber = iprot.readString();
1357 
        else:
1358 
          iprot.skip(ftype)
1359 
      elif fid == 2:
2821 chandransh 1360 
        if ftype == TType.I64:
4501 mandeep.dh 1361 
          self.itemId = iprot.readI64();
2821 chandransh 1362 
        else:
1363 
          iprot.skip(ftype)
5530 mandeep.dh 1364 
      elif fid == 3:
4501 mandeep.dh 1365 
        if ftype == TType.I64:
5530 mandeep.dh 1366 
          self.fulfilmentWarehouseId = iprot.readI64();
2821 chandransh 1367 
        else:
1368 
          iprot.skip(ftype)
1369 
      else:
1370 
        iprot.skip(ftype)
1371 
      iprot.readFieldEnd()
1372 
    iprot.readStructEnd()
1373 
 
1374 
  def write(self, oprot):
1375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1377 
      return
5361 mandeep.dh 1378 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_args')
5530 mandeep.dh 1379 
    if self.itemNumber is not None:
1380 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
1381 
      oprot.writeString(self.itemNumber)
1382 
      oprot.writeFieldEnd()
4501 mandeep.dh 1383 
    if self.itemId is not None:
5530 mandeep.dh 1384 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
4501 mandeep.dh 1385 
      oprot.writeI64(self.itemId)
2821 chandransh 1386 
      oprot.writeFieldEnd()
5530 mandeep.dh 1387 
    if self.fulfilmentWarehouseId is not None:
1388 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
1389 
      oprot.writeI64(self.fulfilmentWarehouseId)
2821 chandransh 1390 
      oprot.writeFieldEnd()
1391 
    oprot.writeFieldStop()
1392 
    oprot.writeStructEnd()
1393 
 
3431 rajveer 1394 
  def validate(self):
1395 
    return
1396 
 
1397 
 
2821 chandransh 1398 
  def __repr__(self):
1399 
    L = ['%s=%r' % (key, value)
1400 
      for key, value in self.__dict__.iteritems()]
1401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1402 
 
1403 
  def __eq__(self, other):
1404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1405 
 
1406 
  def __ne__(self, other):
1407 
    return not (self == other)
1408 
 
5361 mandeep.dh 1409 
class getNonSeralizedInventoryItem_result:
2821 chandransh 1410 
  """
1411 
  Attributes:
1412 
   - success
5361 mandeep.dh 1413 
   - wex
2821 chandransh 1414 
  """
1415 
 
1416 
  thrift_spec = (
5361 mandeep.dh 1417 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
1418 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2821 chandransh 1419 
  )
1420 
 
5361 mandeep.dh 1421 
  def __init__(self, success=None, wex=None,):
2821 chandransh 1422 
    self.success = success
5361 mandeep.dh 1423 
    self.wex = wex
2821 chandransh 1424 
 
1425 
  def read(self, iprot):
1426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1428 
      return
1429 
    iprot.readStructBegin()
1430 
    while True:
1431 
      (fname, ftype, fid) = iprot.readFieldBegin()
1432 
      if ftype == TType.STOP:
1433 
        break
1434 
      if fid == 0:
5361 mandeep.dh 1435 
        if ftype == TType.STRUCT:
1436 
          self.success = InventoryItem()
1437 
          self.success.read(iprot)
2821 chandransh 1438 
        else:
1439 
          iprot.skip(ftype)
5361 mandeep.dh 1440 
      elif fid == 1:
1441 
        if ftype == TType.STRUCT:
1442 
          self.wex = WarehouseServiceException()
1443 
          self.wex.read(iprot)
2821 chandransh 1444 
        else:
1445 
          iprot.skip(ftype)
1446 
      else:
1447 
        iprot.skip(ftype)
1448 
      iprot.readFieldEnd()
1449 
    iprot.readStructEnd()
1450 
 
1451 
  def write(self, oprot):
1452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1454 
      return
5361 mandeep.dh 1455 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_result')
3431 rajveer 1456 
    if self.success is not None:
5361 mandeep.dh 1457 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1458 
      self.success.write(oprot)
2821 chandransh 1459 
      oprot.writeFieldEnd()
5361 mandeep.dh 1460 
    if self.wex is not None:
1461 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1462 
      self.wex.write(oprot)
3383 chandransh 1463 
      oprot.writeFieldEnd()
1464 
    oprot.writeFieldStop()
1465 
    oprot.writeStructEnd()
1466 
 
3431 rajveer 1467 
  def validate(self):
1468 
    return
1469 
 
1470 
 
3383 chandransh 1471 
  def __repr__(self):
1472 
    L = ['%s=%r' % (key, value)
1473 
      for key, value in self.__dict__.iteritems()]
1474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1475 
 
1476 
  def __eq__(self, other):
1477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1478 
 
1479 
  def __ne__(self, other):
1480 
    return not (self == other)
1481 
 
4501 mandeep.dh 1482 
class scan_args:
2821 chandransh 1483 
  """
1484 
  Attributes:
5361 mandeep.dh 1485 
   - inventoryItem
2821 chandransh 1486 
   - type
4501 mandeep.dh 1487 
   - quantity
5361 mandeep.dh 1488 
   - billingWarehouseId
2821 chandransh 1489 
  """
1490 
 
1491 
  thrift_spec = (
1492 
    None, # 0
5361 mandeep.dh 1493 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 1494 
    (2, TType.I32, 'type', None, None, ), # 2
1495 
    (3, TType.I64, 'quantity', None, None, ), # 3
5361 mandeep.dh 1496 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
2821 chandransh 1497 
  )
1498 
 
5361 mandeep.dh 1499 
  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None,):
1500 
    self.inventoryItem = inventoryItem
2821 chandransh 1501 
    self.type = type
4501 mandeep.dh 1502 
    self.quantity = quantity
5361 mandeep.dh 1503 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 1504 
 
1505 
  def read(self, iprot):
1506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1508 
      return
1509 
    iprot.readStructBegin()
1510 
    while True:
1511 
      (fname, ftype, fid) = iprot.readFieldBegin()
1512 
      if ftype == TType.STOP:
1513 
        break
1514 
      if fid == 1:
5361 mandeep.dh 1515 
        if ftype == TType.STRUCT:
1516 
          self.inventoryItem = InventoryItem()
1517 
          self.inventoryItem.read(iprot)
2821 chandransh 1518 
        else:
1519 
          iprot.skip(ftype)
1520 
      elif fid == 2:
4501 mandeep.dh 1521 
        if ftype == TType.I32:
1522 
          self.type = iprot.readI32();
2821 chandransh 1523 
        else:
1524 
          iprot.skip(ftype)
3383 chandransh 1525 
      elif fid == 3:
4501 mandeep.dh 1526 
        if ftype == TType.I64:
1527 
          self.quantity = iprot.readI64();
2821 chandransh 1528 
        else:
1529 
          iprot.skip(ftype)
3383 chandransh 1530 
      elif fid == 4:
4501 mandeep.dh 1531 
        if ftype == TType.I64:
5361 mandeep.dh 1532 
          self.billingWarehouseId = iprot.readI64();
2821 chandransh 1533 
        else:
1534 
          iprot.skip(ftype)
1535 
      else:
1536 
        iprot.skip(ftype)
1537 
      iprot.readFieldEnd()
1538 
    iprot.readStructEnd()
1539 
 
1540 
  def write(self, oprot):
1541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1543 
      return
4501 mandeep.dh 1544 
    oprot.writeStructBegin('scan_args')
5361 mandeep.dh 1545 
    if self.inventoryItem is not None:
1546 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
1547 
      self.inventoryItem.write(oprot)
2821 chandransh 1548 
      oprot.writeFieldEnd()
3431 rajveer 1549 
    if self.type is not None:
4501 mandeep.dh 1550 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 1551 
      oprot.writeI32(self.type)
1552 
      oprot.writeFieldEnd()
4501 mandeep.dh 1553 
    if self.quantity is not None:
1554 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
1555 
      oprot.writeI64(self.quantity)
1556 
      oprot.writeFieldEnd()
5361 mandeep.dh 1557 
    if self.billingWarehouseId is not None:
1558 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
1559 
      oprot.writeI64(self.billingWarehouseId)
4501 mandeep.dh 1560 
      oprot.writeFieldEnd()
2821 chandransh 1561 
    oprot.writeFieldStop()
1562 
    oprot.writeStructEnd()
1563 
 
3431 rajveer 1564 
  def validate(self):
1565 
    return
1566 
 
1567 
 
2821 chandransh 1568 
  def __repr__(self):
1569 
    L = ['%s=%r' % (key, value)
1570 
      for key, value in self.__dict__.iteritems()]
1571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1572 
 
1573 
  def __eq__(self, other):
1574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1575 
 
1576 
  def __ne__(self, other):
1577 
    return not (self == other)
1578 
 
4501 mandeep.dh 1579 
class scan_result:
2821 chandransh 1580 
  """
1581 
  Attributes:
1582 
   - wex
1583 
  """
1584 
 
1585 
  thrift_spec = (
1586 
    None, # 0
1587 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
1588 
  )
1589 
 
1590 
  def __init__(self, wex=None,):
1591 
    self.wex = wex
1592 
 
1593 
  def read(self, iprot):
1594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1596 
      return
1597 
    iprot.readStructBegin()
1598 
    while True:
1599 
      (fname, ftype, fid) = iprot.readFieldBegin()
1600 
      if ftype == TType.STOP:
1601 
        break
1602 
      if fid == 1:
1603 
        if ftype == TType.STRUCT:
1604 
          self.wex = WarehouseServiceException()
1605 
          self.wex.read(iprot)
1606 
        else:
1607 
          iprot.skip(ftype)
1608 
      else:
1609 
        iprot.skip(ftype)
1610 
      iprot.readFieldEnd()
1611 
    iprot.readStructEnd()
1612 
 
1613 
  def write(self, oprot):
1614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1616 
      return
4501 mandeep.dh 1617 
    oprot.writeStructBegin('scan_result')
3431 rajveer 1618 
    if self.wex is not None:
2821 chandransh 1619 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1620 
      self.wex.write(oprot)
1621 
      oprot.writeFieldEnd()
1622 
    oprot.writeFieldStop()
1623 
    oprot.writeStructEnd()
1624 
 
3431 rajveer 1625 
  def validate(self):
1626 
    return
1627 
 
1628 
 
2821 chandransh 1629 
  def __repr__(self):
1630 
    L = ['%s=%r' % (key, value)
1631 
      for key, value in self.__dict__.iteritems()]
1632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1633 
 
1634 
  def __eq__(self, other):
1635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1636 
 
1637 
  def __ne__(self, other):
1638 
    return not (self == other)
1639 
 
4501 mandeep.dh 1640 
class scanSerializedItemForOrder_args:
2821 chandransh 1641 
  """
1642 
  Attributes:
4555 mandeep.dh 1643 
   - serialNumber
2821 chandransh 1644 
   - type
4501 mandeep.dh 1645 
   - orderId
5110 mandeep.dh 1646 
   - fulfilmentWarehouseId
1647 
   - quantity
1648 
   - billingWarehouseId
2821 chandransh 1649 
  """
1650 
 
1651 
  thrift_spec = (
1652 
    None, # 0
4555 mandeep.dh 1653 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
4501 mandeep.dh 1654 
    (2, TType.I32, 'type', None, None, ), # 2
1655 
    (3, TType.I64, 'orderId', None, None, ), # 3
5110 mandeep.dh 1656 
    (4, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 4
1657 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
1658 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
2821 chandransh 1659 
  )
1660 
 
5110 mandeep.dh 1661 
  def __init__(self, serialNumber=None, type=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
4555 mandeep.dh 1662 
    self.serialNumber = serialNumber
2821 chandransh 1663 
    self.type = type
4501 mandeep.dh 1664 
    self.orderId = orderId
5110 mandeep.dh 1665 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
1666 
    self.quantity = quantity
1667 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 1668 
 
1669 
  def read(self, iprot):
1670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1672 
      return
1673 
    iprot.readStructBegin()
1674 
    while True:
1675 
      (fname, ftype, fid) = iprot.readFieldBegin()
1676 
      if ftype == TType.STOP:
1677 
        break
1678 
      if fid == 1:
4555 mandeep.dh 1679 
        if ftype == TType.STRING:
1680 
          self.serialNumber = iprot.readString();
2821 chandransh 1681 
        else:
1682 
          iprot.skip(ftype)
1683 
      elif fid == 2:
4501 mandeep.dh 1684 
        if ftype == TType.I32:
1685 
          self.type = iprot.readI32();
2821 chandransh 1686 
        else:
1687 
          iprot.skip(ftype)
1688 
      elif fid == 3:
4501 mandeep.dh 1689 
        if ftype == TType.I64:
1690 
          self.orderId = iprot.readI64();
1691 
        else:
1692 
          iprot.skip(ftype)
1693 
      elif fid == 4:
1694 
        if ftype == TType.I64:
5110 mandeep.dh 1695 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 1696 
        else:
1697 
          iprot.skip(ftype)
5110 mandeep.dh 1698 
      elif fid == 5:
1699 
        if ftype == TType.DOUBLE:
1700 
          self.quantity = iprot.readDouble();
1701 
        else:
1702 
          iprot.skip(ftype)
1703 
      elif fid == 6:
1704 
        if ftype == TType.I64:
1705 
          self.billingWarehouseId = iprot.readI64();
1706 
        else:
1707 
          iprot.skip(ftype)
4501 mandeep.dh 1708 
      else:
1709 
        iprot.skip(ftype)
1710 
      iprot.readFieldEnd()
1711 
    iprot.readStructEnd()
1712 
 
1713 
  def write(self, oprot):
1714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1716 
      return
1717 
    oprot.writeStructBegin('scanSerializedItemForOrder_args')
4555 mandeep.dh 1718 
    if self.serialNumber is not None:
1719 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
1720 
      oprot.writeString(self.serialNumber)
4501 mandeep.dh 1721 
      oprot.writeFieldEnd()
1722 
    if self.type is not None:
1723 
      oprot.writeFieldBegin('type', TType.I32, 2)
1724 
      oprot.writeI32(self.type)
1725 
      oprot.writeFieldEnd()
1726 
    if self.orderId is not None:
1727 
      oprot.writeFieldBegin('orderId', TType.I64, 3)
1728 
      oprot.writeI64(self.orderId)
1729 
      oprot.writeFieldEnd()
5110 mandeep.dh 1730 
    if self.fulfilmentWarehouseId is not None:
1731 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 4)
1732 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 1733 
      oprot.writeFieldEnd()
5110 mandeep.dh 1734 
    if self.quantity is not None:
1735 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
1736 
      oprot.writeDouble(self.quantity)
1737 
      oprot.writeFieldEnd()
1738 
    if self.billingWarehouseId is not None:
1739 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
1740 
      oprot.writeI64(self.billingWarehouseId)
1741 
      oprot.writeFieldEnd()
4501 mandeep.dh 1742 
    oprot.writeFieldStop()
1743 
    oprot.writeStructEnd()
1744 
 
1745 
  def validate(self):
1746 
    return
1747 
 
1748 
 
1749 
  def __repr__(self):
1750 
    L = ['%s=%r' % (key, value)
1751 
      for key, value in self.__dict__.iteritems()]
1752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1753 
 
1754 
  def __eq__(self, other):
1755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1756 
 
1757 
  def __ne__(self, other):
1758 
    return not (self == other)
1759 
 
1760 
class scanSerializedItemForOrder_result:
1761 
  """
1762 
  Attributes:
1763 
   - success
1764 
   - wex
1765 
  """
1766 
 
1767 
  thrift_spec = (
4555 mandeep.dh 1768 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4501 mandeep.dh 1769 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
1770 
  )
1771 
 
1772 
  def __init__(self, success=None, wex=None,):
1773 
    self.success = success
1774 
    self.wex = wex
1775 
 
1776 
  def read(self, iprot):
1777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1779 
      return
1780 
    iprot.readStructBegin()
1781 
    while True:
1782 
      (fname, ftype, fid) = iprot.readFieldBegin()
1783 
      if ftype == TType.STOP:
1784 
        break
1785 
      if fid == 0:
4555 mandeep.dh 1786 
        if ftype == TType.STRUCT:
1787 
          self.success = InventoryItem()
1788 
          self.success.read(iprot)
4501 mandeep.dh 1789 
        else:
1790 
          iprot.skip(ftype)
1791 
      elif fid == 1:
1792 
        if ftype == TType.STRUCT:
1793 
          self.wex = WarehouseServiceException()
1794 
          self.wex.read(iprot)
1795 
        else:
1796 
          iprot.skip(ftype)
1797 
      else:
1798 
        iprot.skip(ftype)
1799 
      iprot.readFieldEnd()
1800 
    iprot.readStructEnd()
1801 
 
1802 
  def write(self, oprot):
1803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1805 
      return
1806 
    oprot.writeStructBegin('scanSerializedItemForOrder_result')
1807 
    if self.success is not None:
4555 mandeep.dh 1808 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1809 
      self.success.write(oprot)
4501 mandeep.dh 1810 
      oprot.writeFieldEnd()
1811 
    if self.wex is not None:
1812 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1813 
      self.wex.write(oprot)
1814 
      oprot.writeFieldEnd()
1815 
    oprot.writeFieldStop()
1816 
    oprot.writeStructEnd()
1817 
 
1818 
  def validate(self):
1819 
    return
1820 
 
1821 
 
1822 
  def __repr__(self):
1823 
    L = ['%s=%r' % (key, value)
1824 
      for key, value in self.__dict__.iteritems()]
1825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1826 
 
1827 
  def __eq__(self, other):
1828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1829 
 
1830 
  def __ne__(self, other):
1831 
    return not (self == other)
1832 
 
1833 
class scanForOrder_args:
1834 
  """
1835 
  Attributes:
5361 mandeep.dh 1836 
   - inventoryItem
4501 mandeep.dh 1837 
   - type
1838 
   - quantity
1839 
   - orderId
5110 mandeep.dh 1840 
   - fulfilmentWarehouseId
5361 mandeep.dh 1841 
   - billingWarehouseId
4501 mandeep.dh 1842 
  """
1843 
 
1844 
  thrift_spec = (
1845 
    None, # 0
5361 mandeep.dh 1846 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 1847 
    (2, TType.I32, 'type', None, None, ), # 2
1848 
    (3, TType.I64, 'quantity', None, None, ), # 3
1849 
    (4, TType.I64, 'orderId', None, None, ), # 4
5110 mandeep.dh 1850 
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
5361 mandeep.dh 1851 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
4501 mandeep.dh 1852 
  )
1853 
 
5361 mandeep.dh 1854 
  def __init__(self, inventoryItem=None, type=None, quantity=None, orderId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
1855 
    self.inventoryItem = inventoryItem
4501 mandeep.dh 1856 
    self.type = type
1857 
    self.quantity = quantity
1858 
    self.orderId = orderId
5110 mandeep.dh 1859 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 1860 
    self.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 1861 
 
1862 
  def read(self, iprot):
1863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1865 
      return
1866 
    iprot.readStructBegin()
1867 
    while True:
1868 
      (fname, ftype, fid) = iprot.readFieldBegin()
1869 
      if ftype == TType.STOP:
1870 
        break
1871 
      if fid == 1:
5361 mandeep.dh 1872 
        if ftype == TType.STRUCT:
1873 
          self.inventoryItem = InventoryItem()
1874 
          self.inventoryItem.read(iprot)
4501 mandeep.dh 1875 
        else:
1876 
          iprot.skip(ftype)
1877 
      elif fid == 2:
2821 chandransh 1878 
        if ftype == TType.I32:
1879 
          self.type = iprot.readI32();
1880 
        else:
1881 
          iprot.skip(ftype)
4501 mandeep.dh 1882 
      elif fid == 3:
1883 
        if ftype == TType.I64:
1884 
          self.quantity = iprot.readI64();
1885 
        else:
1886 
          iprot.skip(ftype)
1887 
      elif fid == 4:
1888 
        if ftype == TType.I64:
1889 
          self.orderId = iprot.readI64();
1890 
        else:
1891 
          iprot.skip(ftype)
1892 
      elif fid == 5:
1893 
        if ftype == TType.I64:
5110 mandeep.dh 1894 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 1895 
        else:
1896 
          iprot.skip(ftype)
5361 mandeep.dh 1897 
      elif fid == 6:
1898 
        if ftype == TType.I64:
1899 
          self.billingWarehouseId = iprot.readI64();
1900 
        else:
1901 
          iprot.skip(ftype)
2821 chandransh 1902 
      else:
1903 
        iprot.skip(ftype)
1904 
      iprot.readFieldEnd()
1905 
    iprot.readStructEnd()
1906 
 
1907 
  def write(self, oprot):
1908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1910 
      return
4501 mandeep.dh 1911 
    oprot.writeStructBegin('scanForOrder_args')
5361 mandeep.dh 1912 
    if self.inventoryItem is not None:
1913 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
1914 
      self.inventoryItem.write(oprot)
2821 chandransh 1915 
      oprot.writeFieldEnd()
3431 rajveer 1916 
    if self.type is not None:
4501 mandeep.dh 1917 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 1918 
      oprot.writeI32(self.type)
1919 
      oprot.writeFieldEnd()
4501 mandeep.dh 1920 
    if self.quantity is not None:
1921 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
1922 
      oprot.writeI64(self.quantity)
1923 
      oprot.writeFieldEnd()
1924 
    if self.orderId is not None:
1925 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
1926 
      oprot.writeI64(self.orderId)
1927 
      oprot.writeFieldEnd()
5110 mandeep.dh 1928 
    if self.fulfilmentWarehouseId is not None:
1929 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
1930 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 1931 
      oprot.writeFieldEnd()
5361 mandeep.dh 1932 
    if self.billingWarehouseId is not None:
1933 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
1934 
      oprot.writeI64(self.billingWarehouseId)
1935 
      oprot.writeFieldEnd()
2821 chandransh 1936 
    oprot.writeFieldStop()
1937 
    oprot.writeStructEnd()
1938 
 
3431 rajveer 1939 
  def validate(self):
1940 
    return
1941 
 
1942 
 
2821 chandransh 1943 
  def __repr__(self):
1944 
    L = ['%s=%r' % (key, value)
1945 
      for key, value in self.__dict__.iteritems()]
1946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1947 
 
1948 
  def __eq__(self, other):
1949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1950 
 
1951 
  def __ne__(self, other):
1952 
    return not (self == other)
1953 
 
4501 mandeep.dh 1954 
class scanForOrder_result:
2821 chandransh 1955 
  """
1956 
  Attributes:
5361 mandeep.dh 1957 
   - success
2821 chandransh 1958 
   - wex
1959 
  """
1960 
 
1961 
  thrift_spec = (
5361 mandeep.dh 1962 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2821 chandransh 1963 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
1964 
  )
1965 
 
5361 mandeep.dh 1966 
  def __init__(self, success=None, wex=None,):
1967 
    self.success = success
2821 chandransh 1968 
    self.wex = wex
1969 
 
1970 
  def read(self, iprot):
1971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1973 
      return
1974 
    iprot.readStructBegin()
1975 
    while True:
1976 
      (fname, ftype, fid) = iprot.readFieldBegin()
1977 
      if ftype == TType.STOP:
1978 
        break
5361 mandeep.dh 1979 
      if fid == 0:
2821 chandransh 1980 
        if ftype == TType.STRUCT:
5361 mandeep.dh 1981 
          self.success = InventoryItem()
1982 
          self.success.read(iprot)
1983 
        else:
1984 
          iprot.skip(ftype)
1985 
      elif fid == 1:
1986 
        if ftype == TType.STRUCT:
2821 chandransh 1987 
          self.wex = WarehouseServiceException()
1988 
          self.wex.read(iprot)
1989 
        else:
1990 
          iprot.skip(ftype)
1991 
      else:
1992 
        iprot.skip(ftype)
1993 
      iprot.readFieldEnd()
1994 
    iprot.readStructEnd()
1995 
 
1996 
  def write(self, oprot):
1997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1999 
      return
4501 mandeep.dh 2000 
    oprot.writeStructBegin('scanForOrder_result')
5361 mandeep.dh 2001 
    if self.success is not None:
2002 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2003 
      self.success.write(oprot)
2004 
      oprot.writeFieldEnd()
3431 rajveer 2005 
    if self.wex is not None:
2821 chandransh 2006 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2007 
      self.wex.write(oprot)
2008 
      oprot.writeFieldEnd()
2009 
    oprot.writeFieldStop()
2010 
    oprot.writeStructEnd()
2011 
 
3431 rajveer 2012 
  def validate(self):
2013 
    return
2014 
 
2015 
 
2821 chandransh 2016 
  def __repr__(self):
2017 
    L = ['%s=%r' % (key, value)
2018 
      for key, value in self.__dict__.iteritems()]
2019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2020 
 
2021 
  def __eq__(self, other):
2022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2023 
 
2024 
  def __ne__(self, other):
2025 
    return not (self == other)
4501 mandeep.dh 2026 
 
2027 
class createItemNumberMapping_args:
2028 
  """
2029 
  Attributes:
2030 
   - itemNumber
2031 
   - itemId
2032 
  """
2033 
 
2034 
  thrift_spec = (
2035 
    None, # 0
2036 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2037 
    (2, TType.I64, 'itemId', None, None, ), # 2
2038 
  )
2039 
 
2040 
  def __init__(self, itemNumber=None, itemId=None,):
2041 
    self.itemNumber = itemNumber
2042 
    self.itemId = itemId
2043 
 
2044 
  def read(self, iprot):
2045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2047 
      return
2048 
    iprot.readStructBegin()
2049 
    while True:
2050 
      (fname, ftype, fid) = iprot.readFieldBegin()
2051 
      if ftype == TType.STOP:
2052 
        break
2053 
      if fid == 1:
2054 
        if ftype == TType.STRING:
2055 
          self.itemNumber = iprot.readString();
2056 
        else:
2057 
          iprot.skip(ftype)
2058 
      elif fid == 2:
2059 
        if ftype == TType.I64:
2060 
          self.itemId = iprot.readI64();
2061 
        else:
2062 
          iprot.skip(ftype)
2063 
      else:
2064 
        iprot.skip(ftype)
2065 
      iprot.readFieldEnd()
2066 
    iprot.readStructEnd()
2067 
 
2068 
  def write(self, oprot):
2069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2071 
      return
2072 
    oprot.writeStructBegin('createItemNumberMapping_args')
2073 
    if self.itemNumber is not None:
2074 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2075 
      oprot.writeString(self.itemNumber)
2076 
      oprot.writeFieldEnd()
2077 
    if self.itemId is not None:
2078 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
2079 
      oprot.writeI64(self.itemId)
2080 
      oprot.writeFieldEnd()
2081 
    oprot.writeFieldStop()
2082 
    oprot.writeStructEnd()
2083 
 
2084 
  def validate(self):
2085 
    return
2086 
 
2087 
 
2088 
  def __repr__(self):
2089 
    L = ['%s=%r' % (key, value)
2090 
      for key, value in self.__dict__.iteritems()]
2091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2092 
 
2093 
  def __eq__(self, other):
2094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2095 
 
2096 
  def __ne__(self, other):
2097 
    return not (self == other)
2098 
 
2099 
class createItemNumberMapping_result:
2100 
 
2101 
  thrift_spec = (
2102 
  )
2103 
 
2104 
  def read(self, iprot):
2105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2107 
      return
2108 
    iprot.readStructBegin()
2109 
    while True:
2110 
      (fname, ftype, fid) = iprot.readFieldBegin()
2111 
      if ftype == TType.STOP:
2112 
        break
2113 
      else:
2114 
        iprot.skip(ftype)
2115 
      iprot.readFieldEnd()
2116 
    iprot.readStructEnd()
2117 
 
2118 
  def write(self, oprot):
2119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2121 
      return
2122 
    oprot.writeStructBegin('createItemNumberMapping_result')
2123 
    oprot.writeFieldStop()
2124 
    oprot.writeStructEnd()
2125 
 
2126 
  def validate(self):
2127 
    return
2128 
 
2129 
 
2130 
  def __repr__(self):
2131 
    L = ['%s=%r' % (key, value)
2132 
      for key, value in self.__dict__.iteritems()]
2133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2134 
 
2135 
  def __eq__(self, other):
2136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2137 
 
2138 
  def __ne__(self, other):
2139 
    return not (self == other)
4620 amit.gupta 2140 
 
2141 
class getItemNumbers_args:
2142 
  """
2143 
  Attributes:
2144 
   - itemId
2145 
  """
2146 
 
2147 
  thrift_spec = (
2148 
    None, # 0
2149 
    (1, TType.I64, 'itemId', None, None, ), # 1
2150 
  )
2151 
 
2152 
  def __init__(self, itemId=None,):
2153 
    self.itemId = itemId
2154 
 
2155 
  def read(self, iprot):
2156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2158 
      return
2159 
    iprot.readStructBegin()
2160 
    while True:
2161 
      (fname, ftype, fid) = iprot.readFieldBegin()
2162 
      if ftype == TType.STOP:
2163 
        break
2164 
      if fid == 1:
2165 
        if ftype == TType.I64:
2166 
          self.itemId = iprot.readI64();
2167 
        else:
2168 
          iprot.skip(ftype)
2169 
      else:
2170 
        iprot.skip(ftype)
2171 
      iprot.readFieldEnd()
2172 
    iprot.readStructEnd()
2173 
 
2174 
  def write(self, oprot):
2175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2177 
      return
2178 
    oprot.writeStructBegin('getItemNumbers_args')
2179 
    if self.itemId is not None:
2180 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
2181 
      oprot.writeI64(self.itemId)
2182 
      oprot.writeFieldEnd()
2183 
    oprot.writeFieldStop()
2184 
    oprot.writeStructEnd()
2185 
 
2186 
  def validate(self):
2187 
    return
2188 
 
2189 
 
2190 
  def __repr__(self):
2191 
    L = ['%s=%r' % (key, value)
2192 
      for key, value in self.__dict__.iteritems()]
2193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2194 
 
2195 
  def __eq__(self, other):
2196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2197 
 
2198 
  def __ne__(self, other):
2199 
    return not (self == other)
2200 
 
2201 
class getItemNumbers_result:
2202 
  """
2203 
  Attributes:
2204 
   - success
2205 
  """
2206 
 
2207 
  thrift_spec = (
2208 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
2209 
  )
2210 
 
2211 
  def __init__(self, success=None,):
2212 
    self.success = success
2213 
 
2214 
  def read(self, iprot):
2215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2217 
      return
2218 
    iprot.readStructBegin()
2219 
    while True:
2220 
      (fname, ftype, fid) = iprot.readFieldBegin()
2221 
      if ftype == TType.STOP:
2222 
        break
2223 
      if fid == 0:
2224 
        if ftype == TType.LIST:
2225 
          self.success = []
5361 mandeep.dh 2226 
          (_etype3, _size0) = iprot.readListBegin()
2227 
          for _i4 in xrange(_size0):
2228 
            _elem5 = iprot.readString();
2229 
            self.success.append(_elem5)
4620 amit.gupta 2230 
          iprot.readListEnd()
2231 
        else:
2232 
          iprot.skip(ftype)
2233 
      else:
2234 
        iprot.skip(ftype)
2235 
      iprot.readFieldEnd()
2236 
    iprot.readStructEnd()
2237 
 
2238 
  def write(self, oprot):
2239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2241 
      return
2242 
    oprot.writeStructBegin('getItemNumbers_result')
2243 
    if self.success is not None:
2244 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2245 
      oprot.writeListBegin(TType.STRING, len(self.success))
5361 mandeep.dh 2246 
      for iter6 in self.success:
2247 
        oprot.writeString(iter6)
4620 amit.gupta 2248 
      oprot.writeListEnd()
2249 
      oprot.writeFieldEnd()
2250 
    oprot.writeFieldStop()
2251 
    oprot.writeStructEnd()
2252 
 
2253 
  def validate(self):
2254 
    return
2255 
 
2256 
 
2257 
  def __repr__(self):
2258 
    L = ['%s=%r' % (key, value)
2259 
      for key, value in self.__dict__.iteritems()]
2260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2261 
 
2262 
  def __eq__(self, other):
2263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2264 
 
2265 
  def __ne__(self, other):
2266 
    return not (self == other)
5110 mandeep.dh 2267 
 
2268 
class getItemIds_args:
2269 
  """
2270 
  Attributes:
2271 
   - itemNumber
2272 
  """
2273 
 
2274 
  thrift_spec = (
2275 
    None, # 0
2276 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2277 
  )
2278 
 
2279 
  def __init__(self, itemNumber=None,):
2280 
    self.itemNumber = itemNumber
2281 
 
2282 
  def read(self, iprot):
2283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2285 
      return
2286 
    iprot.readStructBegin()
2287 
    while True:
2288 
      (fname, ftype, fid) = iprot.readFieldBegin()
2289 
      if ftype == TType.STOP:
2290 
        break
2291 
      if fid == 1:
2292 
        if ftype == TType.STRING:
2293 
          self.itemNumber = iprot.readString();
2294 
        else:
2295 
          iprot.skip(ftype)
2296 
      else:
2297 
        iprot.skip(ftype)
2298 
      iprot.readFieldEnd()
2299 
    iprot.readStructEnd()
2300 
 
2301 
  def write(self, oprot):
2302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2304 
      return
2305 
    oprot.writeStructBegin('getItemIds_args')
2306 
    if self.itemNumber is not None:
2307 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2308 
      oprot.writeString(self.itemNumber)
2309 
      oprot.writeFieldEnd()
2310 
    oprot.writeFieldStop()
2311 
    oprot.writeStructEnd()
2312 
 
2313 
  def validate(self):
2314 
    return
2315 
 
2316 
 
2317 
  def __repr__(self):
2318 
    L = ['%s=%r' % (key, value)
2319 
      for key, value in self.__dict__.iteritems()]
2320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2321 
 
2322 
  def __eq__(self, other):
2323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2324 
 
2325 
  def __ne__(self, other):
2326 
    return not (self == other)
2327 
 
2328 
class getItemIds_result:
2329 
  """
2330 
  Attributes:
2331 
   - success
2332 
  """
2333 
 
2334 
  thrift_spec = (
2335 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2336 
  )
2337 
 
2338 
  def __init__(self, success=None,):
2339 
    self.success = success
2340 
 
2341 
  def read(self, iprot):
2342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2344 
      return
2345 
    iprot.readStructBegin()
2346 
    while True:
2347 
      (fname, ftype, fid) = iprot.readFieldBegin()
2348 
      if ftype == TType.STOP:
2349 
        break
2350 
      if fid == 0:
2351 
        if ftype == TType.LIST:
2352 
          self.success = []
5361 mandeep.dh 2353 
          (_etype10, _size7) = iprot.readListBegin()
2354 
          for _i11 in xrange(_size7):
2355 
            _elem12 = iprot.readI64();
2356 
            self.success.append(_elem12)
5110 mandeep.dh 2357 
          iprot.readListEnd()
2358 
        else:
2359 
          iprot.skip(ftype)
2360 
      else:
2361 
        iprot.skip(ftype)
2362 
      iprot.readFieldEnd()
2363 
    iprot.readStructEnd()
2364 
 
2365 
  def write(self, oprot):
2366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2368 
      return
2369 
    oprot.writeStructBegin('getItemIds_result')
2370 
    if self.success is not None:
2371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2372 
      oprot.writeListBegin(TType.I64, len(self.success))
5361 mandeep.dh 2373 
      for iter13 in self.success:
2374 
        oprot.writeI64(iter13)
5110 mandeep.dh 2375 
      oprot.writeListEnd()
2376 
      oprot.writeFieldEnd()
2377 
    oprot.writeFieldStop()
2378 
    oprot.writeStructEnd()
2379 
 
2380 
  def validate(self):
2381 
    return
2382 
 
2383 
 
2384 
  def __repr__(self):
2385 
    L = ['%s=%r' % (key, value)
2386 
      for key, value in self.__dict__.iteritems()]
2387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2388 
 
2389 
  def __eq__(self, other):
2390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2391 
 
2392 
  def __ne__(self, other):
2393 
    return not (self == other)
5185 mandeep.dh 2394 
 
2395 
class getInventoryItemsFromLastScanType_args:
2396 
  """
2397 
  Attributes:
2398 
   - lastScanType
2399 
  """
2400 
 
2401 
  thrift_spec = (
2402 
    None, # 0
2403 
    (1, TType.I32, 'lastScanType', None, None, ), # 1
2404 
  )
2405 
 
2406 
  def __init__(self, lastScanType=None,):
2407 
    self.lastScanType = lastScanType
2408 
 
2409 
  def read(self, iprot):
2410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2412 
      return
2413 
    iprot.readStructBegin()
2414 
    while True:
2415 
      (fname, ftype, fid) = iprot.readFieldBegin()
2416 
      if ftype == TType.STOP:
2417 
        break
2418 
      if fid == 1:
2419 
        if ftype == TType.I32:
2420 
          self.lastScanType = iprot.readI32();
2421 
        else:
2422 
          iprot.skip(ftype)
2423 
      else:
2424 
        iprot.skip(ftype)
2425 
      iprot.readFieldEnd()
2426 
    iprot.readStructEnd()
2427 
 
2428 
  def write(self, oprot):
2429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2431 
      return
2432 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_args')
2433 
    if self.lastScanType is not None:
2434 
      oprot.writeFieldBegin('lastScanType', TType.I32, 1)
2435 
      oprot.writeI32(self.lastScanType)
2436 
      oprot.writeFieldEnd()
2437 
    oprot.writeFieldStop()
2438 
    oprot.writeStructEnd()
2439 
 
2440 
  def validate(self):
2441 
    return
2442 
 
2443 
 
2444 
  def __repr__(self):
2445 
    L = ['%s=%r' % (key, value)
2446 
      for key, value in self.__dict__.iteritems()]
2447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2448 
 
2449 
  def __eq__(self, other):
2450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2451 
 
2452 
  def __ne__(self, other):
2453 
    return not (self == other)
2454 
 
2455 
class getInventoryItemsFromLastScanType_result:
2456 
  """
2457 
  Attributes:
2458 
   - success
2459 
   - wex
2460 
  """
2461 
 
2462 
  thrift_spec = (
2463 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
2464 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2465 
  )
2466 
 
2467 
  def __init__(self, success=None, wex=None,):
2468 
    self.success = success
2469 
    self.wex = wex
2470 
 
2471 
  def read(self, iprot):
2472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2474 
      return
2475 
    iprot.readStructBegin()
2476 
    while True:
2477 
      (fname, ftype, fid) = iprot.readFieldBegin()
2478 
      if ftype == TType.STOP:
2479 
        break
2480 
      if fid == 0:
2481 
        if ftype == TType.LIST:
2482 
          self.success = []
5361 mandeep.dh 2483 
          (_etype17, _size14) = iprot.readListBegin()
2484 
          for _i18 in xrange(_size14):
2485 
            _elem19 = InventoryItem()
2486 
            _elem19.read(iprot)
2487 
            self.success.append(_elem19)
5185 mandeep.dh 2488 
          iprot.readListEnd()
2489 
        else:
2490 
          iprot.skip(ftype)
2491 
      elif fid == 1:
2492 
        if ftype == TType.STRUCT:
2493 
          self.wex = WarehouseServiceException()
2494 
          self.wex.read(iprot)
2495 
        else:
2496 
          iprot.skip(ftype)
2497 
      else:
2498 
        iprot.skip(ftype)
2499 
      iprot.readFieldEnd()
2500 
    iprot.readStructEnd()
2501 
 
2502 
  def write(self, oprot):
2503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2505 
      return
2506 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_result')
2507 
    if self.success is not None:
2508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5361 mandeep.dh 2510 
      for iter20 in self.success:
2511 
        iter20.write(oprot)
5185 mandeep.dh 2512 
      oprot.writeListEnd()
2513 
      oprot.writeFieldEnd()
2514 
    if self.wex is not None:
2515 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2516 
      self.wex.write(oprot)
2517 
      oprot.writeFieldEnd()
2518 
    oprot.writeFieldStop()
2519 
    oprot.writeStructEnd()
2520 
 
2521 
  def validate(self):
2522 
    return
2523 
 
2524 
 
2525 
  def __repr__(self):
2526 
    L = ['%s=%r' % (key, value)
2527 
      for key, value in self.__dict__.iteritems()]
2528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2529 
 
2530 
  def __eq__(self, other):
2531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2532 
 
2533 
  def __ne__(self, other):
2534 
    return not (self == other)
2535 
 
2536 
class getInventoryItemFromId_args:
2537 
  """
2538 
  Attributes:
2539 
   - inventoryItemId
2540 
  """
2541 
 
2542 
  thrift_spec = (
2543 
    None, # 0
2544 
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
2545 
  )
2546 
 
2547 
  def __init__(self, inventoryItemId=None,):
2548 
    self.inventoryItemId = inventoryItemId
2549 
 
2550 
  def read(self, iprot):
2551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2553 
      return
2554 
    iprot.readStructBegin()
2555 
    while True:
2556 
      (fname, ftype, fid) = iprot.readFieldBegin()
2557 
      if ftype == TType.STOP:
2558 
        break
2559 
      if fid == 1:
2560 
        if ftype == TType.I64:
2561 
          self.inventoryItemId = iprot.readI64();
2562 
        else:
2563 
          iprot.skip(ftype)
2564 
      else:
2565 
        iprot.skip(ftype)
2566 
      iprot.readFieldEnd()
2567 
    iprot.readStructEnd()
2568 
 
2569 
  def write(self, oprot):
2570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2572 
      return
2573 
    oprot.writeStructBegin('getInventoryItemFromId_args')
2574 
    if self.inventoryItemId is not None:
2575 
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
2576 
      oprot.writeI64(self.inventoryItemId)
2577 
      oprot.writeFieldEnd()
2578 
    oprot.writeFieldStop()
2579 
    oprot.writeStructEnd()
2580 
 
2581 
  def validate(self):
2582 
    return
2583 
 
2584 
 
2585 
  def __repr__(self):
2586 
    L = ['%s=%r' % (key, value)
2587 
      for key, value in self.__dict__.iteritems()]
2588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2589 
 
2590 
  def __eq__(self, other):
2591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2592 
 
2593 
  def __ne__(self, other):
2594 
    return not (self == other)
2595 
 
2596 
class getInventoryItemFromId_result:
2597 
  """
2598 
  Attributes:
2599 
   - success
2600 
   - wex
2601 
  """
2602 
 
2603 
  thrift_spec = (
2604 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2605 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2606 
  )
2607 
 
2608 
  def __init__(self, success=None, wex=None,):
2609 
    self.success = success
2610 
    self.wex = wex
2611 
 
2612 
  def read(self, iprot):
2613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2615 
      return
2616 
    iprot.readStructBegin()
2617 
    while True:
2618 
      (fname, ftype, fid) = iprot.readFieldBegin()
2619 
      if ftype == TType.STOP:
2620 
        break
2621 
      if fid == 0:
2622 
        if ftype == TType.STRUCT:
2623 
          self.success = InventoryItem()
2624 
          self.success.read(iprot)
2625 
        else:
2626 
          iprot.skip(ftype)
2627 
      elif fid == 1:
2628 
        if ftype == TType.STRUCT:
2629 
          self.wex = WarehouseServiceException()
2630 
          self.wex.read(iprot)
2631 
        else:
2632 
          iprot.skip(ftype)
2633 
      else:
2634 
        iprot.skip(ftype)
2635 
      iprot.readFieldEnd()
2636 
    iprot.readStructEnd()
2637 
 
2638 
  def write(self, oprot):
2639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2641 
      return
2642 
    oprot.writeStructBegin('getInventoryItemFromId_result')
2643 
    if self.success is not None:
2644 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2645 
      self.success.write(oprot)
2646 
      oprot.writeFieldEnd()
2647 
    if self.wex is not None:
2648 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2649 
      self.wex.write(oprot)
2650 
      oprot.writeFieldEnd()
2651 
    oprot.writeFieldStop()
2652 
    oprot.writeStructEnd()
2653 
 
2654 
  def validate(self):
2655 
    return
2656 
 
2657 
 
2658 
  def __repr__(self):
2659 
    L = ['%s=%r' % (key, value)
2660 
      for key, value in self.__dict__.iteritems()]
2661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2662 
 
2663 
  def __eq__(self, other):
2664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2665 
 
2666 
  def __ne__(self, other):
2667 
    return not (self == other)
5372 mandeep.dh 2668 
 
2669 
class getPurchaseScans_args:
2670 
  """
2671 
  Attributes:
2672 
   - startDate
2673 
   - endDate
2674 
  """
2675 
 
2676 
  thrift_spec = (
2677 
    None, # 0
2678 
    (1, TType.I64, 'startDate', None, None, ), # 1
2679 
    (2, TType.I64, 'endDate', None, None, ), # 2
2680 
  )
2681 
 
2682 
  def __init__(self, startDate=None, endDate=None,):
2683 
    self.startDate = startDate
2684 
    self.endDate = endDate
2685 
 
2686 
  def read(self, iprot):
2687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2689 
      return
2690 
    iprot.readStructBegin()
2691 
    while True:
2692 
      (fname, ftype, fid) = iprot.readFieldBegin()
2693 
      if ftype == TType.STOP:
2694 
        break
2695 
      if fid == 1:
2696 
        if ftype == TType.I64:
2697 
          self.startDate = iprot.readI64();
2698 
        else:
2699 
          iprot.skip(ftype)
2700 
      elif fid == 2:
2701 
        if ftype == TType.I64:
2702 
          self.endDate = iprot.readI64();
2703 
        else:
2704 
          iprot.skip(ftype)
2705 
      else:
2706 
        iprot.skip(ftype)
2707 
      iprot.readFieldEnd()
2708 
    iprot.readStructEnd()
2709 
 
2710 
  def write(self, oprot):
2711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2713 
      return
2714 
    oprot.writeStructBegin('getPurchaseScans_args')
2715 
    if self.startDate is not None:
2716 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
2717 
      oprot.writeI64(self.startDate)
2718 
      oprot.writeFieldEnd()
2719 
    if self.endDate is not None:
2720 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
2721 
      oprot.writeI64(self.endDate)
2722 
      oprot.writeFieldEnd()
2723 
    oprot.writeFieldStop()
2724 
    oprot.writeStructEnd()
2725 
 
2726 
  def validate(self):
2727 
    return
2728 
 
2729 
 
2730 
  def __repr__(self):
2731 
    L = ['%s=%r' % (key, value)
2732 
      for key, value in self.__dict__.iteritems()]
2733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2734 
 
2735 
  def __eq__(self, other):
2736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2737 
 
2738 
  def __ne__(self, other):
2739 
    return not (self == other)
2740 
 
2741 
class getPurchaseScans_result:
2742 
  """
2743 
  Attributes:
2744 
   - success
2745 
  """
2746 
 
2747 
  thrift_spec = (
2748 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
2749 
  )
2750 
 
2751 
  def __init__(self, success=None,):
2752 
    self.success = success
2753 
 
2754 
  def read(self, iprot):
2755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2757 
      return
2758 
    iprot.readStructBegin()
2759 
    while True:
2760 
      (fname, ftype, fid) = iprot.readFieldBegin()
2761 
      if ftype == TType.STOP:
2762 
        break
2763 
      if fid == 0:
2764 
        if ftype == TType.LIST:
2765 
          self.success = []
2766 
          (_etype24, _size21) = iprot.readListBegin()
2767 
          for _i25 in xrange(_size21):
2768 
            _elem26 = DetailedPurchaseScan()
2769 
            _elem26.read(iprot)
2770 
            self.success.append(_elem26)
2771 
          iprot.readListEnd()
2772 
        else:
2773 
          iprot.skip(ftype)
2774 
      else:
2775 
        iprot.skip(ftype)
2776 
      iprot.readFieldEnd()
2777 
    iprot.readStructEnd()
2778 
 
2779 
  def write(self, oprot):
2780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2782 
      return
2783 
    oprot.writeStructBegin('getPurchaseScans_result')
2784 
    if self.success is not None:
2785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2787 
      for iter27 in self.success:
2788 
        iter27.write(oprot)
2789 
      oprot.writeListEnd()
2790 
      oprot.writeFieldEnd()
2791 
    oprot.writeFieldStop()
2792 
    oprot.writeStructEnd()
2793 
 
2794 
  def validate(self):
2795 
    return
2796 
 
2797 
 
2798 
  def __repr__(self):
2799 
    L = ['%s=%r' % (key, value)
2800 
      for key, value in self.__dict__.iteritems()]
2801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2802 
 
2803 
  def __eq__(self, other):
2804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2805 
 
2806 
  def __ne__(self, other):
2807 
    return not (self == other)
5496 mandeep.dh 2808 
 
2809 
class fetchScansPerInvoiceNumber_args:
2810 
  """
2811 
  Attributes:
2812 
   - date
2813 
  """
2814 
 
2815 
  thrift_spec = (
2816 
    None, # 0
2817 
    (1, TType.I64, 'date', None, None, ), # 1
2818 
  )
2819 
 
2820 
  def __init__(self, date=None,):
2821 
    self.date = date
2822 
 
2823 
  def read(self, iprot):
2824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2826 
      return
2827 
    iprot.readStructBegin()
2828 
    while True:
2829 
      (fname, ftype, fid) = iprot.readFieldBegin()
2830 
      if ftype == TType.STOP:
2831 
        break
2832 
      if fid == 1:
2833 
        if ftype == TType.I64:
2834 
          self.date = iprot.readI64();
2835 
        else:
2836 
          iprot.skip(ftype)
2837 
      else:
2838 
        iprot.skip(ftype)
2839 
      iprot.readFieldEnd()
2840 
    iprot.readStructEnd()
2841 
 
2842 
  def write(self, oprot):
2843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2845 
      return
2846 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_args')
2847 
    if self.date is not None:
2848 
      oprot.writeFieldBegin('date', TType.I64, 1)
2849 
      oprot.writeI64(self.date)
2850 
      oprot.writeFieldEnd()
2851 
    oprot.writeFieldStop()
2852 
    oprot.writeStructEnd()
2853 
 
2854 
  def validate(self):
2855 
    return
2856 
 
2857 
 
2858 
  def __repr__(self):
2859 
    L = ['%s=%r' % (key, value)
2860 
      for key, value in self.__dict__.iteritems()]
2861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2862 
 
2863 
  def __eq__(self, other):
2864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2865 
 
2866 
  def __ne__(self, other):
2867 
    return not (self == other)
2868 
 
2869 
class fetchScansPerInvoiceNumber_result:
2870 
  """
2871 
  Attributes:
2872 
   - success
2873 
  """
2874 
 
2875 
  thrift_spec = (
2876 
    (0, TType.LIST, 'success', (TType.STRUCT,(InvoiceScan, InvoiceScan.thrift_spec)), None, ), # 0
2877 
  )
2878 
 
2879 
  def __init__(self, success=None,):
2880 
    self.success = success
2881 
 
2882 
  def read(self, iprot):
2883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2885 
      return
2886 
    iprot.readStructBegin()
2887 
    while True:
2888 
      (fname, ftype, fid) = iprot.readFieldBegin()
2889 
      if ftype == TType.STOP:
2890 
        break
2891 
      if fid == 0:
2892 
        if ftype == TType.LIST:
2893 
          self.success = []
2894 
          (_etype31, _size28) = iprot.readListBegin()
2895 
          for _i32 in xrange(_size28):
2896 
            _elem33 = InvoiceScan()
2897 
            _elem33.read(iprot)
2898 
            self.success.append(_elem33)
2899 
          iprot.readListEnd()
2900 
        else:
2901 
          iprot.skip(ftype)
2902 
      else:
2903 
        iprot.skip(ftype)
2904 
      iprot.readFieldEnd()
2905 
    iprot.readStructEnd()
2906 
 
2907 
  def write(self, oprot):
2908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2910 
      return
2911 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_result')
2912 
    if self.success is not None:
2913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2915 
      for iter34 in self.success:
2916 
        iter34.write(oprot)
2917 
      oprot.writeListEnd()
2918 
      oprot.writeFieldEnd()
2919 
    oprot.writeFieldStop()
2920 
    oprot.writeStructEnd()
2921 
 
2922 
  def validate(self):
2923 
    return
2924 
 
2925 
 
2926 
  def __repr__(self):
2927 
    L = ['%s=%r' % (key, value)
2928 
      for key, value in self.__dict__.iteritems()]
2929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2930 
 
2931 
  def __eq__(self, other):
2932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2933 
 
2934 
  def __ne__(self, other):
2935 
    return not (self == other)
5620 mandeep.dh 2936 
 
2937 
class getInventoryItemFromOrder_args:
2938 
  """
2939 
  Attributes:
2940 
   - orderId
2941 
  """
2942 
 
2943 
  thrift_spec = (
2944 
    None, # 0
2945 
    (1, TType.I64, 'orderId', None, None, ), # 1
2946 
  )
2947 
 
2948 
  def __init__(self, orderId=None,):
2949 
    self.orderId = orderId
2950 
 
2951 
  def read(self, iprot):
2952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2954 
      return
2955 
    iprot.readStructBegin()
2956 
    while True:
2957 
      (fname, ftype, fid) = iprot.readFieldBegin()
2958 
      if ftype == TType.STOP:
2959 
        break
2960 
      if fid == 1:
2961 
        if ftype == TType.I64:
2962 
          self.orderId = iprot.readI64();
2963 
        else:
2964 
          iprot.skip(ftype)
2965 
      else:
2966 
        iprot.skip(ftype)
2967 
      iprot.readFieldEnd()
2968 
    iprot.readStructEnd()
2969 
 
2970 
  def write(self, oprot):
2971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2973 
      return
2974 
    oprot.writeStructBegin('getInventoryItemFromOrder_args')
2975 
    if self.orderId is not None:
2976 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
2977 
      oprot.writeI64(self.orderId)
2978 
      oprot.writeFieldEnd()
2979 
    oprot.writeFieldStop()
2980 
    oprot.writeStructEnd()
2981 
 
2982 
  def validate(self):
2983 
    return
2984 
 
2985 
 
2986 
  def __repr__(self):
2987 
    L = ['%s=%r' % (key, value)
2988 
      for key, value in self.__dict__.iteritems()]
2989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2990 
 
2991 
  def __eq__(self, other):
2992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2993 
 
2994 
  def __ne__(self, other):
2995 
    return not (self == other)
2996 
 
2997 
class getInventoryItemFromOrder_result:
2998 
  """
2999 
  Attributes:
3000 
   - success
3001 
   - we
3002 
  """
3003 
 
3004 
  thrift_spec = (
3005 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3006 
    (1, TType.STRUCT, 'we', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3007 
  )
3008 
 
3009 
  def __init__(self, success=None, we=None,):
3010 
    self.success = success
3011 
    self.we = we
3012 
 
3013 
  def read(self, iprot):
3014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3016 
      return
3017 
    iprot.readStructBegin()
3018 
    while True:
3019 
      (fname, ftype, fid) = iprot.readFieldBegin()
3020 
      if ftype == TType.STOP:
3021 
        break
3022 
      if fid == 0:
3023 
        if ftype == TType.STRUCT:
3024 
          self.success = InventoryItem()
3025 
          self.success.read(iprot)
3026 
        else:
3027 
          iprot.skip(ftype)
3028 
      elif fid == 1:
3029 
        if ftype == TType.STRUCT:
3030 
          self.we = WarehouseServiceException()
3031 
          self.we.read(iprot)
3032 
        else:
3033 
          iprot.skip(ftype)
3034 
      else:
3035 
        iprot.skip(ftype)
3036 
      iprot.readFieldEnd()
3037 
    iprot.readStructEnd()
3038 
 
3039 
  def write(self, oprot):
3040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3042 
      return
3043 
    oprot.writeStructBegin('getInventoryItemFromOrder_result')
3044 
    if self.success is not None:
3045 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3046 
      self.success.write(oprot)
3047 
      oprot.writeFieldEnd()
3048 
    if self.we is not None:
3049 
      oprot.writeFieldBegin('we', TType.STRUCT, 1)
3050 
      self.we.write(oprot)
3051 
      oprot.writeFieldEnd()
3052 
    oprot.writeFieldStop()
3053 
    oprot.writeStructEnd()
3054 
 
3055 
  def validate(self):
3056 
    return
3057 
 
3058 
 
3059 
  def __repr__(self):
3060 
    L = ['%s=%r' % (key, value)
3061 
      for key, value in self.__dict__.iteritems()]
3062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3063 
 
3064 
  def __eq__(self, other):
3065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3066 
 
3067 
  def __ne__(self, other):
3068 
    return not (self == other)
5711 mandeep.dh 3069 
 
3070 
class getInventoryAge_args:
3071 
 
3072 
  thrift_spec = (
3073 
  )
3074 
 
3075 
  def read(self, iprot):
3076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3078 
      return
3079 
    iprot.readStructBegin()
3080 
    while True:
3081 
      (fname, ftype, fid) = iprot.readFieldBegin()
3082 
      if ftype == TType.STOP:
3083 
        break
3084 
      else:
3085 
        iprot.skip(ftype)
3086 
      iprot.readFieldEnd()
3087 
    iprot.readStructEnd()
3088 
 
3089 
  def write(self, oprot):
3090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3092 
      return
3093 
    oprot.writeStructBegin('getInventoryAge_args')
3094 
    oprot.writeFieldStop()
3095 
    oprot.writeStructEnd()
3096 
 
3097 
  def validate(self):
3098 
    return
3099 
 
3100 
 
3101 
  def __repr__(self):
3102 
    L = ['%s=%r' % (key, value)
3103 
      for key, value in self.__dict__.iteritems()]
3104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3105 
 
3106 
  def __eq__(self, other):
3107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3108 
 
3109 
  def __ne__(self, other):
3110 
    return not (self == other)
3111 
 
3112 
class getInventoryAge_result:
3113 
  """
3114 
  Attributes:
3115 
   - success
3116 
  """
3117 
 
3118 
  thrift_spec = (
3119 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAge, InventoryAge.thrift_spec)), None, ), # 0
3120 
  )
3121 
 
3122 
  def __init__(self, success=None,):
3123 
    self.success = success
3124 
 
3125 
  def read(self, iprot):
3126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3128 
      return
3129 
    iprot.readStructBegin()
3130 
    while True:
3131 
      (fname, ftype, fid) = iprot.readFieldBegin()
3132 
      if ftype == TType.STOP:
3133 
        break
3134 
      if fid == 0:
3135 
        if ftype == TType.LIST:
3136 
          self.success = []
3137 
          (_etype38, _size35) = iprot.readListBegin()
3138 
          for _i39 in xrange(_size35):
3139 
            _elem40 = InventoryAge()
3140 
            _elem40.read(iprot)
3141 
            self.success.append(_elem40)
3142 
          iprot.readListEnd()
3143 
        else:
3144 
          iprot.skip(ftype)
3145 
      else:
3146 
        iprot.skip(ftype)
3147 
      iprot.readFieldEnd()
3148 
    iprot.readStructEnd()
3149 
 
3150 
  def write(self, oprot):
3151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3153 
      return
3154 
    oprot.writeStructBegin('getInventoryAge_result')
3155 
    if self.success is not None:
3156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3158 
      for iter41 in self.success:
3159 
        iter41.write(oprot)
3160 
      oprot.writeListEnd()
3161 
      oprot.writeFieldEnd()
3162 
    oprot.writeFieldStop()
3163 
    oprot.writeStructEnd()
3164 
 
3165 
  def validate(self):
3166 
    return
3167 
 
3168 
 
3169 
  def __repr__(self):
3170 
    L = ['%s=%r' % (key, value)
3171 
      for key, value in self.__dict__.iteritems()]
3172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3173 
 
3174 
  def __eq__(self, other):
3175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3176 
 
3177 
  def __ne__(self, other):
3178 
    return not (self == other)
6361 rajveer 3179 
 
3180 
class getInventoryScansForItem_args:
3181 
  """
3182 
  Attributes:
3183 
   - itemId
3184 
   - fromDate
3185 
   - toDate
3186 
  """
3187 
 
3188 
  thrift_spec = (
3189 
    None, # 0
3190 
    (1, TType.I64, 'itemId', None, None, ), # 1
3191 
    (2, TType.I64, 'fromDate', None, None, ), # 2
3192 
    (3, TType.I64, 'toDate', None, None, ), # 3
3193 
  )
3194 
 
3195 
  def __init__(self, itemId=None, fromDate=None, toDate=None,):
3196 
    self.itemId = itemId
3197 
    self.fromDate = fromDate
3198 
    self.toDate = toDate
3199 
 
3200 
  def read(self, iprot):
3201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3203 
      return
3204 
    iprot.readStructBegin()
3205 
    while True:
3206 
      (fname, ftype, fid) = iprot.readFieldBegin()
3207 
      if ftype == TType.STOP:
3208 
        break
3209 
      if fid == 1:
3210 
        if ftype == TType.I64:
3211 
          self.itemId = iprot.readI64();
3212 
        else:
3213 
          iprot.skip(ftype)
3214 
      elif fid == 2:
3215 
        if ftype == TType.I64:
3216 
          self.fromDate = iprot.readI64();
3217 
        else:
3218 
          iprot.skip(ftype)
3219 
      elif fid == 3:
3220 
        if ftype == TType.I64:
3221 
          self.toDate = iprot.readI64();
3222 
        else:
3223 
          iprot.skip(ftype)
3224 
      else:
3225 
        iprot.skip(ftype)
3226 
      iprot.readFieldEnd()
3227 
    iprot.readStructEnd()
3228 
 
3229 
  def write(self, oprot):
3230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3232 
      return
3233 
    oprot.writeStructBegin('getInventoryScansForItem_args')
3234 
    if self.itemId is not None:
3235 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
3236 
      oprot.writeI64(self.itemId)
3237 
      oprot.writeFieldEnd()
3238 
    if self.fromDate is not None:
3239 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
3240 
      oprot.writeI64(self.fromDate)
3241 
      oprot.writeFieldEnd()
3242 
    if self.toDate is not None:
3243 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
3244 
      oprot.writeI64(self.toDate)
3245 
      oprot.writeFieldEnd()
3246 
    oprot.writeFieldStop()
3247 
    oprot.writeStructEnd()
3248 
 
3249 
  def validate(self):
3250 
    return
3251 
 
3252 
 
3253 
  def __repr__(self):
3254 
    L = ['%s=%r' % (key, value)
3255 
      for key, value in self.__dict__.iteritems()]
3256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3257 
 
3258 
  def __eq__(self, other):
3259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3260 
 
3261 
  def __ne__(self, other):
3262 
    return not (self == other)
3263 
 
3264 
class getInventoryScansForItem_result:
3265 
  """
3266 
  Attributes:
3267 
   - success
3268 
  """
3269 
 
3270 
  thrift_spec = (
3271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
3272 
  )
3273 
 
3274 
  def __init__(self, success=None,):
3275 
    self.success = success
3276 
 
3277 
  def read(self, iprot):
3278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3280 
      return
3281 
    iprot.readStructBegin()
3282 
    while True:
3283 
      (fname, ftype, fid) = iprot.readFieldBegin()
3284 
      if ftype == TType.STOP:
3285 
        break
3286 
      if fid == 0:
3287 
        if ftype == TType.LIST:
3288 
          self.success = []
3289 
          (_etype45, _size42) = iprot.readListBegin()
3290 
          for _i46 in xrange(_size42):
3291 
            _elem47 = Scan()
3292 
            _elem47.read(iprot)
3293 
            self.success.append(_elem47)
3294 
          iprot.readListEnd()
3295 
        else:
3296 
          iprot.skip(ftype)
3297 
      else:
3298 
        iprot.skip(ftype)
3299 
      iprot.readFieldEnd()
3300 
    iprot.readStructEnd()
3301 
 
3302 
  def write(self, oprot):
3303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3305 
      return
3306 
    oprot.writeStructBegin('getInventoryScansForItem_result')
3307 
    if self.success is not None:
3308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3310 
      for iter48 in self.success:
3311 
        iter48.write(oprot)
3312 
      oprot.writeListEnd()
3313 
      oprot.writeFieldEnd()
3314 
    oprot.writeFieldStop()
3315 
    oprot.writeStructEnd()
3316 
 
3317 
  def validate(self):
3318 
    return
3319 
 
3320 
 
3321 
  def __repr__(self):
3322 
    L = ['%s=%r' % (key, value)
3323 
      for key, value in self.__dict__.iteritems()]
3324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3325 
 
3326 
  def __eq__(self, other):
3327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3328 
 
3329 
  def __ne__(self, other):
3330 
    return not (self == other)
3331 
 
3332 
class getScanRecordsForSerialNumber_args:
3333 
  """
3334 
  Attributes:
3335 
   - serialNumber
3336 
  """
3337 
 
3338 
  thrift_spec = (
3339 
    None, # 0
3340 
    (1, TType.I64, 'serialNumber', None, None, ), # 1
3341 
  )
3342 
 
3343 
  def __init__(self, serialNumber=None,):
3344 
    self.serialNumber = serialNumber
3345 
 
3346 
  def read(self, iprot):
3347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3349 
      return
3350 
    iprot.readStructBegin()
3351 
    while True:
3352 
      (fname, ftype, fid) = iprot.readFieldBegin()
3353 
      if ftype == TType.STOP:
3354 
        break
3355 
      if fid == 1:
3356 
        if ftype == TType.I64:
3357 
          self.serialNumber = iprot.readI64();
3358 
        else:
3359 
          iprot.skip(ftype)
3360 
      else:
3361 
        iprot.skip(ftype)
3362 
      iprot.readFieldEnd()
3363 
    iprot.readStructEnd()
3364 
 
3365 
  def write(self, oprot):
3366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3368 
      return
3369 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_args')
3370 
    if self.serialNumber is not None:
3371 
      oprot.writeFieldBegin('serialNumber', TType.I64, 1)
3372 
      oprot.writeI64(self.serialNumber)
3373 
      oprot.writeFieldEnd()
3374 
    oprot.writeFieldStop()
3375 
    oprot.writeStructEnd()
3376 
 
3377 
  def validate(self):
3378 
    return
3379 
 
3380 
 
3381 
  def __repr__(self):
3382 
    L = ['%s=%r' % (key, value)
3383 
      for key, value in self.__dict__.iteritems()]
3384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3385 
 
3386 
  def __eq__(self, other):
3387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3388 
 
3389 
  def __ne__(self, other):
3390 
    return not (self == other)
3391 
 
3392 
class getScanRecordsForSerialNumber_result:
3393 
  """
3394 
  Attributes:
3395 
   - success
3396 
  """
3397 
 
3398 
  thrift_spec = (
3399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
3400 
  )
3401 
 
3402 
  def __init__(self, success=None,):
3403 
    self.success = success
3404 
 
3405 
  def read(self, iprot):
3406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3408 
      return
3409 
    iprot.readStructBegin()
3410 
    while True:
3411 
      (fname, ftype, fid) = iprot.readFieldBegin()
3412 
      if ftype == TType.STOP:
3413 
        break
3414 
      if fid == 0:
3415 
        if ftype == TType.LIST:
3416 
          self.success = []
3417 
          (_etype52, _size49) = iprot.readListBegin()
3418 
          for _i53 in xrange(_size49):
3419 
            _elem54 = Scan()
3420 
            _elem54.read(iprot)
3421 
            self.success.append(_elem54)
3422 
          iprot.readListEnd()
3423 
        else:
3424 
          iprot.skip(ftype)
3425 
      else:
3426 
        iprot.skip(ftype)
3427 
      iprot.readFieldEnd()
3428 
    iprot.readStructEnd()
3429 
 
3430 
  def write(self, oprot):
3431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3433 
      return
3434 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_result')
3435 
    if self.success is not None:
3436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3438 
      for iter55 in self.success:
3439 
        iter55.write(oprot)
3440 
      oprot.writeListEnd()
3441 
      oprot.writeFieldEnd()
3442 
    oprot.writeFieldStop()
3443 
    oprot.writeStructEnd()
3444 
 
3445 
  def validate(self):
3446 
    return
3447 
 
3448 
 
3449 
  def __repr__(self):
3450 
    L = ['%s=%r' % (key, value)
3451 
      for key, value in self.__dict__.iteritems()]
3452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3453 
 
3454 
  def __eq__(self, other):
3455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3456 
 
3457 
  def __ne__(self, other):
3458 
    return not (self == other)
6467 amar.kumar 3459 
 
3460 
class scanForPurchaseReturn_args:
3461 
  """
3462 
  Attributes:
3463 
   - saleReturnItems
3464 
   - vendorId
3465 
  """
3466 
 
3467 
  thrift_spec = (
3468 
    None, # 0
3469 
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
3470 
    (2, TType.I64, 'vendorId', None, None, ), # 2
3471 
  )
3472 
 
3473 
  def __init__(self, saleReturnItems=None, vendorId=None,):
3474 
    self.saleReturnItems = saleReturnItems
3475 
    self.vendorId = vendorId
3476 
 
3477 
  def read(self, iprot):
3478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3480 
      return
3481 
    iprot.readStructBegin()
3482 
    while True:
3483 
      (fname, ftype, fid) = iprot.readFieldBegin()
3484 
      if ftype == TType.STOP:
3485 
        break
3486 
      if fid == 1:
3487 
        if ftype == TType.LIST:
3488 
          self.saleReturnItems = []
3489 
          (_etype59, _size56) = iprot.readListBegin()
3490 
          for _i60 in xrange(_size56):
3491 
            _elem61 = InventoryItem()
3492 
            _elem61.read(iprot)
3493 
            self.saleReturnItems.append(_elem61)
3494 
          iprot.readListEnd()
3495 
        else:
3496 
          iprot.skip(ftype)
3497 
      elif fid == 2:
3498 
        if ftype == TType.I64:
3499 
          self.vendorId = iprot.readI64();
3500 
        else:
3501 
          iprot.skip(ftype)
3502 
      else:
3503 
        iprot.skip(ftype)
3504 
      iprot.readFieldEnd()
3505 
    iprot.readStructEnd()
3506 
 
3507 
  def write(self, oprot):
3508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3510 
      return
3511 
    oprot.writeStructBegin('scanForPurchaseReturn_args')
3512 
    if self.saleReturnItems is not None:
3513 
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
3514 
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
3515 
      for iter62 in self.saleReturnItems:
3516 
        iter62.write(oprot)
3517 
      oprot.writeListEnd()
3518 
      oprot.writeFieldEnd()
3519 
    if self.vendorId is not None:
3520 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
3521 
      oprot.writeI64(self.vendorId)
3522 
      oprot.writeFieldEnd()
3523 
    oprot.writeFieldStop()
3524 
    oprot.writeStructEnd()
3525 
 
3526 
  def validate(self):
3527 
    return
3528 
 
3529 
 
3530 
  def __repr__(self):
3531 
    L = ['%s=%r' % (key, value)
3532 
      for key, value in self.__dict__.iteritems()]
3533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3534 
 
3535 
  def __eq__(self, other):
3536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3537 
 
3538 
  def __ne__(self, other):
3539 
    return not (self == other)
3540 
 
3541 
class scanForPurchaseReturn_result:
3542 
  """
3543 
  Attributes:
3544 
   - ex
3545 
  """
3546 
 
3547 
  thrift_spec = (
3548 
    None, # 0
3549 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3550 
  )
3551 
 
3552 
  def __init__(self, ex=None,):
3553 
    self.ex = ex
3554 
 
3555 
  def read(self, iprot):
3556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3558 
      return
3559 
    iprot.readStructBegin()
3560 
    while True:
3561 
      (fname, ftype, fid) = iprot.readFieldBegin()
3562 
      if ftype == TType.STOP:
3563 
        break
3564 
      if fid == 1:
3565 
        if ftype == TType.STRUCT:
3566 
          self.ex = WarehouseServiceException()
3567 
          self.ex.read(iprot)
3568 
        else:
3569 
          iprot.skip(ftype)
3570 
      else:
3571 
        iprot.skip(ftype)
3572 
      iprot.readFieldEnd()
3573 
    iprot.readStructEnd()
3574 
 
3575 
  def write(self, oprot):
3576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3578 
      return
3579 
    oprot.writeStructBegin('scanForPurchaseReturn_result')
3580 
    if self.ex is not None:
3581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3582 
      self.ex.write(oprot)
3583 
      oprot.writeFieldEnd()
3584 
    oprot.writeFieldStop()
3585 
    oprot.writeStructEnd()
3586 
 
3587 
  def validate(self):
3588 
    return
3589 
 
3590 
 
3591 
  def __repr__(self):
3592 
    L = ['%s=%r' % (key, value)
3593 
      for key, value in self.__dict__.iteritems()]
3594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3595 
 
3596 
  def __eq__(self, other):
3597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3598 
 
3599 
  def __ne__(self, other):
3600 
    return not (self == other)
6630 amar.kumar 3601 
 
3602 
class scanForLostItem_args:
3603 
  """
3604 
  Attributes:
3605 
   - lostItems
3606 
   - vendorId
3607 
  """
3608 
 
3609 
  thrift_spec = (
3610 
    None, # 0
3611 
    (1, TType.LIST, 'lostItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
3612 
    (2, TType.I64, 'vendorId', None, None, ), # 2
3613 
  )
3614 
 
3615 
  def __init__(self, lostItems=None, vendorId=None,):
3616 
    self.lostItems = lostItems
3617 
    self.vendorId = vendorId
3618 
 
3619 
  def read(self, iprot):
3620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3622 
      return
3623 
    iprot.readStructBegin()
3624 
    while True:
3625 
      (fname, ftype, fid) = iprot.readFieldBegin()
3626 
      if ftype == TType.STOP:
3627 
        break
3628 
      if fid == 1:
3629 
        if ftype == TType.LIST:
3630 
          self.lostItems = []
3631 
          (_etype66, _size63) = iprot.readListBegin()
3632 
          for _i67 in xrange(_size63):
3633 
            _elem68 = InventoryItem()
3634 
            _elem68.read(iprot)
3635 
            self.lostItems.append(_elem68)
3636 
          iprot.readListEnd()
3637 
        else:
3638 
          iprot.skip(ftype)
3639 
      elif fid == 2:
3640 
        if ftype == TType.I64:
3641 
          self.vendorId = iprot.readI64();
3642 
        else:
3643 
          iprot.skip(ftype)
3644 
      else:
3645 
        iprot.skip(ftype)
3646 
      iprot.readFieldEnd()
3647 
    iprot.readStructEnd()
3648 
 
3649 
  def write(self, oprot):
3650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3652 
      return
3653 
    oprot.writeStructBegin('scanForLostItem_args')
3654 
    if self.lostItems is not None:
3655 
      oprot.writeFieldBegin('lostItems', TType.LIST, 1)
3656 
      oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
3657 
      for iter69 in self.lostItems:
3658 
        iter69.write(oprot)
3659 
      oprot.writeListEnd()
3660 
      oprot.writeFieldEnd()
3661 
    if self.vendorId is not None:
3662 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
3663 
      oprot.writeI64(self.vendorId)
3664 
      oprot.writeFieldEnd()
3665 
    oprot.writeFieldStop()
3666 
    oprot.writeStructEnd()
3667 
 
3668 
  def validate(self):
3669 
    return
3670 
 
3671 
 
3672 
  def __repr__(self):
3673 
    L = ['%s=%r' % (key, value)
3674 
      for key, value in self.__dict__.iteritems()]
3675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3676 
 
3677 
  def __eq__(self, other):
3678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3679 
 
3680 
  def __ne__(self, other):
3681 
    return not (self == other)
3682 
 
3683 
class scanForLostItem_result:
3684 
  """
3685 
  Attributes:
3686 
   - ex
3687 
  """
3688 
 
3689 
  thrift_spec = (
3690 
    None, # 0
3691 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3692 
  )
3693 
 
3694 
  def __init__(self, ex=None,):
3695 
    self.ex = ex
3696 
 
3697 
  def read(self, iprot):
3698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3700 
      return
3701 
    iprot.readStructBegin()
3702 
    while True:
3703 
      (fname, ftype, fid) = iprot.readFieldBegin()
3704 
      if ftype == TType.STOP:
3705 
        break
3706 
      if fid == 1:
3707 
        if ftype == TType.STRUCT:
3708 
          self.ex = WarehouseServiceException()
3709 
          self.ex.read(iprot)
3710 
        else:
3711 
          iprot.skip(ftype)
3712 
      else:
3713 
        iprot.skip(ftype)
3714 
      iprot.readFieldEnd()
3715 
    iprot.readStructEnd()
3716 
 
3717 
  def write(self, oprot):
3718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3720 
      return
3721 
    oprot.writeStructBegin('scanForLostItem_result')
3722 
    if self.ex is not None:
3723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3724 
      self.ex.write(oprot)
3725 
      oprot.writeFieldEnd()
3726 
    oprot.writeFieldStop()
3727 
    oprot.writeStructEnd()
3728 
 
3729 
  def validate(self):
3730 
    return
3731 
 
3732 
 
3733 
  def __repr__(self):
3734 
    L = ['%s=%r' % (key, value)
3735 
      for key, value in self.__dict__.iteritems()]
3736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3737 
 
3738 
  def __eq__(self, other):
3739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3740 
 
3741 
  def __ne__(self, other):
3742 
    return not (self == other)
3743 
 
3744 
class getCurrentSerializedInventoryByScans_args:
3745 
 
3746 
  thrift_spec = (
3747 
  )
3748 
 
3749 
  def read(self, iprot):
3750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3752 
      return
3753 
    iprot.readStructBegin()
3754 
    while True:
3755 
      (fname, ftype, fid) = iprot.readFieldBegin()
3756 
      if ftype == TType.STOP:
3757 
        break
3758 
      else:
3759 
        iprot.skip(ftype)
3760 
      iprot.readFieldEnd()
3761 
    iprot.readStructEnd()
3762 
 
3763 
  def write(self, oprot):
3764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3766 
      return
3767 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_args')
3768 
    oprot.writeFieldStop()
3769 
    oprot.writeStructEnd()
3770 
 
3771 
  def validate(self):
3772 
    return
3773 
 
3774 
 
3775 
  def __repr__(self):
3776 
    L = ['%s=%r' % (key, value)
3777 
      for key, value in self.__dict__.iteritems()]
3778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3779 
 
3780 
  def __eq__(self, other):
3781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3782 
 
3783 
  def __ne__(self, other):
3784 
    return not (self == other)
3785 
 
3786 
class getCurrentSerializedInventoryByScans_result:
3787 
  """
3788 
  Attributes:
3789 
   - success
3790 
  """
3791 
 
3792 
  thrift_spec = (
3793 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
3794 
  )
3795 
 
3796 
  def __init__(self, success=None,):
3797 
    self.success = success
3798 
 
3799 
  def read(self, iprot):
3800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3802 
      return
3803 
    iprot.readStructBegin()
3804 
    while True:
3805 
      (fname, ftype, fid) = iprot.readFieldBegin()
3806 
      if ftype == TType.STOP:
3807 
        break
3808 
      if fid == 0:
3809 
        if ftype == TType.LIST:
3810 
          self.success = []
3811 
          (_etype73, _size70) = iprot.readListBegin()
3812 
          for _i74 in xrange(_size70):
3813 
            _elem75 = InventoryAvailability()
3814 
            _elem75.read(iprot)
3815 
            self.success.append(_elem75)
3816 
          iprot.readListEnd()
3817 
        else:
3818 
          iprot.skip(ftype)
3819 
      else:
3820 
        iprot.skip(ftype)
3821 
      iprot.readFieldEnd()
3822 
    iprot.readStructEnd()
3823 
 
3824 
  def write(self, oprot):
3825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3827 
      return
3828 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_result')
3829 
    if self.success is not None:
3830 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3831 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3832 
      for iter76 in self.success:
3833 
        iter76.write(oprot)
3834 
      oprot.writeListEnd()
3835 
      oprot.writeFieldEnd()
3836 
    oprot.writeFieldStop()
3837 
    oprot.writeStructEnd()
3838 
 
3839 
  def validate(self):
3840 
    return
3841 
 
3842 
 
3843 
  def __repr__(self):
3844 
    L = ['%s=%r' % (key, value)
3845 
      for key, value in self.__dict__.iteritems()]
3846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3847 
 
3848 
  def __eq__(self, other):
3849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3850 
 
3851 
  def __ne__(self, other):
3852 
    return not (self == other)
3853 
 
3854 
class getCurrentNonSerializedInventoryByScans_args:
3855 
 
3856 
  thrift_spec = (
3857 
  )
3858 
 
3859 
  def read(self, iprot):
3860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3862 
      return
3863 
    iprot.readStructBegin()
3864 
    while True:
3865 
      (fname, ftype, fid) = iprot.readFieldBegin()
3866 
      if ftype == TType.STOP:
3867 
        break
3868 
      else:
3869 
        iprot.skip(ftype)
3870 
      iprot.readFieldEnd()
3871 
    iprot.readStructEnd()
3872 
 
3873 
  def write(self, oprot):
3874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3876 
      return
3877 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_args')
3878 
    oprot.writeFieldStop()
3879 
    oprot.writeStructEnd()
3880 
 
3881 
  def validate(self):
3882 
    return
3883 
 
3884 
 
3885 
  def __repr__(self):
3886 
    L = ['%s=%r' % (key, value)
3887 
      for key, value in self.__dict__.iteritems()]
3888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3889 
 
3890 
  def __eq__(self, other):
3891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3892 
 
3893 
  def __ne__(self, other):
3894 
    return not (self == other)
3895 
 
3896 
class getCurrentNonSerializedInventoryByScans_result:
3897 
  """
3898 
  Attributes:
3899 
   - success
3900 
  """
3901 
 
3902 
  thrift_spec = (
3903 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
3904 
  )
3905 
 
3906 
  def __init__(self, success=None,):
3907 
    self.success = success
3908 
 
3909 
  def read(self, iprot):
3910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3912 
      return
3913 
    iprot.readStructBegin()
3914 
    while True:
3915 
      (fname, ftype, fid) = iprot.readFieldBegin()
3916 
      if ftype == TType.STOP:
3917 
        break
3918 
      if fid == 0:
3919 
        if ftype == TType.LIST:
3920 
          self.success = []
3921 
          (_etype80, _size77) = iprot.readListBegin()
3922 
          for _i81 in xrange(_size77):
3923 
            _elem82 = InventoryAvailability()
3924 
            _elem82.read(iprot)
3925 
            self.success.append(_elem82)
3926 
          iprot.readListEnd()
3927 
        else:
3928 
          iprot.skip(ftype)
3929 
      else:
3930 
        iprot.skip(ftype)
3931 
      iprot.readFieldEnd()
3932 
    iprot.readStructEnd()
3933 
 
3934 
  def write(self, oprot):
3935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3937 
      return
3938 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_result')
3939 
    if self.success is not None:
3940 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3941 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3942 
      for iter83 in self.success:
3943 
        iter83.write(oprot)
3944 
      oprot.writeListEnd()
3945 
      oprot.writeFieldEnd()
3946 
    oprot.writeFieldStop()
3947 
    oprot.writeStructEnd()
3948 
 
3949 
  def validate(self):
3950 
    return
3951 
 
3952 
 
3953 
  def __repr__(self):
3954 
    L = ['%s=%r' % (key, value)
3955 
      for key, value in self.__dict__.iteritems()]
3956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3957 
 
3958 
  def __eq__(self, other):
3959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3960 
 
3961 
  def __ne__(self, other):
3962 
    return not (self == other)