Subversion Repositories SmartDukaan

Rev

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

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