Subversion Repositories SmartDukaan

Rev

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