Subversion Repositories SmartDukaan

Rev

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