Subversion Repositories SmartDukaan

Rev

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