Subversion Repositories SmartDukaan

Rev

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