Subversion Repositories SmartDukaan

Rev

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

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