Subversion Repositories SmartDukaan

Rev

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

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