Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
2821 chandransh 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
2821 chandransh 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
2821 chandransh 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
2821 chandransh 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
4501 mandeep.dh 20 
  def getInventoryItem(self, serialNumber):
2832 chandransh 21 
    """
4501 mandeep.dh 22 
    Retrieves serialized inventory item given a serial number
3431 rajveer 23 
 
2832 chandransh 24 
    Parameters:
4501 mandeep.dh 25 
     - serialNumber
2832 chandransh 26 
    """
27 
    pass
28 
 
5530 mandeep.dh 29 
  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
2821 chandransh 30 
    """
5361 mandeep.dh 31 
    Retrieves non-serialized inventory item from a given supplier
3431 rajveer 32 
 
2821 chandransh 33 
    Parameters:
5530 mandeep.dh 34 
     - itemNumber
4501 mandeep.dh 35 
     - itemId
5530 mandeep.dh 36 
     - fulfilmentWarehouseId
2821 chandransh 37 
    """
38 
    pass
39 
 
5361 mandeep.dh 40 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
2821 chandransh 41 
    """
4501 mandeep.dh 42 
    Scan non-serialized items.
3431 rajveer 43 
 
2821 chandransh 44 
    Parameters:
5361 mandeep.dh 45 
     - inventoryItem
2821 chandransh 46 
     - type
4501 mandeep.dh 47 
     - quantity
5361 mandeep.dh 48 
     - billingWarehouseId
2821 chandransh 49 
    """
50 
    pass
51 
 
5110 mandeep.dh 52 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 53 
    """
54 
    Scan serialized items linked with an order. Returns its price.
2821 chandransh 55 
 
4501 mandeep.dh 56 
    Parameters:
4555 mandeep.dh 57 
     - serialNumber
4501 mandeep.dh 58 
     - type
59 
     - orderId
5110 mandeep.dh 60 
     - fulfilmentWarehouseId
61 
     - quantity
62 
     - billingWarehouseId
4501 mandeep.dh 63 
    """
64 
    pass
65 
 
5361 mandeep.dh 66 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 67 
    """
68 
    Scan non-serialized items linked with an order.
69 
 
70 
    Parameters:
5361 mandeep.dh 71 
     - inventoryItem
4501 mandeep.dh 72 
     - type
73 
     - quantity
74 
     - orderId
5110 mandeep.dh 75 
     - fulfilmentWarehouseId
5361 mandeep.dh 76 
     - billingWarehouseId
4501 mandeep.dh 77 
    """
78 
    pass
79 
 
80 
  def createItemNumberMapping(self, itemNumber, itemId):
81 
    """
82 
    Created item number to item id mapping
83 
 
84 
    Parameters:
85 
     - itemNumber
86 
     - itemId
87 
    """
88 
    pass
89 
 
4620 amit.gupta 90 
  def getItemNumbers(self, itemId):
91 
    """
92 
    Get itemNumber mappings for itemId
4501 mandeep.dh 93 
 
4620 amit.gupta 94 
    Parameters:
95 
     - itemId
96 
    """
97 
    pass
98 
 
5110 mandeep.dh 99 
  def getItemIds(self, itemNumber):
100 
    """
101 
    Gets item ids for a given item number
4620 amit.gupta 102 
 
5110 mandeep.dh 103 
    Parameters:
104 
     - itemNumber
105 
    """
106 
    pass
107 
 
5185 mandeep.dh 108 
  def getInventoryItemsFromLastScanType(self, lastScanType):
109 
    """
110 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 111 
 
5185 mandeep.dh 112 
    Parameters:
113 
     - lastScanType
114 
    """
115 
    pass
116 
 
117 
  def getInventoryItemFromId(self, inventoryItemId):
118 
    """
119 
    Retrieves inventory item given a inventoryItem id
120 
 
121 
    Parameters:
122 
     - inventoryItemId
123 
    """
124 
    pass
125 
 
5372 mandeep.dh 126 
  def getPurchaseScans(self, startDate, endDate):
127 
    """
128 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 129 
 
5372 mandeep.dh 130 
    Parameters:
131 
     - startDate
132 
     - endDate
133 
    """
134 
    pass
135 
 
5496 mandeep.dh 136 
  def fetchScansPerInvoiceNumber(self, date):
137 
    """
138 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 139 
 
5496 mandeep.dh 140 
    Parameters:
141 
     - date
142 
    """
143 
    pass
144 
 
5620 mandeep.dh 145 
  def getInventoryItemFromOrder(self, orderId):
146 
    """
147 
    Returns inventory item for a given order
5496 mandeep.dh 148 
 
5620 mandeep.dh 149 
    Parameters:
150 
     - orderId
151 
    """
152 
    pass
153 
 
5711 mandeep.dh 154 
  def getInventoryAge(self, ):
155 
    """
156 
    Fetches the stock inventory age week-wise
157 
    """
158 
    pass
5620 mandeep.dh 159 
 
6361 rajveer 160 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
161 
    """
162 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 163 
 
6361 rajveer 164 
    Parameters:
165 
     - itemId
166 
     - fromDate
167 
     - toDate
168 
    """
169 
    pass
170 
 
171 
  def getScanRecordsForSerialNumber(self, serialNumber):
172 
    """
173 
    Fetches the scanRecords for a given serialNumber for a given time interval
174 
 
175 
    Parameters:
176 
     - serialNumber
177 
    """
178 
    pass
179 
 
6467 amar.kumar 180 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
181 
    """
6630 amar.kumar 182 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 183 
 
6467 amar.kumar 184 
    Parameters:
185 
     - saleReturnItems
186 
     - vendorId
187 
    """
188 
    pass
189 
 
6630 amar.kumar 190 
  def scanForLostItem(self, lostItems, vendorId):
191 
    """
192 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 193 
 
6630 amar.kumar 194 
    Parameters:
195 
     - lostItems
196 
     - vendorId
197 
    """
198 
    pass
199 
 
200 
  def getCurrentSerializedInventoryByScans(self, ):
201 
    """
202 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
203 
    """
204 
    pass
205 
 
206 
  def getCurrentNonSerializedInventoryByScans(self, ):
207 
    """
208 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
209 
    """
210 
    pass
211 
 
6762 amar.kumar 212 
  def getHistoricSerializedInventoryByScans(self, date):
213 
    """
214 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
6630 amar.kumar 215 
 
6762 amar.kumar 216 
    Parameters:
217 
     - date
218 
    """
219 
    pass
220 
 
221 
  def getHistoricNonSerializedInventoryByScans(self, date):
222 
    """
223 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
224 
 
225 
    Parameters:
226 
     - date
227 
    """
228 
    pass
229 
 
230 
  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
231 
    """
6880 amar.kumar 232 
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 233 
 
234 
    Parameters:
235 
     - itemId
236 
     - serialNumber
237 
     - itemNumber
238 
     - invoiceNumber
239 
     - warehouseId
240 
     - unitPrice
241 
     - orderId
242 
    """
243 
    pass
244 
 
245 
  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
246 
    """
6880 amar.kumar 247 
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 248 
 
249 
    Parameters:
250 
     - orderId
251 
     - unitPrice
252 
    """
253 
    pass
254 
 
6880 amar.kumar 255 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
256 
    """
257 
    Parameters:
258 
     - startDate
259 
     - endDate
260 
    """
261 
    pass
6762 amar.kumar 262 
 
6880 amar.kumar 263 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
264 
    """
265 
    Parameters:
266 
     - startDate
267 
     - endDate
268 
    """
269 
    pass
270 
 
7190 amar.kumar 271 
  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
272 
    """
273 
    Parameters:
274 
     - orderId
275 
     - freebieItemId
276 
     - freebieWarehouseId
277 
     - scanType
278 
    """
279 
    pass
6880 amar.kumar 280 
 
7190 amar.kumar 281 
 
3376 rajveer 282 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
2821 chandransh 283 
  def __init__(self, iprot, oprot=None):
3376 rajveer 284 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
2821 chandransh 285 
 
4501 mandeep.dh 286 
  def getInventoryItem(self, serialNumber):
2832 chandransh 287 
    """
4501 mandeep.dh 288 
    Retrieves serialized inventory item given a serial number
3431 rajveer 289 
 
2832 chandransh 290 
    Parameters:
4501 mandeep.dh 291 
     - serialNumber
2832 chandransh 292 
    """
4501 mandeep.dh 293 
    self.send_getInventoryItem(serialNumber)
294 
    return self.recv_getInventoryItem()
2832 chandransh 295 
 
4501 mandeep.dh 296 
  def send_getInventoryItem(self, serialNumber):
297 
    self._oprot.writeMessageBegin('getInventoryItem', TMessageType.CALL, self._seqid)
298 
    args = getInventoryItem_args()
299 
    args.serialNumber = serialNumber
2832 chandransh 300 
    args.write(self._oprot)
301 
    self._oprot.writeMessageEnd()
302 
    self._oprot.trans.flush()
303 
 
4501 mandeep.dh 304 
  def recv_getInventoryItem(self, ):
2832 chandransh 305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
306 
    if mtype == TMessageType.EXCEPTION:
307 
      x = TApplicationException()
308 
      x.read(self._iprot)
309 
      self._iprot.readMessageEnd()
310 
      raise x
4501 mandeep.dh 311 
    result = getInventoryItem_result()
2832 chandransh 312 
    result.read(self._iprot)
313 
    self._iprot.readMessageEnd()
3431 rajveer 314 
    if result.success is not None:
2832 chandransh 315 
      return result.success
4541 mandeep.dh 316 
    if result.wex is not None:
317 
      raise result.wex
4501 mandeep.dh 318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItem failed: unknown result");
2832 chandransh 319 
 
5530 mandeep.dh 320 
  def getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
2821 chandransh 321 
    """
5361 mandeep.dh 322 
    Retrieves non-serialized inventory item from a given supplier
3431 rajveer 323 
 
2821 chandransh 324 
    Parameters:
5530 mandeep.dh 325 
     - itemNumber
4501 mandeep.dh 326 
     - itemId
5530 mandeep.dh 327 
     - fulfilmentWarehouseId
2821 chandransh 328 
    """
5530 mandeep.dh 329 
    self.send_getNonSeralizedInventoryItem(itemNumber, itemId, fulfilmentWarehouseId)
5361 mandeep.dh 330 
    return self.recv_getNonSeralizedInventoryItem()
2821 chandransh 331 
 
5530 mandeep.dh 332 
  def send_getNonSeralizedInventoryItem(self, itemNumber, itemId, fulfilmentWarehouseId):
5361 mandeep.dh 333 
    self._oprot.writeMessageBegin('getNonSeralizedInventoryItem', TMessageType.CALL, self._seqid)
334 
    args = getNonSeralizedInventoryItem_args()
5530 mandeep.dh 335 
    args.itemNumber = itemNumber
4501 mandeep.dh 336 
    args.itemId = itemId
5530 mandeep.dh 337 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 338 
    args.write(self._oprot)
339 
    self._oprot.writeMessageEnd()
340 
    self._oprot.trans.flush()
341 
 
5361 mandeep.dh 342 
  def recv_getNonSeralizedInventoryItem(self, ):
2821 chandransh 343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
344 
    if mtype == TMessageType.EXCEPTION:
345 
      x = TApplicationException()
346 
      x.read(self._iprot)
347 
      self._iprot.readMessageEnd()
348 
      raise x
5361 mandeep.dh 349 
    result = getNonSeralizedInventoryItem_result()
2821 chandransh 350 
    result.read(self._iprot)
351 
    self._iprot.readMessageEnd()
3431 rajveer 352 
    if result.success is not None:
2821 chandransh 353 
      return result.success
5361 mandeep.dh 354 
    if result.wex is not None:
355 
      raise result.wex
356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonSeralizedInventoryItem failed: unknown result");
2821 chandransh 357 
 
5361 mandeep.dh 358 
  def scan(self, inventoryItem, type, quantity, billingWarehouseId):
3383 chandransh 359 
    """
4501 mandeep.dh 360 
    Scan non-serialized items.
3431 rajveer 361 
 
2821 chandransh 362 
    Parameters:
5361 mandeep.dh 363 
     - inventoryItem
2821 chandransh 364 
     - type
4501 mandeep.dh 365 
     - quantity
5361 mandeep.dh 366 
     - billingWarehouseId
2821 chandransh 367 
    """
5361 mandeep.dh 368 
    self.send_scan(inventoryItem, type, quantity, billingWarehouseId)
4501 mandeep.dh 369 
    self.recv_scan()
2821 chandransh 370 
 
5361 mandeep.dh 371 
  def send_scan(self, inventoryItem, type, quantity, billingWarehouseId):
4501 mandeep.dh 372 
    self._oprot.writeMessageBegin('scan', TMessageType.CALL, self._seqid)
373 
    args = scan_args()
5361 mandeep.dh 374 
    args.inventoryItem = inventoryItem
2821 chandransh 375 
    args.type = type
4501 mandeep.dh 376 
    args.quantity = quantity
5361 mandeep.dh 377 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 378 
    args.write(self._oprot)
379 
    self._oprot.writeMessageEnd()
380 
    self._oprot.trans.flush()
381 
 
4501 mandeep.dh 382 
  def recv_scan(self, ):
2821 chandransh 383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
384 
    if mtype == TMessageType.EXCEPTION:
385 
      x = TApplicationException()
386 
      x.read(self._iprot)
387 
      self._iprot.readMessageEnd()
388 
      raise x
4501 mandeep.dh 389 
    result = scan_result()
2821 chandransh 390 
    result.read(self._iprot)
391 
    self._iprot.readMessageEnd()
3431 rajveer 392 
    if result.wex is not None:
2821 chandransh 393 
      raise result.wex
394 
    return
395 
 
5110 mandeep.dh 396 
  def scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
2821 chandransh 397 
    """
4501 mandeep.dh 398 
    Scan serialized items linked with an order. Returns its price.
3431 rajveer 399 
 
2821 chandransh 400 
    Parameters:
4555 mandeep.dh 401 
     - serialNumber
2821 chandransh 402 
     - type
4501 mandeep.dh 403 
     - orderId
5110 mandeep.dh 404 
     - fulfilmentWarehouseId
405 
     - quantity
406 
     - billingWarehouseId
2821 chandransh 407 
    """
5110 mandeep.dh 408 
    self.send_scanSerializedItemForOrder(serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId)
4501 mandeep.dh 409 
    return self.recv_scanSerializedItemForOrder()
2821 chandransh 410 
 
5110 mandeep.dh 411 
  def send_scanSerializedItemForOrder(self, serialNumber, type, orderId, fulfilmentWarehouseId, quantity, billingWarehouseId):
4501 mandeep.dh 412 
    self._oprot.writeMessageBegin('scanSerializedItemForOrder', TMessageType.CALL, self._seqid)
413 
    args = scanSerializedItemForOrder_args()
4555 mandeep.dh 414 
    args.serialNumber = serialNumber
2821 chandransh 415 
    args.type = type
4501 mandeep.dh 416 
    args.orderId = orderId
5110 mandeep.dh 417 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
418 
    args.quantity = quantity
419 
    args.billingWarehouseId = billingWarehouseId
2821 chandransh 420 
    args.write(self._oprot)
421 
    self._oprot.writeMessageEnd()
422 
    self._oprot.trans.flush()
423 
 
4501 mandeep.dh 424 
  def recv_scanSerializedItemForOrder(self, ):
2821 chandransh 425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
426 
    if mtype == TMessageType.EXCEPTION:
427 
      x = TApplicationException()
428 
      x.read(self._iprot)
429 
      self._iprot.readMessageEnd()
430 
      raise x
4501 mandeep.dh 431 
    result = scanSerializedItemForOrder_result()
2821 chandransh 432 
    result.read(self._iprot)
433 
    self._iprot.readMessageEnd()
4501 mandeep.dh 434 
    if result.success is not None:
435 
      return result.success
3431 rajveer 436 
    if result.wex is not None:
2821 chandransh 437 
      raise result.wex
4501 mandeep.dh 438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanSerializedItemForOrder failed: unknown result");
439 
 
5361 mandeep.dh 440 
  def scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 441 
    """
442 
    Scan non-serialized items linked with an order.
443 
 
444 
    Parameters:
5361 mandeep.dh 445 
     - inventoryItem
4501 mandeep.dh 446 
     - type
447 
     - quantity
448 
     - orderId
5110 mandeep.dh 449 
     - fulfilmentWarehouseId
5361 mandeep.dh 450 
     - billingWarehouseId
4501 mandeep.dh 451 
    """
5361 mandeep.dh 452 
    self.send_scanForOrder(inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId)
453 
    return self.recv_scanForOrder()
4501 mandeep.dh 454 
 
5361 mandeep.dh 455 
  def send_scanForOrder(self, inventoryItem, type, quantity, orderId, fulfilmentWarehouseId, billingWarehouseId):
4501 mandeep.dh 456 
    self._oprot.writeMessageBegin('scanForOrder', TMessageType.CALL, self._seqid)
457 
    args = scanForOrder_args()
5361 mandeep.dh 458 
    args.inventoryItem = inventoryItem
4501 mandeep.dh 459 
    args.type = type
460 
    args.quantity = quantity
461 
    args.orderId = orderId
5110 mandeep.dh 462 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 463 
    args.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 464 
    args.write(self._oprot)
465 
    self._oprot.writeMessageEnd()
466 
    self._oprot.trans.flush()
467 
 
468 
  def recv_scanForOrder(self, ):
469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
470 
    if mtype == TMessageType.EXCEPTION:
471 
      x = TApplicationException()
472 
      x.read(self._iprot)
473 
      self._iprot.readMessageEnd()
474 
      raise x
475 
    result = scanForOrder_result()
476 
    result.read(self._iprot)
477 
    self._iprot.readMessageEnd()
5361 mandeep.dh 478 
    if result.success is not None:
479 
      return result.success
4501 mandeep.dh 480 
    if result.wex is not None:
481 
      raise result.wex
5361 mandeep.dh 482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOrder failed: unknown result");
2821 chandransh 483 
 
4501 mandeep.dh 484 
  def createItemNumberMapping(self, itemNumber, itemId):
485 
    """
486 
    Created item number to item id mapping
2821 chandransh 487 
 
4501 mandeep.dh 488 
    Parameters:
489 
     - itemNumber
490 
     - itemId
491 
    """
492 
    self.send_createItemNumberMapping(itemNumber, itemId)
493 
    self.recv_createItemNumberMapping()
494 
 
495 
  def send_createItemNumberMapping(self, itemNumber, itemId):
496 
    self._oprot.writeMessageBegin('createItemNumberMapping', TMessageType.CALL, self._seqid)
497 
    args = createItemNumberMapping_args()
498 
    args.itemNumber = itemNumber
499 
    args.itemId = itemId
500 
    args.write(self._oprot)
501 
    self._oprot.writeMessageEnd()
502 
    self._oprot.trans.flush()
503 
 
504 
  def recv_createItemNumberMapping(self, ):
505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
506 
    if mtype == TMessageType.EXCEPTION:
507 
      x = TApplicationException()
508 
      x.read(self._iprot)
509 
      self._iprot.readMessageEnd()
510 
      raise x
511 
    result = createItemNumberMapping_result()
512 
    result.read(self._iprot)
513 
    self._iprot.readMessageEnd()
514 
    return
515 
 
4620 amit.gupta 516 
  def getItemNumbers(self, itemId):
517 
    """
518 
    Get itemNumber mappings for itemId
4501 mandeep.dh 519 
 
4620 amit.gupta 520 
    Parameters:
521 
     - itemId
522 
    """
523 
    self.send_getItemNumbers(itemId)
524 
    return self.recv_getItemNumbers()
525 
 
526 
  def send_getItemNumbers(self, itemId):
527 
    self._oprot.writeMessageBegin('getItemNumbers', TMessageType.CALL, self._seqid)
528 
    args = getItemNumbers_args()
529 
    args.itemId = itemId
530 
    args.write(self._oprot)
531 
    self._oprot.writeMessageEnd()
532 
    self._oprot.trans.flush()
533 
 
534 
  def recv_getItemNumbers(self, ):
535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
536 
    if mtype == TMessageType.EXCEPTION:
537 
      x = TApplicationException()
538 
      x.read(self._iprot)
539 
      self._iprot.readMessageEnd()
540 
      raise x
541 
    result = getItemNumbers_result()
542 
    result.read(self._iprot)
543 
    self._iprot.readMessageEnd()
544 
    if result.success is not None:
545 
      return result.success
546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemNumbers failed: unknown result");
547 
 
5110 mandeep.dh 548 
  def getItemIds(self, itemNumber):
549 
    """
550 
    Gets item ids for a given item number
4620 amit.gupta 551 
 
5110 mandeep.dh 552 
    Parameters:
553 
     - itemNumber
554 
    """
555 
    self.send_getItemIds(itemNumber)
556 
    return self.recv_getItemIds()
557 
 
558 
  def send_getItemIds(self, itemNumber):
559 
    self._oprot.writeMessageBegin('getItemIds', TMessageType.CALL, self._seqid)
560 
    args = getItemIds_args()
561 
    args.itemNumber = itemNumber
562 
    args.write(self._oprot)
563 
    self._oprot.writeMessageEnd()
564 
    self._oprot.trans.flush()
565 
 
566 
  def recv_getItemIds(self, ):
567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
568 
    if mtype == TMessageType.EXCEPTION:
569 
      x = TApplicationException()
570 
      x.read(self._iprot)
571 
      self._iprot.readMessageEnd()
572 
      raise x
573 
    result = getItemIds_result()
574 
    result.read(self._iprot)
575 
    self._iprot.readMessageEnd()
576 
    if result.success is not None:
577 
      return result.success
578 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemIds failed: unknown result");
579 
 
5185 mandeep.dh 580 
  def getInventoryItemsFromLastScanType(self, lastScanType):
581 
    """
582 
    Retrieves all inventory items given a last scan type
5110 mandeep.dh 583 
 
5185 mandeep.dh 584 
    Parameters:
585 
     - lastScanType
586 
    """
587 
    self.send_getInventoryItemsFromLastScanType(lastScanType)
588 
    return self.recv_getInventoryItemsFromLastScanType()
589 
 
590 
  def send_getInventoryItemsFromLastScanType(self, lastScanType):
591 
    self._oprot.writeMessageBegin('getInventoryItemsFromLastScanType', TMessageType.CALL, self._seqid)
592 
    args = getInventoryItemsFromLastScanType_args()
593 
    args.lastScanType = lastScanType
594 
    args.write(self._oprot)
595 
    self._oprot.writeMessageEnd()
596 
    self._oprot.trans.flush()
597 
 
598 
  def recv_getInventoryItemsFromLastScanType(self, ):
599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
600 
    if mtype == TMessageType.EXCEPTION:
601 
      x = TApplicationException()
602 
      x.read(self._iprot)
603 
      self._iprot.readMessageEnd()
604 
      raise x
605 
    result = getInventoryItemsFromLastScanType_result()
606 
    result.read(self._iprot)
607 
    self._iprot.readMessageEnd()
608 
    if result.success is not None:
609 
      return result.success
610 
    if result.wex is not None:
611 
      raise result.wex
612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemsFromLastScanType failed: unknown result");
613 
 
614 
  def getInventoryItemFromId(self, inventoryItemId):
615 
    """
616 
    Retrieves inventory item given a inventoryItem id
617 
 
618 
    Parameters:
619 
     - inventoryItemId
620 
    """
621 
    self.send_getInventoryItemFromId(inventoryItemId)
622 
    return self.recv_getInventoryItemFromId()
623 
 
624 
  def send_getInventoryItemFromId(self, inventoryItemId):
625 
    self._oprot.writeMessageBegin('getInventoryItemFromId', TMessageType.CALL, self._seqid)
626 
    args = getInventoryItemFromId_args()
627 
    args.inventoryItemId = inventoryItemId
628 
    args.write(self._oprot)
629 
    self._oprot.writeMessageEnd()
630 
    self._oprot.trans.flush()
631 
 
632 
  def recv_getInventoryItemFromId(self, ):
633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
634 
    if mtype == TMessageType.EXCEPTION:
635 
      x = TApplicationException()
636 
      x.read(self._iprot)
637 
      self._iprot.readMessageEnd()
638 
      raise x
639 
    result = getInventoryItemFromId_result()
640 
    result.read(self._iprot)
641 
    self._iprot.readMessageEnd()
642 
    if result.success is not None:
643 
      return result.success
644 
    if result.wex is not None:
645 
      raise result.wex
646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromId failed: unknown result");
647 
 
5372 mandeep.dh 648 
  def getPurchaseScans(self, startDate, endDate):
649 
    """
650 
    Returns the purchase scans grouped by items for Purchase register reconciliation
5185 mandeep.dh 651 
 
5372 mandeep.dh 652 
    Parameters:
653 
     - startDate
654 
     - endDate
655 
    """
656 
    self.send_getPurchaseScans(startDate, endDate)
657 
    return self.recv_getPurchaseScans()
658 
 
659 
  def send_getPurchaseScans(self, startDate, endDate):
660 
    self._oprot.writeMessageBegin('getPurchaseScans', TMessageType.CALL, self._seqid)
661 
    args = getPurchaseScans_args()
662 
    args.startDate = startDate
663 
    args.endDate = endDate
664 
    args.write(self._oprot)
665 
    self._oprot.writeMessageEnd()
666 
    self._oprot.trans.flush()
667 
 
668 
  def recv_getPurchaseScans(self, ):
669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
670 
    if mtype == TMessageType.EXCEPTION:
671 
      x = TApplicationException()
672 
      x.read(self._iprot)
673 
      self._iprot.readMessageEnd()
674 
      raise x
675 
    result = getPurchaseScans_result()
676 
    result.read(self._iprot)
677 
    self._iprot.readMessageEnd()
678 
    if result.success is not None:
679 
      return result.success
680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPurchaseScans failed: unknown result");
681 
 
5496 mandeep.dh 682 
  def fetchScansPerInvoiceNumber(self, date):
683 
    """
684 
    Returns the invoices and the count of scans against on a given day.
5372 mandeep.dh 685 
 
5496 mandeep.dh 686 
    Parameters:
687 
     - date
688 
    """
689 
    self.send_fetchScansPerInvoiceNumber(date)
690 
    return self.recv_fetchScansPerInvoiceNumber()
691 
 
692 
  def send_fetchScansPerInvoiceNumber(self, date):
693 
    self._oprot.writeMessageBegin('fetchScansPerInvoiceNumber', TMessageType.CALL, self._seqid)
694 
    args = fetchScansPerInvoiceNumber_args()
695 
    args.date = date
696 
    args.write(self._oprot)
697 
    self._oprot.writeMessageEnd()
698 
    self._oprot.trans.flush()
699 
 
700 
  def recv_fetchScansPerInvoiceNumber(self, ):
701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
702 
    if mtype == TMessageType.EXCEPTION:
703 
      x = TApplicationException()
704 
      x.read(self._iprot)
705 
      self._iprot.readMessageEnd()
706 
      raise x
707 
    result = fetchScansPerInvoiceNumber_result()
708 
    result.read(self._iprot)
709 
    self._iprot.readMessageEnd()
710 
    if result.success is not None:
711 
      return result.success
712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "fetchScansPerInvoiceNumber failed: unknown result");
713 
 
5620 mandeep.dh 714 
  def getInventoryItemFromOrder(self, orderId):
715 
    """
716 
    Returns inventory item for a given order
5496 mandeep.dh 717 
 
5620 mandeep.dh 718 
    Parameters:
719 
     - orderId
720 
    """
721 
    self.send_getInventoryItemFromOrder(orderId)
722 
    return self.recv_getInventoryItemFromOrder()
723 
 
724 
  def send_getInventoryItemFromOrder(self, orderId):
725 
    self._oprot.writeMessageBegin('getInventoryItemFromOrder', TMessageType.CALL, self._seqid)
726 
    args = getInventoryItemFromOrder_args()
727 
    args.orderId = orderId
728 
    args.write(self._oprot)
729 
    self._oprot.writeMessageEnd()
730 
    self._oprot.trans.flush()
731 
 
732 
  def recv_getInventoryItemFromOrder(self, ):
733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
734 
    if mtype == TMessageType.EXCEPTION:
735 
      x = TApplicationException()
736 
      x.read(self._iprot)
737 
      self._iprot.readMessageEnd()
738 
      raise x
739 
    result = getInventoryItemFromOrder_result()
740 
    result.read(self._iprot)
741 
    self._iprot.readMessageEnd()
742 
    if result.success is not None:
743 
      return result.success
744 
    if result.we is not None:
745 
      raise result.we
746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryItemFromOrder failed: unknown result");
747 
 
5711 mandeep.dh 748 
  def getInventoryAge(self, ):
749 
    """
750 
    Fetches the stock inventory age week-wise
751 
    """
752 
    self.send_getInventoryAge()
753 
    return self.recv_getInventoryAge()
5620 mandeep.dh 754 
 
5711 mandeep.dh 755 
  def send_getInventoryAge(self, ):
756 
    self._oprot.writeMessageBegin('getInventoryAge', TMessageType.CALL, self._seqid)
757 
    args = getInventoryAge_args()
758 
    args.write(self._oprot)
759 
    self._oprot.writeMessageEnd()
760 
    self._oprot.trans.flush()
761 
 
762 
  def recv_getInventoryAge(self, ):
763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
764 
    if mtype == TMessageType.EXCEPTION:
765 
      x = TApplicationException()
766 
      x.read(self._iprot)
767 
      self._iprot.readMessageEnd()
768 
      raise x
769 
    result = getInventoryAge_result()
770 
    result.read(self._iprot)
771 
    self._iprot.readMessageEnd()
772 
    if result.success is not None:
773 
      return result.success
774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryAge failed: unknown result");
775 
 
6361 rajveer 776 
  def getInventoryScansForItem(self, itemId, fromDate, toDate):
777 
    """
778 
    Fetches the scanRecords for a given item for a given time interval
5711 mandeep.dh 779 
 
6361 rajveer 780 
    Parameters:
781 
     - itemId
782 
     - fromDate
783 
     - toDate
784 
    """
785 
    self.send_getInventoryScansForItem(itemId, fromDate, toDate)
786 
    return self.recv_getInventoryScansForItem()
787 
 
788 
  def send_getInventoryScansForItem(self, itemId, fromDate, toDate):
789 
    self._oprot.writeMessageBegin('getInventoryScansForItem', TMessageType.CALL, self._seqid)
790 
    args = getInventoryScansForItem_args()
791 
    args.itemId = itemId
792 
    args.fromDate = fromDate
793 
    args.toDate = toDate
794 
    args.write(self._oprot)
795 
    self._oprot.writeMessageEnd()
796 
    self._oprot.trans.flush()
797 
 
798 
  def recv_getInventoryScansForItem(self, ):
799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
800 
    if mtype == TMessageType.EXCEPTION:
801 
      x = TApplicationException()
802 
      x.read(self._iprot)
803 
      self._iprot.readMessageEnd()
804 
      raise x
805 
    result = getInventoryScansForItem_result()
806 
    result.read(self._iprot)
807 
    self._iprot.readMessageEnd()
808 
    if result.success is not None:
809 
      return result.success
810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getInventoryScansForItem failed: unknown result");
811 
 
812 
  def getScanRecordsForSerialNumber(self, serialNumber):
813 
    """
814 
    Fetches the scanRecords for a given serialNumber for a given time interval
815 
 
816 
    Parameters:
817 
     - serialNumber
818 
    """
819 
    self.send_getScanRecordsForSerialNumber(serialNumber)
820 
    return self.recv_getScanRecordsForSerialNumber()
821 
 
822 
  def send_getScanRecordsForSerialNumber(self, serialNumber):
823 
    self._oprot.writeMessageBegin('getScanRecordsForSerialNumber', TMessageType.CALL, self._seqid)
824 
    args = getScanRecordsForSerialNumber_args()
825 
    args.serialNumber = serialNumber
826 
    args.write(self._oprot)
827 
    self._oprot.writeMessageEnd()
828 
    self._oprot.trans.flush()
829 
 
830 
  def recv_getScanRecordsForSerialNumber(self, ):
831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
832 
    if mtype == TMessageType.EXCEPTION:
833 
      x = TApplicationException()
834 
      x.read(self._iprot)
835 
      self._iprot.readMessageEnd()
836 
      raise x
837 
    result = getScanRecordsForSerialNumber_result()
838 
    result.read(self._iprot)
839 
    self._iprot.readMessageEnd()
840 
    if result.success is not None:
841 
      return result.success
842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getScanRecordsForSerialNumber failed: unknown result");
843 
 
6467 amar.kumar 844 
  def scanForPurchaseReturn(self, saleReturnItems, vendorId):
845 
    """
6630 amar.kumar 846 
    Inserts outgoing scans for Returned Items and updates returnId in InventoryItems
6361 rajveer 847 
 
6467 amar.kumar 848 
    Parameters:
849 
     - saleReturnItems
850 
     - vendorId
851 
    """
852 
    self.send_scanForPurchaseReturn(saleReturnItems, vendorId)
853 
    self.recv_scanForPurchaseReturn()
854 
 
855 
  def send_scanForPurchaseReturn(self, saleReturnItems, vendorId):
856 
    self._oprot.writeMessageBegin('scanForPurchaseReturn', TMessageType.CALL, self._seqid)
857 
    args = scanForPurchaseReturn_args()
858 
    args.saleReturnItems = saleReturnItems
859 
    args.vendorId = vendorId
860 
    args.write(self._oprot)
861 
    self._oprot.writeMessageEnd()
862 
    self._oprot.trans.flush()
863 
 
864 
  def recv_scanForPurchaseReturn(self, ):
865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
866 
    if mtype == TMessageType.EXCEPTION:
867 
      x = TApplicationException()
868 
      x.read(self._iprot)
869 
      self._iprot.readMessageEnd()
870 
      raise x
871 
    result = scanForPurchaseReturn_result()
872 
    result.read(self._iprot)
873 
    self._iprot.readMessageEnd()
874 
    if result.ex is not None:
875 
      raise result.ex
876 
    return
877 
 
6630 amar.kumar 878 
  def scanForLostItem(self, lostItems, vendorId):
879 
    """
880 
    Inserts scans for lost Items and updates lastScanType in InventoryItems
6467 amar.kumar 881 
 
6630 amar.kumar 882 
    Parameters:
883 
     - lostItems
884 
     - vendorId
885 
    """
886 
    self.send_scanForLostItem(lostItems, vendorId)
887 
    self.recv_scanForLostItem()
888 
 
889 
  def send_scanForLostItem(self, lostItems, vendorId):
890 
    self._oprot.writeMessageBegin('scanForLostItem', TMessageType.CALL, self._seqid)
891 
    args = scanForLostItem_args()
892 
    args.lostItems = lostItems
893 
    args.vendorId = vendorId
894 
    args.write(self._oprot)
895 
    self._oprot.writeMessageEnd()
896 
    self._oprot.trans.flush()
897 
 
898 
  def recv_scanForLostItem(self, ):
899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
900 
    if mtype == TMessageType.EXCEPTION:
901 
      x = TApplicationException()
902 
      x.read(self._iprot)
903 
      self._iprot.readMessageEnd()
904 
      raise x
905 
    result = scanForLostItem_result()
906 
    result.read(self._iprot)
907 
    self._iprot.readMessageEnd()
908 
    if result.ex is not None:
909 
      raise result.ex
910 
    return
911 
 
912 
  def getCurrentSerializedInventoryByScans(self, ):
913 
    """
914 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
915 
    """
916 
    self.send_getCurrentSerializedInventoryByScans()
917 
    return self.recv_getCurrentSerializedInventoryByScans()
918 
 
919 
  def send_getCurrentSerializedInventoryByScans(self, ):
920 
    self._oprot.writeMessageBegin('getCurrentSerializedInventoryByScans', TMessageType.CALL, self._seqid)
921 
    args = getCurrentSerializedInventoryByScans_args()
922 
    args.write(self._oprot)
923 
    self._oprot.writeMessageEnd()
924 
    self._oprot.trans.flush()
925 
 
926 
  def recv_getCurrentSerializedInventoryByScans(self, ):
927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
928 
    if mtype == TMessageType.EXCEPTION:
929 
      x = TApplicationException()
930 
      x.read(self._iprot)
931 
      self._iprot.readMessageEnd()
932 
      raise x
933 
    result = getCurrentSerializedInventoryByScans_result()
934 
    result.read(self._iprot)
935 
    self._iprot.readMessageEnd()
936 
    if result.success is not None:
937 
      return result.success
938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentSerializedInventoryByScans failed: unknown result");
939 
 
940 
  def getCurrentNonSerializedInventoryByScans(self, ):
941 
    """
942 
    Get inventory count for available Serialized items in our warehouses using entries in ScanNew table
943 
    """
944 
    self.send_getCurrentNonSerializedInventoryByScans()
945 
    return self.recv_getCurrentNonSerializedInventoryByScans()
946 
 
947 
  def send_getCurrentNonSerializedInventoryByScans(self, ):
948 
    self._oprot.writeMessageBegin('getCurrentNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
949 
    args = getCurrentNonSerializedInventoryByScans_args()
950 
    args.write(self._oprot)
951 
    self._oprot.writeMessageEnd()
952 
    self._oprot.trans.flush()
953 
 
954 
  def recv_getCurrentNonSerializedInventoryByScans(self, ):
955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
956 
    if mtype == TMessageType.EXCEPTION:
957 
      x = TApplicationException()
958 
      x.read(self._iprot)
959 
      self._iprot.readMessageEnd()
960 
      raise x
961 
    result = getCurrentNonSerializedInventoryByScans_result()
962 
    result.read(self._iprot)
963 
    self._iprot.readMessageEnd()
964 
    if result.success is not None:
965 
      return result.success
966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentNonSerializedInventoryByScans failed: unknown result");
967 
 
6762 amar.kumar 968 
  def getHistoricSerializedInventoryByScans(self, date):
969 
    """
970 
    Get inventory for Serialized items in our warehouses at a given date using entries in ScanNew table
6630 amar.kumar 971 
 
6762 amar.kumar 972 
    Parameters:
973 
     - date
974 
    """
975 
    self.send_getHistoricSerializedInventoryByScans(date)
976 
    return self.recv_getHistoricSerializedInventoryByScans()
977 
 
978 
  def send_getHistoricSerializedInventoryByScans(self, date):
979 
    self._oprot.writeMessageBegin('getHistoricSerializedInventoryByScans', TMessageType.CALL, self._seqid)
980 
    args = getHistoricSerializedInventoryByScans_args()
981 
    args.date = date
982 
    args.write(self._oprot)
983 
    self._oprot.writeMessageEnd()
984 
    self._oprot.trans.flush()
985 
 
986 
  def recv_getHistoricSerializedInventoryByScans(self, ):
987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
988 
    if mtype == TMessageType.EXCEPTION:
989 
      x = TApplicationException()
990 
      x.read(self._iprot)
991 
      self._iprot.readMessageEnd()
992 
      raise x
993 
    result = getHistoricSerializedInventoryByScans_result()
994 
    result.read(self._iprot)
995 
    self._iprot.readMessageEnd()
996 
    if result.success is not None:
997 
      return result.success
998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricSerializedInventoryByScans failed: unknown result");
999 
 
1000 
  def getHistoricNonSerializedInventoryByScans(self, date):
1001 
    """
1002 
    Get inventory for Non Serialized items in our warehouses at a given date using entries in ScanNew table
1003 
 
1004 
    Parameters:
1005 
     - date
1006 
    """
1007 
    self.send_getHistoricNonSerializedInventoryByScans(date)
1008 
    return self.recv_getHistoricNonSerializedInventoryByScans()
1009 
 
1010 
  def send_getHistoricNonSerializedInventoryByScans(self, date):
1011 
    self._oprot.writeMessageBegin('getHistoricNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1012 
    args = getHistoricNonSerializedInventoryByScans_args()
1013 
    args.date = date
1014 
    args.write(self._oprot)
1015 
    self._oprot.writeMessageEnd()
1016 
    self._oprot.trans.flush()
1017 
 
1018 
  def recv_getHistoricNonSerializedInventoryByScans(self, ):
1019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1020 
    if mtype == TMessageType.EXCEPTION:
1021 
      x = TApplicationException()
1022 
      x.read(self._iprot)
1023 
      self._iprot.readMessageEnd()
1024 
      raise x
1025 
    result = getHistoricNonSerializedInventoryByScans_result()
1026 
    result.read(self._iprot)
1027 
    self._iprot.readMessageEnd()
1028 
    if result.success is not None:
1029 
      return result.success
1030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHistoricNonSerializedInventoryByScans failed: unknown result");
1031 
 
1032 
  def scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
1033 
    """
6880 amar.kumar 1034 
    Insert Purchase/Sale Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1035 
 
1036 
    Parameters:
1037 
     - itemId
1038 
     - serialNumber
1039 
     - itemNumber
1040 
     - invoiceNumber
1041 
     - warehouseId
1042 
     - unitPrice
1043 
     - orderId
1044 
    """
1045 
    self.send_scanForOursExternalSale(itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId)
1046 
    return self.recv_scanForOursExternalSale()
1047 
 
1048 
  def send_scanForOursExternalSale(self, itemId, serialNumber, itemNumber, invoiceNumber, warehouseId, unitPrice, orderId):
1049 
    self._oprot.writeMessageBegin('scanForOursExternalSale', TMessageType.CALL, self._seqid)
1050 
    args = scanForOursExternalSale_args()
1051 
    args.itemId = itemId
1052 
    args.serialNumber = serialNumber
1053 
    args.itemNumber = itemNumber
1054 
    args.invoiceNumber = invoiceNumber
1055 
    args.warehouseId = warehouseId
1056 
    args.unitPrice = unitPrice
1057 
    args.orderId = orderId
1058 
    args.write(self._oprot)
1059 
    self._oprot.writeMessageEnd()
1060 
    self._oprot.trans.flush()
1061 
 
1062 
  def recv_scanForOursExternalSale(self, ):
1063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1064 
    if mtype == TMessageType.EXCEPTION:
1065 
      x = TApplicationException()
1066 
      x.read(self._iprot)
1067 
      self._iprot.readMessageEnd()
1068 
      raise x
1069 
    result = scanForOursExternalSale_result()
1070 
    result.read(self._iprot)
1071 
    self._iprot.readMessageEnd()
1072 
    if result.success is not None:
1073 
      return result.success
1074 
    if result.ex is not None:
1075 
      raise result.ex
1076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanForOursExternalSale failed: unknown result");
1077 
 
1078 
  def scanForOursExternalSaleReturn(self, orderId, unitPrice):
1079 
    """
6880 amar.kumar 1080 
    Insert Purchase_Ret/Sale_Ret Entries for product billed by Hotspot using OURS_EXTERNAL Billing
6762 amar.kumar 1081 
 
1082 
    Parameters:
1083 
     - orderId
1084 
     - unitPrice
1085 
    """
1086 
    self.send_scanForOursExternalSaleReturn(orderId, unitPrice)
1087 
    self.recv_scanForOursExternalSaleReturn()
1088 
 
1089 
  def send_scanForOursExternalSaleReturn(self, orderId, unitPrice):
1090 
    self._oprot.writeMessageBegin('scanForOursExternalSaleReturn', TMessageType.CALL, self._seqid)
1091 
    args = scanForOursExternalSaleReturn_args()
1092 
    args.orderId = orderId
1093 
    args.unitPrice = unitPrice
1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_scanForOursExternalSaleReturn(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = scanForOursExternalSaleReturn_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
1108 
    return
1109 
 
6880 amar.kumar 1110 
  def getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1111 
    """
1112 
    Parameters:
1113 
     - startDate
1114 
     - endDate
1115 
    """
1116 
    self.send_getMovementNonSerializedInventoryByScans(startDate, endDate)
1117 
    return self.recv_getMovementNonSerializedInventoryByScans()
6762 amar.kumar 1118 
 
6880 amar.kumar 1119 
  def send_getMovementNonSerializedInventoryByScans(self, startDate, endDate):
1120 
    self._oprot.writeMessageBegin('getMovementNonSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1121 
    args = getMovementNonSerializedInventoryByScans_args()
1122 
    args.startDate = startDate
1123 
    args.endDate = endDate
1124 
    args.write(self._oprot)
1125 
    self._oprot.writeMessageEnd()
1126 
    self._oprot.trans.flush()
1127 
 
1128 
  def recv_getMovementNonSerializedInventoryByScans(self, ):
1129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1130 
    if mtype == TMessageType.EXCEPTION:
1131 
      x = TApplicationException()
1132 
      x.read(self._iprot)
1133 
      self._iprot.readMessageEnd()
1134 
      raise x
1135 
    result = getMovementNonSerializedInventoryByScans_result()
1136 
    result.read(self._iprot)
1137 
    self._iprot.readMessageEnd()
1138 
    if result.success is not None:
1139 
      return result.success
1140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementNonSerializedInventoryByScans failed: unknown result");
1141 
 
1142 
  def getMovementSerializedInventoryByScans(self, startDate, endDate):
1143 
    """
1144 
    Parameters:
1145 
     - startDate
1146 
     - endDate
1147 
    """
1148 
    self.send_getMovementSerializedInventoryByScans(startDate, endDate)
1149 
    return self.recv_getMovementSerializedInventoryByScans()
1150 
 
1151 
  def send_getMovementSerializedInventoryByScans(self, startDate, endDate):
1152 
    self._oprot.writeMessageBegin('getMovementSerializedInventoryByScans', TMessageType.CALL, self._seqid)
1153 
    args = getMovementSerializedInventoryByScans_args()
1154 
    args.startDate = startDate
1155 
    args.endDate = endDate
1156 
    args.write(self._oprot)
1157 
    self._oprot.writeMessageEnd()
1158 
    self._oprot.trans.flush()
1159 
 
1160 
  def recv_getMovementSerializedInventoryByScans(self, ):
1161 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1162 
    if mtype == TMessageType.EXCEPTION:
1163 
      x = TApplicationException()
1164 
      x.read(self._iprot)
1165 
      self._iprot.readMessageEnd()
1166 
      raise x
1167 
    result = getMovementSerializedInventoryByScans_result()
1168 
    result.read(self._iprot)
1169 
    self._iprot.readMessageEnd()
1170 
    if result.success is not None:
1171 
      return result.success
1172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMovementSerializedInventoryByScans failed: unknown result");
1173 
 
7190 amar.kumar 1174 
  def scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1175 
    """
1176 
    Parameters:
1177 
     - orderId
1178 
     - freebieItemId
1179 
     - freebieWarehouseId
1180 
     - scanType
1181 
    """
1182 
    self.send_scanfreebie(orderId, freebieItemId, freebieWarehouseId, scanType)
1183 
    return self.recv_scanfreebie()
6880 amar.kumar 1184 
 
7190 amar.kumar 1185 
  def send_scanfreebie(self, orderId, freebieItemId, freebieWarehouseId, scanType):
1186 
    self._oprot.writeMessageBegin('scanfreebie', TMessageType.CALL, self._seqid)
1187 
    args = scanfreebie_args()
1188 
    args.orderId = orderId
1189 
    args.freebieItemId = freebieItemId
1190 
    args.freebieWarehouseId = freebieWarehouseId
1191 
    args.scanType = scanType
1192 
    args.write(self._oprot)
1193 
    self._oprot.writeMessageEnd()
1194 
    self._oprot.trans.flush()
1195 
 
1196 
  def recv_scanfreebie(self, ):
1197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1198 
    if mtype == TMessageType.EXCEPTION:
1199 
      x = TApplicationException()
1200 
      x.read(self._iprot)
1201 
      self._iprot.readMessageEnd()
1202 
      raise x
1203 
    result = scanfreebie_result()
1204 
    result.read(self._iprot)
1205 
    self._iprot.readMessageEnd()
1206 
    if result.success is not None:
1207 
      return result.success
1208 
    if result.wex is not None:
1209 
      raise result.wex
1210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "scanfreebie failed: unknown result");
1211 
 
1212 
 
3376 rajveer 1213 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
2821 chandransh 1214 
  def __init__(self, handler):
3376 rajveer 1215 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
4501 mandeep.dh 1216 
    self._processMap["getInventoryItem"] = Processor.process_getInventoryItem
5361 mandeep.dh 1217 
    self._processMap["getNonSeralizedInventoryItem"] = Processor.process_getNonSeralizedInventoryItem
4501 mandeep.dh 1218 
    self._processMap["scan"] = Processor.process_scan
1219 
    self._processMap["scanSerializedItemForOrder"] = Processor.process_scanSerializedItemForOrder
1220 
    self._processMap["scanForOrder"] = Processor.process_scanForOrder
1221 
    self._processMap["createItemNumberMapping"] = Processor.process_createItemNumberMapping
4620 amit.gupta 1222 
    self._processMap["getItemNumbers"] = Processor.process_getItemNumbers
5110 mandeep.dh 1223 
    self._processMap["getItemIds"] = Processor.process_getItemIds
5185 mandeep.dh 1224 
    self._processMap["getInventoryItemsFromLastScanType"] = Processor.process_getInventoryItemsFromLastScanType
1225 
    self._processMap["getInventoryItemFromId"] = Processor.process_getInventoryItemFromId
5372 mandeep.dh 1226 
    self._processMap["getPurchaseScans"] = Processor.process_getPurchaseScans
5496 mandeep.dh 1227 
    self._processMap["fetchScansPerInvoiceNumber"] = Processor.process_fetchScansPerInvoiceNumber
5620 mandeep.dh 1228 
    self._processMap["getInventoryItemFromOrder"] = Processor.process_getInventoryItemFromOrder
5711 mandeep.dh 1229 
    self._processMap["getInventoryAge"] = Processor.process_getInventoryAge
6361 rajveer 1230 
    self._processMap["getInventoryScansForItem"] = Processor.process_getInventoryScansForItem
1231 
    self._processMap["getScanRecordsForSerialNumber"] = Processor.process_getScanRecordsForSerialNumber
6467 amar.kumar 1232 
    self._processMap["scanForPurchaseReturn"] = Processor.process_scanForPurchaseReturn
6630 amar.kumar 1233 
    self._processMap["scanForLostItem"] = Processor.process_scanForLostItem
1234 
    self._processMap["getCurrentSerializedInventoryByScans"] = Processor.process_getCurrentSerializedInventoryByScans
1235 
    self._processMap["getCurrentNonSerializedInventoryByScans"] = Processor.process_getCurrentNonSerializedInventoryByScans
6762 amar.kumar 1236 
    self._processMap["getHistoricSerializedInventoryByScans"] = Processor.process_getHistoricSerializedInventoryByScans
1237 
    self._processMap["getHistoricNonSerializedInventoryByScans"] = Processor.process_getHistoricNonSerializedInventoryByScans
1238 
    self._processMap["scanForOursExternalSale"] = Processor.process_scanForOursExternalSale
1239 
    self._processMap["scanForOursExternalSaleReturn"] = Processor.process_scanForOursExternalSaleReturn
6880 amar.kumar 1240 
    self._processMap["getMovementNonSerializedInventoryByScans"] = Processor.process_getMovementNonSerializedInventoryByScans
1241 
    self._processMap["getMovementSerializedInventoryByScans"] = Processor.process_getMovementSerializedInventoryByScans
7190 amar.kumar 1242 
    self._processMap["scanfreebie"] = Processor.process_scanfreebie
2821 chandransh 1243 
 
1244 
  def process(self, iprot, oprot):
1245 
    (name, type, seqid) = iprot.readMessageBegin()
1246 
    if name not in self._processMap:
1247 
      iprot.skip(TType.STRUCT)
1248 
      iprot.readMessageEnd()
1249 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1250 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1251 
      x.write(oprot)
1252 
      oprot.writeMessageEnd()
1253 
      oprot.trans.flush()
1254 
      return
1255 
    else:
1256 
      self._processMap[name](self, seqid, iprot, oprot)
1257 
    return True
1258 
 
4501 mandeep.dh 1259 
  def process_getInventoryItem(self, seqid, iprot, oprot):
1260 
    args = getInventoryItem_args()
2832 chandransh 1261 
    args.read(iprot)
1262 
    iprot.readMessageEnd()
4501 mandeep.dh 1263 
    result = getInventoryItem_result()
4541 mandeep.dh 1264 
    try:
1265 
      result.success = self._handler.getInventoryItem(args.serialNumber)
1266 
    except WarehouseServiceException, wex:
1267 
      result.wex = wex
4501 mandeep.dh 1268 
    oprot.writeMessageBegin("getInventoryItem", TMessageType.REPLY, seqid)
2832 chandransh 1269 
    result.write(oprot)
1270 
    oprot.writeMessageEnd()
1271 
    oprot.trans.flush()
1272 
 
5361 mandeep.dh 1273 
  def process_getNonSeralizedInventoryItem(self, seqid, iprot, oprot):
1274 
    args = getNonSeralizedInventoryItem_args()
2821 chandransh 1275 
    args.read(iprot)
1276 
    iprot.readMessageEnd()
5361 mandeep.dh 1277 
    result = getNonSeralizedInventoryItem_result()
1278 
    try:
5530 mandeep.dh 1279 
      result.success = self._handler.getNonSeralizedInventoryItem(args.itemNumber, args.itemId, args.fulfilmentWarehouseId)
5361 mandeep.dh 1280 
    except WarehouseServiceException, wex:
1281 
      result.wex = wex
1282 
    oprot.writeMessageBegin("getNonSeralizedInventoryItem", TMessageType.REPLY, seqid)
2821 chandransh 1283 
    result.write(oprot)
1284 
    oprot.writeMessageEnd()
1285 
    oprot.trans.flush()
1286 
 
4501 mandeep.dh 1287 
  def process_scan(self, seqid, iprot, oprot):
1288 
    args = scan_args()
3383 chandransh 1289 
    args.read(iprot)
1290 
    iprot.readMessageEnd()
4501 mandeep.dh 1291 
    result = scan_result()
3383 chandransh 1292 
    try:
5361 mandeep.dh 1293 
      self._handler.scan(args.inventoryItem, args.type, args.quantity, args.billingWarehouseId)
3383 chandransh 1294 
    except WarehouseServiceException, wex:
1295 
      result.wex = wex
4501 mandeep.dh 1296 
    oprot.writeMessageBegin("scan", TMessageType.REPLY, seqid)
3383 chandransh 1297 
    result.write(oprot)
1298 
    oprot.writeMessageEnd()
1299 
    oprot.trans.flush()
1300 
 
4501 mandeep.dh 1301 
  def process_scanSerializedItemForOrder(self, seqid, iprot, oprot):
1302 
    args = scanSerializedItemForOrder_args()
2821 chandransh 1303 
    args.read(iprot)
1304 
    iprot.readMessageEnd()
4501 mandeep.dh 1305 
    result = scanSerializedItemForOrder_result()
2821 chandransh 1306 
    try:
5110 mandeep.dh 1307 
      result.success = self._handler.scanSerializedItemForOrder(args.serialNumber, args.type, args.orderId, args.fulfilmentWarehouseId, args.quantity, args.billingWarehouseId)
2821 chandransh 1308 
    except WarehouseServiceException, wex:
1309 
      result.wex = wex
4501 mandeep.dh 1310 
    oprot.writeMessageBegin("scanSerializedItemForOrder", TMessageType.REPLY, seqid)
2821 chandransh 1311 
    result.write(oprot)
1312 
    oprot.writeMessageEnd()
1313 
    oprot.trans.flush()
1314 
 
4501 mandeep.dh 1315 
  def process_scanForOrder(self, seqid, iprot, oprot):
1316 
    args = scanForOrder_args()
2821 chandransh 1317 
    args.read(iprot)
1318 
    iprot.readMessageEnd()
4501 mandeep.dh 1319 
    result = scanForOrder_result()
2821 chandransh 1320 
    try:
5361 mandeep.dh 1321 
      result.success = self._handler.scanForOrder(args.inventoryItem, args.type, args.quantity, args.orderId, args.fulfilmentWarehouseId, args.billingWarehouseId)
2821 chandransh 1322 
    except WarehouseServiceException, wex:
1323 
      result.wex = wex
4501 mandeep.dh 1324 
    oprot.writeMessageBegin("scanForOrder", TMessageType.REPLY, seqid)
2821 chandransh 1325 
    result.write(oprot)
1326 
    oprot.writeMessageEnd()
1327 
    oprot.trans.flush()
1328 
 
4501 mandeep.dh 1329 
  def process_createItemNumberMapping(self, seqid, iprot, oprot):
1330 
    args = createItemNumberMapping_args()
1331 
    args.read(iprot)
1332 
    iprot.readMessageEnd()
1333 
    result = createItemNumberMapping_result()
1334 
    self._handler.createItemNumberMapping(args.itemNumber, args.itemId)
1335 
    oprot.writeMessageBegin("createItemNumberMapping", TMessageType.REPLY, seqid)
1336 
    result.write(oprot)
1337 
    oprot.writeMessageEnd()
1338 
    oprot.trans.flush()
2821 chandransh 1339 
 
4620 amit.gupta 1340 
  def process_getItemNumbers(self, seqid, iprot, oprot):
1341 
    args = getItemNumbers_args()
1342 
    args.read(iprot)
1343 
    iprot.readMessageEnd()
1344 
    result = getItemNumbers_result()
1345 
    result.success = self._handler.getItemNumbers(args.itemId)
1346 
    oprot.writeMessageBegin("getItemNumbers", TMessageType.REPLY, seqid)
1347 
    result.write(oprot)
1348 
    oprot.writeMessageEnd()
1349 
    oprot.trans.flush()
4501 mandeep.dh 1350 
 
5110 mandeep.dh 1351 
  def process_getItemIds(self, seqid, iprot, oprot):
1352 
    args = getItemIds_args()
1353 
    args.read(iprot)
1354 
    iprot.readMessageEnd()
1355 
    result = getItemIds_result()
1356 
    result.success = self._handler.getItemIds(args.itemNumber)
1357 
    oprot.writeMessageBegin("getItemIds", TMessageType.REPLY, seqid)
1358 
    result.write(oprot)
1359 
    oprot.writeMessageEnd()
1360 
    oprot.trans.flush()
4620 amit.gupta 1361 
 
5185 mandeep.dh 1362 
  def process_getInventoryItemsFromLastScanType(self, seqid, iprot, oprot):
1363 
    args = getInventoryItemsFromLastScanType_args()
1364 
    args.read(iprot)
1365 
    iprot.readMessageEnd()
1366 
    result = getInventoryItemsFromLastScanType_result()
1367 
    try:
1368 
      result.success = self._handler.getInventoryItemsFromLastScanType(args.lastScanType)
1369 
    except WarehouseServiceException, wex:
1370 
      result.wex = wex
1371 
    oprot.writeMessageBegin("getInventoryItemsFromLastScanType", TMessageType.REPLY, seqid)
1372 
    result.write(oprot)
1373 
    oprot.writeMessageEnd()
1374 
    oprot.trans.flush()
5110 mandeep.dh 1375 
 
5185 mandeep.dh 1376 
  def process_getInventoryItemFromId(self, seqid, iprot, oprot):
1377 
    args = getInventoryItemFromId_args()
1378 
    args.read(iprot)
1379 
    iprot.readMessageEnd()
1380 
    result = getInventoryItemFromId_result()
1381 
    try:
1382 
      result.success = self._handler.getInventoryItemFromId(args.inventoryItemId)
1383 
    except WarehouseServiceException, wex:
1384 
      result.wex = wex
1385 
    oprot.writeMessageBegin("getInventoryItemFromId", TMessageType.REPLY, seqid)
1386 
    result.write(oprot)
1387 
    oprot.writeMessageEnd()
1388 
    oprot.trans.flush()
1389 
 
5372 mandeep.dh 1390 
  def process_getPurchaseScans(self, seqid, iprot, oprot):
1391 
    args = getPurchaseScans_args()
1392 
    args.read(iprot)
1393 
    iprot.readMessageEnd()
1394 
    result = getPurchaseScans_result()
1395 
    result.success = self._handler.getPurchaseScans(args.startDate, args.endDate)
1396 
    oprot.writeMessageBegin("getPurchaseScans", TMessageType.REPLY, seqid)
1397 
    result.write(oprot)
1398 
    oprot.writeMessageEnd()
1399 
    oprot.trans.flush()
5185 mandeep.dh 1400 
 
5496 mandeep.dh 1401 
  def process_fetchScansPerInvoiceNumber(self, seqid, iprot, oprot):
1402 
    args = fetchScansPerInvoiceNumber_args()
1403 
    args.read(iprot)
1404 
    iprot.readMessageEnd()
1405 
    result = fetchScansPerInvoiceNumber_result()
1406 
    result.success = self._handler.fetchScansPerInvoiceNumber(args.date)
1407 
    oprot.writeMessageBegin("fetchScansPerInvoiceNumber", TMessageType.REPLY, seqid)
1408 
    result.write(oprot)
1409 
    oprot.writeMessageEnd()
1410 
    oprot.trans.flush()
5372 mandeep.dh 1411 
 
5620 mandeep.dh 1412 
  def process_getInventoryItemFromOrder(self, seqid, iprot, oprot):
1413 
    args = getInventoryItemFromOrder_args()
1414 
    args.read(iprot)
1415 
    iprot.readMessageEnd()
1416 
    result = getInventoryItemFromOrder_result()
1417 
    try:
1418 
      result.success = self._handler.getInventoryItemFromOrder(args.orderId)
1419 
    except WarehouseServiceException, we:
1420 
      result.we = we
1421 
    oprot.writeMessageBegin("getInventoryItemFromOrder", TMessageType.REPLY, seqid)
1422 
    result.write(oprot)
1423 
    oprot.writeMessageEnd()
1424 
    oprot.trans.flush()
5496 mandeep.dh 1425 
 
5711 mandeep.dh 1426 
  def process_getInventoryAge(self, seqid, iprot, oprot):
1427 
    args = getInventoryAge_args()
1428 
    args.read(iprot)
1429 
    iprot.readMessageEnd()
1430 
    result = getInventoryAge_result()
1431 
    result.success = self._handler.getInventoryAge()
1432 
    oprot.writeMessageBegin("getInventoryAge", TMessageType.REPLY, seqid)
1433 
    result.write(oprot)
1434 
    oprot.writeMessageEnd()
1435 
    oprot.trans.flush()
5620 mandeep.dh 1436 
 
6361 rajveer 1437 
  def process_getInventoryScansForItem(self, seqid, iprot, oprot):
1438 
    args = getInventoryScansForItem_args()
1439 
    args.read(iprot)
1440 
    iprot.readMessageEnd()
1441 
    result = getInventoryScansForItem_result()
1442 
    result.success = self._handler.getInventoryScansForItem(args.itemId, args.fromDate, args.toDate)
1443 
    oprot.writeMessageBegin("getInventoryScansForItem", TMessageType.REPLY, seqid)
1444 
    result.write(oprot)
1445 
    oprot.writeMessageEnd()
1446 
    oprot.trans.flush()
5711 mandeep.dh 1447 
 
6361 rajveer 1448 
  def process_getScanRecordsForSerialNumber(self, seqid, iprot, oprot):
1449 
    args = getScanRecordsForSerialNumber_args()
1450 
    args.read(iprot)
1451 
    iprot.readMessageEnd()
1452 
    result = getScanRecordsForSerialNumber_result()
1453 
    result.success = self._handler.getScanRecordsForSerialNumber(args.serialNumber)
1454 
    oprot.writeMessageBegin("getScanRecordsForSerialNumber", TMessageType.REPLY, seqid)
1455 
    result.write(oprot)
1456 
    oprot.writeMessageEnd()
1457 
    oprot.trans.flush()
1458 
 
6467 amar.kumar 1459 
  def process_scanForPurchaseReturn(self, seqid, iprot, oprot):
1460 
    args = scanForPurchaseReturn_args()
1461 
    args.read(iprot)
1462 
    iprot.readMessageEnd()
1463 
    result = scanForPurchaseReturn_result()
1464 
    try:
1465 
      self._handler.scanForPurchaseReturn(args.saleReturnItems, args.vendorId)
1466 
    except WarehouseServiceException, ex:
1467 
      result.ex = ex
1468 
    oprot.writeMessageBegin("scanForPurchaseReturn", TMessageType.REPLY, seqid)
1469 
    result.write(oprot)
1470 
    oprot.writeMessageEnd()
1471 
    oprot.trans.flush()
6361 rajveer 1472 
 
6630 amar.kumar 1473 
  def process_scanForLostItem(self, seqid, iprot, oprot):
1474 
    args = scanForLostItem_args()
1475 
    args.read(iprot)
1476 
    iprot.readMessageEnd()
1477 
    result = scanForLostItem_result()
1478 
    try:
1479 
      self._handler.scanForLostItem(args.lostItems, args.vendorId)
1480 
    except WarehouseServiceException, ex:
1481 
      result.ex = ex
1482 
    oprot.writeMessageBegin("scanForLostItem", TMessageType.REPLY, seqid)
1483 
    result.write(oprot)
1484 
    oprot.writeMessageEnd()
1485 
    oprot.trans.flush()
6467 amar.kumar 1486 
 
6630 amar.kumar 1487 
  def process_getCurrentSerializedInventoryByScans(self, seqid, iprot, oprot):
1488 
    args = getCurrentSerializedInventoryByScans_args()
1489 
    args.read(iprot)
1490 
    iprot.readMessageEnd()
1491 
    result = getCurrentSerializedInventoryByScans_result()
1492 
    result.success = self._handler.getCurrentSerializedInventoryByScans()
1493 
    oprot.writeMessageBegin("getCurrentSerializedInventoryByScans", TMessageType.REPLY, seqid)
1494 
    result.write(oprot)
1495 
    oprot.writeMessageEnd()
1496 
    oprot.trans.flush()
1497 
 
1498 
  def process_getCurrentNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1499 
    args = getCurrentNonSerializedInventoryByScans_args()
1500 
    args.read(iprot)
1501 
    iprot.readMessageEnd()
1502 
    result = getCurrentNonSerializedInventoryByScans_result()
1503 
    result.success = self._handler.getCurrentNonSerializedInventoryByScans()
1504 
    oprot.writeMessageBegin("getCurrentNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1505 
    result.write(oprot)
1506 
    oprot.writeMessageEnd()
1507 
    oprot.trans.flush()
1508 
 
6762 amar.kumar 1509 
  def process_getHistoricSerializedInventoryByScans(self, seqid, iprot, oprot):
1510 
    args = getHistoricSerializedInventoryByScans_args()
1511 
    args.read(iprot)
1512 
    iprot.readMessageEnd()
1513 
    result = getHistoricSerializedInventoryByScans_result()
1514 
    result.success = self._handler.getHistoricSerializedInventoryByScans(args.date)
1515 
    oprot.writeMessageBegin("getHistoricSerializedInventoryByScans", TMessageType.REPLY, seqid)
1516 
    result.write(oprot)
1517 
    oprot.writeMessageEnd()
1518 
    oprot.trans.flush()
6630 amar.kumar 1519 
 
6762 amar.kumar 1520 
  def process_getHistoricNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1521 
    args = getHistoricNonSerializedInventoryByScans_args()
1522 
    args.read(iprot)
1523 
    iprot.readMessageEnd()
1524 
    result = getHistoricNonSerializedInventoryByScans_result()
1525 
    result.success = self._handler.getHistoricNonSerializedInventoryByScans(args.date)
1526 
    oprot.writeMessageBegin("getHistoricNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1527 
    result.write(oprot)
1528 
    oprot.writeMessageEnd()
1529 
    oprot.trans.flush()
1530 
 
1531 
  def process_scanForOursExternalSale(self, seqid, iprot, oprot):
1532 
    args = scanForOursExternalSale_args()
1533 
    args.read(iprot)
1534 
    iprot.readMessageEnd()
1535 
    result = scanForOursExternalSale_result()
1536 
    try:
1537 
      result.success = self._handler.scanForOursExternalSale(args.itemId, args.serialNumber, args.itemNumber, args.invoiceNumber, args.warehouseId, args.unitPrice, args.orderId)
1538 
    except WarehouseServiceException, ex:
1539 
      result.ex = ex
1540 
    oprot.writeMessageBegin("scanForOursExternalSale", TMessageType.REPLY, seqid)
1541 
    result.write(oprot)
1542 
    oprot.writeMessageEnd()
1543 
    oprot.trans.flush()
1544 
 
1545 
  def process_scanForOursExternalSaleReturn(self, seqid, iprot, oprot):
1546 
    args = scanForOursExternalSaleReturn_args()
1547 
    args.read(iprot)
1548 
    iprot.readMessageEnd()
1549 
    result = scanForOursExternalSaleReturn_result()
1550 
    self._handler.scanForOursExternalSaleReturn(args.orderId, args.unitPrice)
1551 
    oprot.writeMessageBegin("scanForOursExternalSaleReturn", TMessageType.REPLY, seqid)
1552 
    result.write(oprot)
1553 
    oprot.writeMessageEnd()
1554 
    oprot.trans.flush()
1555 
 
6880 amar.kumar 1556 
  def process_getMovementNonSerializedInventoryByScans(self, seqid, iprot, oprot):
1557 
    args = getMovementNonSerializedInventoryByScans_args()
1558 
    args.read(iprot)
1559 
    iprot.readMessageEnd()
1560 
    result = getMovementNonSerializedInventoryByScans_result()
1561 
    result.success = self._handler.getMovementNonSerializedInventoryByScans(args.startDate, args.endDate)
1562 
    oprot.writeMessageBegin("getMovementNonSerializedInventoryByScans", TMessageType.REPLY, seqid)
1563 
    result.write(oprot)
1564 
    oprot.writeMessageEnd()
1565 
    oprot.trans.flush()
6762 amar.kumar 1566 
 
6880 amar.kumar 1567 
  def process_getMovementSerializedInventoryByScans(self, seqid, iprot, oprot):
1568 
    args = getMovementSerializedInventoryByScans_args()
1569 
    args.read(iprot)
1570 
    iprot.readMessageEnd()
1571 
    result = getMovementSerializedInventoryByScans_result()
1572 
    result.success = self._handler.getMovementSerializedInventoryByScans(args.startDate, args.endDate)
1573 
    oprot.writeMessageBegin("getMovementSerializedInventoryByScans", TMessageType.REPLY, seqid)
1574 
    result.write(oprot)
1575 
    oprot.writeMessageEnd()
1576 
    oprot.trans.flush()
1577 
 
7190 amar.kumar 1578 
  def process_scanfreebie(self, seqid, iprot, oprot):
1579 
    args = scanfreebie_args()
1580 
    args.read(iprot)
1581 
    iprot.readMessageEnd()
1582 
    result = scanfreebie_result()
1583 
    try:
1584 
      result.success = self._handler.scanfreebie(args.orderId, args.freebieItemId, args.freebieWarehouseId, args.scanType)
1585 
    except WarehouseServiceException, wex:
1586 
      result.wex = wex
1587 
    oprot.writeMessageBegin("scanfreebie", TMessageType.REPLY, seqid)
1588 
    result.write(oprot)
1589 
    oprot.writeMessageEnd()
1590 
    oprot.trans.flush()
6880 amar.kumar 1591 
 
7190 amar.kumar 1592 
 
2821 chandransh 1593 
# HELPER FUNCTIONS AND STRUCTURES
1594 
 
4501 mandeep.dh 1595 
class getInventoryItem_args:
2832 chandransh 1596 
  """
1597 
  Attributes:
4501 mandeep.dh 1598 
   - serialNumber
2832 chandransh 1599 
  """
1600 
 
1601 
  thrift_spec = (
1602 
    None, # 0
4501 mandeep.dh 1603 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
2832 chandransh 1604 
  )
1605 
 
4501 mandeep.dh 1606 
  def __init__(self, serialNumber=None,):
1607 
    self.serialNumber = serialNumber
2832 chandransh 1608 
 
1609 
  def read(self, iprot):
1610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1612 
      return
1613 
    iprot.readStructBegin()
1614 
    while True:
1615 
      (fname, ftype, fid) = iprot.readFieldBegin()
1616 
      if ftype == TType.STOP:
1617 
        break
1618 
      if fid == 1:
4501 mandeep.dh 1619 
        if ftype == TType.STRING:
1620 
          self.serialNumber = iprot.readString();
2832 chandransh 1621 
        else:
1622 
          iprot.skip(ftype)
1623 
      else:
1624 
        iprot.skip(ftype)
1625 
      iprot.readFieldEnd()
1626 
    iprot.readStructEnd()
1627 
 
1628 
  def write(self, oprot):
1629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1631 
      return
4501 mandeep.dh 1632 
    oprot.writeStructBegin('getInventoryItem_args')
1633 
    if self.serialNumber is not None:
1634 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
1635 
      oprot.writeString(self.serialNumber)
2832 chandransh 1636 
      oprot.writeFieldEnd()
1637 
    oprot.writeFieldStop()
1638 
    oprot.writeStructEnd()
1639 
 
3431 rajveer 1640 
  def validate(self):
1641 
    return
1642 
 
1643 
 
2832 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 
 
4501 mandeep.dh 1655 
class getInventoryItem_result:
2832 chandransh 1656 
  """
1657 
  Attributes:
1658 
   - success
4541 mandeep.dh 1659 
   - wex
2832 chandransh 1660 
  """
1661 
 
1662 
  thrift_spec = (
4501 mandeep.dh 1663 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4541 mandeep.dh 1664 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2832 chandransh 1665 
  )
1666 
 
4541 mandeep.dh 1667 
  def __init__(self, success=None, wex=None,):
2832 chandransh 1668 
    self.success = success
4541 mandeep.dh 1669 
    self.wex = wex
2832 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:
1681 
        if ftype == TType.STRUCT:
4501 mandeep.dh 1682 
          self.success = InventoryItem()
2832 chandransh 1683 
          self.success.read(iprot)
1684 
        else:
1685 
          iprot.skip(ftype)
4541 mandeep.dh 1686 
      elif fid == 1:
1687 
        if ftype == TType.STRUCT:
1688 
          self.wex = WarehouseServiceException()
1689 
          self.wex.read(iprot)
1690 
        else:
1691 
          iprot.skip(ftype)
2832 chandransh 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
4501 mandeep.dh 1701 
    oprot.writeStructBegin('getInventoryItem_result')
3431 rajveer 1702 
    if self.success is not None:
2832 chandransh 1703 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1704 
      self.success.write(oprot)
1705 
      oprot.writeFieldEnd()
4541 mandeep.dh 1706 
    if self.wex is not None:
1707 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1708 
      self.wex.write(oprot)
1709 
      oprot.writeFieldEnd()
2832 chandransh 1710 
    oprot.writeFieldStop()
1711 
    oprot.writeStructEnd()
1712 
 
3431 rajveer 1713 
  def validate(self):
1714 
    return
1715 
 
1716 
 
2832 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 
 
5361 mandeep.dh 1728 
class getNonSeralizedInventoryItem_args:
2821 chandransh 1729 
  """
1730 
  Attributes:
5530 mandeep.dh 1731 
   - itemNumber
4501 mandeep.dh 1732 
   - itemId
5530 mandeep.dh 1733 
   - fulfilmentWarehouseId
2821 chandransh 1734 
  """
1735 
 
1736 
  thrift_spec = (
1737 
    None, # 0
5530 mandeep.dh 1738 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
1739 
    (2, TType.I64, 'itemId', None, None, ), # 2
1740 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
2821 chandransh 1741 
  )
1742 
 
5530 mandeep.dh 1743 
  def __init__(self, itemNumber=None, itemId=None, fulfilmentWarehouseId=None,):
1744 
    self.itemNumber = itemNumber
4501 mandeep.dh 1745 
    self.itemId = itemId
5530 mandeep.dh 1746 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
2821 chandransh 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:
5530 mandeep.dh 1758 
        if ftype == TType.STRING:
1759 
          self.itemNumber = iprot.readString();
1760 
        else:
1761 
          iprot.skip(ftype)
1762 
      elif fid == 2:
2821 chandransh 1763 
        if ftype == TType.I64:
4501 mandeep.dh 1764 
          self.itemId = iprot.readI64();
2821 chandransh 1765 
        else:
1766 
          iprot.skip(ftype)
5530 mandeep.dh 1767 
      elif fid == 3:
4501 mandeep.dh 1768 
        if ftype == TType.I64:
5530 mandeep.dh 1769 
          self.fulfilmentWarehouseId = iprot.readI64();
2821 chandransh 1770 
        else:
1771 
          iprot.skip(ftype)
1772 
      else:
1773 
        iprot.skip(ftype)
1774 
      iprot.readFieldEnd()
1775 
    iprot.readStructEnd()
1776 
 
1777 
  def write(self, oprot):
1778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1780 
      return
5361 mandeep.dh 1781 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_args')
5530 mandeep.dh 1782 
    if self.itemNumber is not None:
1783 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
1784 
      oprot.writeString(self.itemNumber)
1785 
      oprot.writeFieldEnd()
4501 mandeep.dh 1786 
    if self.itemId is not None:
5530 mandeep.dh 1787 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
4501 mandeep.dh 1788 
      oprot.writeI64(self.itemId)
2821 chandransh 1789 
      oprot.writeFieldEnd()
5530 mandeep.dh 1790 
    if self.fulfilmentWarehouseId is not None:
1791 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
1792 
      oprot.writeI64(self.fulfilmentWarehouseId)
2821 chandransh 1793 
      oprot.writeFieldEnd()
1794 
    oprot.writeFieldStop()
1795 
    oprot.writeStructEnd()
1796 
 
3431 rajveer 1797 
  def validate(self):
1798 
    return
1799 
 
1800 
 
2821 chandransh 1801 
  def __repr__(self):
1802 
    L = ['%s=%r' % (key, value)
1803 
      for key, value in self.__dict__.iteritems()]
1804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1805 
 
1806 
  def __eq__(self, other):
1807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1808 
 
1809 
  def __ne__(self, other):
1810 
    return not (self == other)
1811 
 
5361 mandeep.dh 1812 
class getNonSeralizedInventoryItem_result:
2821 chandransh 1813 
  """
1814 
  Attributes:
1815 
   - success
5361 mandeep.dh 1816 
   - wex
2821 chandransh 1817 
  """
1818 
 
1819 
  thrift_spec = (
5361 mandeep.dh 1820 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
1821 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2821 chandransh 1822 
  )
1823 
 
5361 mandeep.dh 1824 
  def __init__(self, success=None, wex=None,):
2821 chandransh 1825 
    self.success = success
5361 mandeep.dh 1826 
    self.wex = wex
2821 chandransh 1827 
 
1828 
  def read(self, iprot):
1829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1831 
      return
1832 
    iprot.readStructBegin()
1833 
    while True:
1834 
      (fname, ftype, fid) = iprot.readFieldBegin()
1835 
      if ftype == TType.STOP:
1836 
        break
1837 
      if fid == 0:
5361 mandeep.dh 1838 
        if ftype == TType.STRUCT:
1839 
          self.success = InventoryItem()
1840 
          self.success.read(iprot)
2821 chandransh 1841 
        else:
1842 
          iprot.skip(ftype)
5361 mandeep.dh 1843 
      elif fid == 1:
1844 
        if ftype == TType.STRUCT:
1845 
          self.wex = WarehouseServiceException()
1846 
          self.wex.read(iprot)
2821 chandransh 1847 
        else:
1848 
          iprot.skip(ftype)
1849 
      else:
1850 
        iprot.skip(ftype)
1851 
      iprot.readFieldEnd()
1852 
    iprot.readStructEnd()
1853 
 
1854 
  def write(self, oprot):
1855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1857 
      return
5361 mandeep.dh 1858 
    oprot.writeStructBegin('getNonSeralizedInventoryItem_result')
3431 rajveer 1859 
    if self.success is not None:
5361 mandeep.dh 1860 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
1861 
      self.success.write(oprot)
2821 chandransh 1862 
      oprot.writeFieldEnd()
5361 mandeep.dh 1863 
    if self.wex is not None:
1864 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
1865 
      self.wex.write(oprot)
3383 chandransh 1866 
      oprot.writeFieldEnd()
1867 
    oprot.writeFieldStop()
1868 
    oprot.writeStructEnd()
1869 
 
3431 rajveer 1870 
  def validate(self):
1871 
    return
1872 
 
1873 
 
3383 chandransh 1874 
  def __repr__(self):
1875 
    L = ['%s=%r' % (key, value)
1876 
      for key, value in self.__dict__.iteritems()]
1877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1878 
 
1879 
  def __eq__(self, other):
1880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1881 
 
1882 
  def __ne__(self, other):
1883 
    return not (self == other)
1884 
 
4501 mandeep.dh 1885 
class scan_args:
2821 chandransh 1886 
  """
1887 
  Attributes:
5361 mandeep.dh 1888 
   - inventoryItem
2821 chandransh 1889 
   - type
4501 mandeep.dh 1890 
   - quantity
5361 mandeep.dh 1891 
   - billingWarehouseId
2821 chandransh 1892 
  """
1893 
 
1894 
  thrift_spec = (
1895 
    None, # 0
5361 mandeep.dh 1896 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 1897 
    (2, TType.I32, 'type', None, None, ), # 2
1898 
    (3, TType.I64, 'quantity', None, None, ), # 3
5361 mandeep.dh 1899 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
2821 chandransh 1900 
  )
1901 
 
5361 mandeep.dh 1902 
  def __init__(self, inventoryItem=None, type=None, quantity=None, billingWarehouseId=None,):
1903 
    self.inventoryItem = inventoryItem
2821 chandransh 1904 
    self.type = type
4501 mandeep.dh 1905 
    self.quantity = quantity
5361 mandeep.dh 1906 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 1907 
 
1908 
  def read(self, iprot):
1909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1911 
      return
1912 
    iprot.readStructBegin()
1913 
    while True:
1914 
      (fname, ftype, fid) = iprot.readFieldBegin()
1915 
      if ftype == TType.STOP:
1916 
        break
1917 
      if fid == 1:
5361 mandeep.dh 1918 
        if ftype == TType.STRUCT:
1919 
          self.inventoryItem = InventoryItem()
1920 
          self.inventoryItem.read(iprot)
2821 chandransh 1921 
        else:
1922 
          iprot.skip(ftype)
1923 
      elif fid == 2:
4501 mandeep.dh 1924 
        if ftype == TType.I32:
1925 
          self.type = iprot.readI32();
2821 chandransh 1926 
        else:
1927 
          iprot.skip(ftype)
3383 chandransh 1928 
      elif fid == 3:
4501 mandeep.dh 1929 
        if ftype == TType.I64:
1930 
          self.quantity = iprot.readI64();
2821 chandransh 1931 
        else:
1932 
          iprot.skip(ftype)
3383 chandransh 1933 
      elif fid == 4:
4501 mandeep.dh 1934 
        if ftype == TType.I64:
5361 mandeep.dh 1935 
          self.billingWarehouseId = iprot.readI64();
2821 chandransh 1936 
        else:
1937 
          iprot.skip(ftype)
1938 
      else:
1939 
        iprot.skip(ftype)
1940 
      iprot.readFieldEnd()
1941 
    iprot.readStructEnd()
1942 
 
1943 
  def write(self, oprot):
1944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
1945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
1946 
      return
4501 mandeep.dh 1947 
    oprot.writeStructBegin('scan_args')
5361 mandeep.dh 1948 
    if self.inventoryItem is not None:
1949 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
1950 
      self.inventoryItem.write(oprot)
2821 chandransh 1951 
      oprot.writeFieldEnd()
3431 rajveer 1952 
    if self.type is not None:
4501 mandeep.dh 1953 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 1954 
      oprot.writeI32(self.type)
1955 
      oprot.writeFieldEnd()
4501 mandeep.dh 1956 
    if self.quantity is not None:
1957 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
1958 
      oprot.writeI64(self.quantity)
1959 
      oprot.writeFieldEnd()
5361 mandeep.dh 1960 
    if self.billingWarehouseId is not None:
1961 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
1962 
      oprot.writeI64(self.billingWarehouseId)
4501 mandeep.dh 1963 
      oprot.writeFieldEnd()
2821 chandransh 1964 
    oprot.writeFieldStop()
1965 
    oprot.writeStructEnd()
1966 
 
3431 rajveer 1967 
  def validate(self):
1968 
    return
1969 
 
1970 
 
2821 chandransh 1971 
  def __repr__(self):
1972 
    L = ['%s=%r' % (key, value)
1973 
      for key, value in self.__dict__.iteritems()]
1974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
1975 
 
1976 
  def __eq__(self, other):
1977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
1978 
 
1979 
  def __ne__(self, other):
1980 
    return not (self == other)
1981 
 
4501 mandeep.dh 1982 
class scan_result:
2821 chandransh 1983 
  """
1984 
  Attributes:
1985 
   - wex
1986 
  """
1987 
 
1988 
  thrift_spec = (
1989 
    None, # 0
1990 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
1991 
  )
1992 
 
1993 
  def __init__(self, wex=None,):
1994 
    self.wex = wex
1995 
 
1996 
  def read(self, iprot):
1997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
1998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
1999 
      return
2000 
    iprot.readStructBegin()
2001 
    while True:
2002 
      (fname, ftype, fid) = iprot.readFieldBegin()
2003 
      if ftype == TType.STOP:
2004 
        break
2005 
      if fid == 1:
2006 
        if ftype == TType.STRUCT:
2007 
          self.wex = WarehouseServiceException()
2008 
          self.wex.read(iprot)
2009 
        else:
2010 
          iprot.skip(ftype)
2011 
      else:
2012 
        iprot.skip(ftype)
2013 
      iprot.readFieldEnd()
2014 
    iprot.readStructEnd()
2015 
 
2016 
  def write(self, oprot):
2017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2019 
      return
4501 mandeep.dh 2020 
    oprot.writeStructBegin('scan_result')
3431 rajveer 2021 
    if self.wex is not None:
2821 chandransh 2022 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2023 
      self.wex.write(oprot)
2024 
      oprot.writeFieldEnd()
2025 
    oprot.writeFieldStop()
2026 
    oprot.writeStructEnd()
2027 
 
3431 rajveer 2028 
  def validate(self):
2029 
    return
2030 
 
2031 
 
2821 chandransh 2032 
  def __repr__(self):
2033 
    L = ['%s=%r' % (key, value)
2034 
      for key, value in self.__dict__.iteritems()]
2035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2036 
 
2037 
  def __eq__(self, other):
2038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2039 
 
2040 
  def __ne__(self, other):
2041 
    return not (self == other)
2042 
 
4501 mandeep.dh 2043 
class scanSerializedItemForOrder_args:
2821 chandransh 2044 
  """
2045 
  Attributes:
4555 mandeep.dh 2046 
   - serialNumber
2821 chandransh 2047 
   - type
4501 mandeep.dh 2048 
   - orderId
5110 mandeep.dh 2049 
   - fulfilmentWarehouseId
2050 
   - quantity
2051 
   - billingWarehouseId
2821 chandransh 2052 
  """
2053 
 
2054 
  thrift_spec = (
2055 
    None, # 0
4555 mandeep.dh 2056 
    (1, TType.STRING, 'serialNumber', None, None, ), # 1
4501 mandeep.dh 2057 
    (2, TType.I32, 'type', None, None, ), # 2
2058 
    (3, TType.I64, 'orderId', None, None, ), # 3
5110 mandeep.dh 2059 
    (4, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 4
2060 
    (5, TType.DOUBLE, 'quantity', None, None, ), # 5
2061 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
2821 chandransh 2062 
  )
2063 
 
5110 mandeep.dh 2064 
  def __init__(self, serialNumber=None, type=None, orderId=None, fulfilmentWarehouseId=None, quantity=None, billingWarehouseId=None,):
4555 mandeep.dh 2065 
    self.serialNumber = serialNumber
2821 chandransh 2066 
    self.type = type
4501 mandeep.dh 2067 
    self.orderId = orderId
5110 mandeep.dh 2068 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
2069 
    self.quantity = quantity
2070 
    self.billingWarehouseId = billingWarehouseId
2821 chandransh 2071 
 
2072 
  def read(self, iprot):
2073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2075 
      return
2076 
    iprot.readStructBegin()
2077 
    while True:
2078 
      (fname, ftype, fid) = iprot.readFieldBegin()
2079 
      if ftype == TType.STOP:
2080 
        break
2081 
      if fid == 1:
4555 mandeep.dh 2082 
        if ftype == TType.STRING:
2083 
          self.serialNumber = iprot.readString();
2821 chandransh 2084 
        else:
2085 
          iprot.skip(ftype)
2086 
      elif fid == 2:
4501 mandeep.dh 2087 
        if ftype == TType.I32:
2088 
          self.type = iprot.readI32();
2821 chandransh 2089 
        else:
2090 
          iprot.skip(ftype)
2091 
      elif fid == 3:
4501 mandeep.dh 2092 
        if ftype == TType.I64:
2093 
          self.orderId = iprot.readI64();
2094 
        else:
2095 
          iprot.skip(ftype)
2096 
      elif fid == 4:
2097 
        if ftype == TType.I64:
5110 mandeep.dh 2098 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 2099 
        else:
2100 
          iprot.skip(ftype)
5110 mandeep.dh 2101 
      elif fid == 5:
2102 
        if ftype == TType.DOUBLE:
2103 
          self.quantity = iprot.readDouble();
2104 
        else:
2105 
          iprot.skip(ftype)
2106 
      elif fid == 6:
2107 
        if ftype == TType.I64:
2108 
          self.billingWarehouseId = iprot.readI64();
2109 
        else:
2110 
          iprot.skip(ftype)
4501 mandeep.dh 2111 
      else:
2112 
        iprot.skip(ftype)
2113 
      iprot.readFieldEnd()
2114 
    iprot.readStructEnd()
2115 
 
2116 
  def write(self, oprot):
2117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2119 
      return
2120 
    oprot.writeStructBegin('scanSerializedItemForOrder_args')
4555 mandeep.dh 2121 
    if self.serialNumber is not None:
2122 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 1)
2123 
      oprot.writeString(self.serialNumber)
4501 mandeep.dh 2124 
      oprot.writeFieldEnd()
2125 
    if self.type is not None:
2126 
      oprot.writeFieldBegin('type', TType.I32, 2)
2127 
      oprot.writeI32(self.type)
2128 
      oprot.writeFieldEnd()
2129 
    if self.orderId is not None:
2130 
      oprot.writeFieldBegin('orderId', TType.I64, 3)
2131 
      oprot.writeI64(self.orderId)
2132 
      oprot.writeFieldEnd()
5110 mandeep.dh 2133 
    if self.fulfilmentWarehouseId is not None:
2134 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 4)
2135 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 2136 
      oprot.writeFieldEnd()
5110 mandeep.dh 2137 
    if self.quantity is not None:
2138 
      oprot.writeFieldBegin('quantity', TType.DOUBLE, 5)
2139 
      oprot.writeDouble(self.quantity)
2140 
      oprot.writeFieldEnd()
2141 
    if self.billingWarehouseId is not None:
2142 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
2143 
      oprot.writeI64(self.billingWarehouseId)
2144 
      oprot.writeFieldEnd()
4501 mandeep.dh 2145 
    oprot.writeFieldStop()
2146 
    oprot.writeStructEnd()
2147 
 
2148 
  def validate(self):
2149 
    return
2150 
 
2151 
 
2152 
  def __repr__(self):
2153 
    L = ['%s=%r' % (key, value)
2154 
      for key, value in self.__dict__.iteritems()]
2155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2156 
 
2157 
  def __eq__(self, other):
2158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2159 
 
2160 
  def __ne__(self, other):
2161 
    return not (self == other)
2162 
 
2163 
class scanSerializedItemForOrder_result:
2164 
  """
2165 
  Attributes:
2166 
   - success
2167 
   - wex
2168 
  """
2169 
 
2170 
  thrift_spec = (
4555 mandeep.dh 2171 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4501 mandeep.dh 2172 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2173 
  )
2174 
 
2175 
  def __init__(self, success=None, wex=None,):
2176 
    self.success = success
2177 
    self.wex = wex
2178 
 
2179 
  def read(self, iprot):
2180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2182 
      return
2183 
    iprot.readStructBegin()
2184 
    while True:
2185 
      (fname, ftype, fid) = iprot.readFieldBegin()
2186 
      if ftype == TType.STOP:
2187 
        break
2188 
      if fid == 0:
4555 mandeep.dh 2189 
        if ftype == TType.STRUCT:
2190 
          self.success = InventoryItem()
2191 
          self.success.read(iprot)
4501 mandeep.dh 2192 
        else:
2193 
          iprot.skip(ftype)
2194 
      elif fid == 1:
2195 
        if ftype == TType.STRUCT:
2196 
          self.wex = WarehouseServiceException()
2197 
          self.wex.read(iprot)
2198 
        else:
2199 
          iprot.skip(ftype)
2200 
      else:
2201 
        iprot.skip(ftype)
2202 
      iprot.readFieldEnd()
2203 
    iprot.readStructEnd()
2204 
 
2205 
  def write(self, oprot):
2206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2208 
      return
2209 
    oprot.writeStructBegin('scanSerializedItemForOrder_result')
2210 
    if self.success is not None:
4555 mandeep.dh 2211 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2212 
      self.success.write(oprot)
4501 mandeep.dh 2213 
      oprot.writeFieldEnd()
2214 
    if self.wex is not None:
2215 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2216 
      self.wex.write(oprot)
2217 
      oprot.writeFieldEnd()
2218 
    oprot.writeFieldStop()
2219 
    oprot.writeStructEnd()
2220 
 
2221 
  def validate(self):
2222 
    return
2223 
 
2224 
 
2225 
  def __repr__(self):
2226 
    L = ['%s=%r' % (key, value)
2227 
      for key, value in self.__dict__.iteritems()]
2228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2229 
 
2230 
  def __eq__(self, other):
2231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2232 
 
2233 
  def __ne__(self, other):
2234 
    return not (self == other)
2235 
 
2236 
class scanForOrder_args:
2237 
  """
2238 
  Attributes:
5361 mandeep.dh 2239 
   - inventoryItem
4501 mandeep.dh 2240 
   - type
2241 
   - quantity
2242 
   - orderId
5110 mandeep.dh 2243 
   - fulfilmentWarehouseId
5361 mandeep.dh 2244 
   - billingWarehouseId
4501 mandeep.dh 2245 
  """
2246 
 
2247 
  thrift_spec = (
2248 
    None, # 0
5361 mandeep.dh 2249 
    (1, TType.STRUCT, 'inventoryItem', (InventoryItem, InventoryItem.thrift_spec), None, ), # 1
4501 mandeep.dh 2250 
    (2, TType.I32, 'type', None, None, ), # 2
2251 
    (3, TType.I64, 'quantity', None, None, ), # 3
2252 
    (4, TType.I64, 'orderId', None, None, ), # 4
5110 mandeep.dh 2253 
    (5, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 5
5361 mandeep.dh 2254 
    (6, TType.I64, 'billingWarehouseId', None, None, ), # 6
4501 mandeep.dh 2255 
  )
2256 
 
5361 mandeep.dh 2257 
  def __init__(self, inventoryItem=None, type=None, quantity=None, orderId=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
2258 
    self.inventoryItem = inventoryItem
4501 mandeep.dh 2259 
    self.type = type
2260 
    self.quantity = quantity
2261 
    self.orderId = orderId
5110 mandeep.dh 2262 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
5361 mandeep.dh 2263 
    self.billingWarehouseId = billingWarehouseId
4501 mandeep.dh 2264 
 
2265 
  def read(self, iprot):
2266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2268 
      return
2269 
    iprot.readStructBegin()
2270 
    while True:
2271 
      (fname, ftype, fid) = iprot.readFieldBegin()
2272 
      if ftype == TType.STOP:
2273 
        break
2274 
      if fid == 1:
5361 mandeep.dh 2275 
        if ftype == TType.STRUCT:
2276 
          self.inventoryItem = InventoryItem()
2277 
          self.inventoryItem.read(iprot)
4501 mandeep.dh 2278 
        else:
2279 
          iprot.skip(ftype)
2280 
      elif fid == 2:
2821 chandransh 2281 
        if ftype == TType.I32:
2282 
          self.type = iprot.readI32();
2283 
        else:
2284 
          iprot.skip(ftype)
4501 mandeep.dh 2285 
      elif fid == 3:
2286 
        if ftype == TType.I64:
2287 
          self.quantity = iprot.readI64();
2288 
        else:
2289 
          iprot.skip(ftype)
2290 
      elif fid == 4:
2291 
        if ftype == TType.I64:
2292 
          self.orderId = iprot.readI64();
2293 
        else:
2294 
          iprot.skip(ftype)
2295 
      elif fid == 5:
2296 
        if ftype == TType.I64:
5110 mandeep.dh 2297 
          self.fulfilmentWarehouseId = iprot.readI64();
4501 mandeep.dh 2298 
        else:
2299 
          iprot.skip(ftype)
5361 mandeep.dh 2300 
      elif fid == 6:
2301 
        if ftype == TType.I64:
2302 
          self.billingWarehouseId = iprot.readI64();
2303 
        else:
2304 
          iprot.skip(ftype)
2821 chandransh 2305 
      else:
2306 
        iprot.skip(ftype)
2307 
      iprot.readFieldEnd()
2308 
    iprot.readStructEnd()
2309 
 
2310 
  def write(self, oprot):
2311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2313 
      return
4501 mandeep.dh 2314 
    oprot.writeStructBegin('scanForOrder_args')
5361 mandeep.dh 2315 
    if self.inventoryItem is not None:
2316 
      oprot.writeFieldBegin('inventoryItem', TType.STRUCT, 1)
2317 
      self.inventoryItem.write(oprot)
2821 chandransh 2318 
      oprot.writeFieldEnd()
3431 rajveer 2319 
    if self.type is not None:
4501 mandeep.dh 2320 
      oprot.writeFieldBegin('type', TType.I32, 2)
2821 chandransh 2321 
      oprot.writeI32(self.type)
2322 
      oprot.writeFieldEnd()
4501 mandeep.dh 2323 
    if self.quantity is not None:
2324 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
2325 
      oprot.writeI64(self.quantity)
2326 
      oprot.writeFieldEnd()
2327 
    if self.orderId is not None:
2328 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
2329 
      oprot.writeI64(self.orderId)
2330 
      oprot.writeFieldEnd()
5110 mandeep.dh 2331 
    if self.fulfilmentWarehouseId is not None:
2332 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 5)
2333 
      oprot.writeI64(self.fulfilmentWarehouseId)
4501 mandeep.dh 2334 
      oprot.writeFieldEnd()
5361 mandeep.dh 2335 
    if self.billingWarehouseId is not None:
2336 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 6)
2337 
      oprot.writeI64(self.billingWarehouseId)
2338 
      oprot.writeFieldEnd()
2821 chandransh 2339 
    oprot.writeFieldStop()
2340 
    oprot.writeStructEnd()
2341 
 
3431 rajveer 2342 
  def validate(self):
2343 
    return
2344 
 
2345 
 
2821 chandransh 2346 
  def __repr__(self):
2347 
    L = ['%s=%r' % (key, value)
2348 
      for key, value in self.__dict__.iteritems()]
2349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2350 
 
2351 
  def __eq__(self, other):
2352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2353 
 
2354 
  def __ne__(self, other):
2355 
    return not (self == other)
2356 
 
4501 mandeep.dh 2357 
class scanForOrder_result:
2821 chandransh 2358 
  """
2359 
  Attributes:
5361 mandeep.dh 2360 
   - success
2821 chandransh 2361 
   - wex
2362 
  """
2363 
 
2364 
  thrift_spec = (
5361 mandeep.dh 2365 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
2821 chandransh 2366 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2367 
  )
2368 
 
5361 mandeep.dh 2369 
  def __init__(self, success=None, wex=None,):
2370 
    self.success = success
2821 chandransh 2371 
    self.wex = wex
2372 
 
2373 
  def read(self, iprot):
2374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2376 
      return
2377 
    iprot.readStructBegin()
2378 
    while True:
2379 
      (fname, ftype, fid) = iprot.readFieldBegin()
2380 
      if ftype == TType.STOP:
2381 
        break
5361 mandeep.dh 2382 
      if fid == 0:
2821 chandransh 2383 
        if ftype == TType.STRUCT:
5361 mandeep.dh 2384 
          self.success = InventoryItem()
2385 
          self.success.read(iprot)
2386 
        else:
2387 
          iprot.skip(ftype)
2388 
      elif fid == 1:
2389 
        if ftype == TType.STRUCT:
2821 chandransh 2390 
          self.wex = WarehouseServiceException()
2391 
          self.wex.read(iprot)
2392 
        else:
2393 
          iprot.skip(ftype)
2394 
      else:
2395 
        iprot.skip(ftype)
2396 
      iprot.readFieldEnd()
2397 
    iprot.readStructEnd()
2398 
 
2399 
  def write(self, oprot):
2400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2402 
      return
4501 mandeep.dh 2403 
    oprot.writeStructBegin('scanForOrder_result')
5361 mandeep.dh 2404 
    if self.success is not None:
2405 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2406 
      self.success.write(oprot)
2407 
      oprot.writeFieldEnd()
3431 rajveer 2408 
    if self.wex is not None:
2821 chandransh 2409 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2410 
      self.wex.write(oprot)
2411 
      oprot.writeFieldEnd()
2412 
    oprot.writeFieldStop()
2413 
    oprot.writeStructEnd()
2414 
 
3431 rajveer 2415 
  def validate(self):
2416 
    return
2417 
 
2418 
 
2821 chandransh 2419 
  def __repr__(self):
2420 
    L = ['%s=%r' % (key, value)
2421 
      for key, value in self.__dict__.iteritems()]
2422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2423 
 
2424 
  def __eq__(self, other):
2425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2426 
 
2427 
  def __ne__(self, other):
2428 
    return not (self == other)
4501 mandeep.dh 2429 
 
2430 
class createItemNumberMapping_args:
2431 
  """
2432 
  Attributes:
2433 
   - itemNumber
2434 
   - itemId
2435 
  """
2436 
 
2437 
  thrift_spec = (
2438 
    None, # 0
2439 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2440 
    (2, TType.I64, 'itemId', None, None, ), # 2
2441 
  )
2442 
 
2443 
  def __init__(self, itemNumber=None, itemId=None,):
2444 
    self.itemNumber = itemNumber
2445 
    self.itemId = itemId
2446 
 
2447 
  def read(self, iprot):
2448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2450 
      return
2451 
    iprot.readStructBegin()
2452 
    while True:
2453 
      (fname, ftype, fid) = iprot.readFieldBegin()
2454 
      if ftype == TType.STOP:
2455 
        break
2456 
      if fid == 1:
2457 
        if ftype == TType.STRING:
2458 
          self.itemNumber = iprot.readString();
2459 
        else:
2460 
          iprot.skip(ftype)
2461 
      elif fid == 2:
2462 
        if ftype == TType.I64:
2463 
          self.itemId = iprot.readI64();
2464 
        else:
2465 
          iprot.skip(ftype)
2466 
      else:
2467 
        iprot.skip(ftype)
2468 
      iprot.readFieldEnd()
2469 
    iprot.readStructEnd()
2470 
 
2471 
  def write(self, oprot):
2472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2474 
      return
2475 
    oprot.writeStructBegin('createItemNumberMapping_args')
2476 
    if self.itemNumber is not None:
2477 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2478 
      oprot.writeString(self.itemNumber)
2479 
      oprot.writeFieldEnd()
2480 
    if self.itemId is not None:
2481 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
2482 
      oprot.writeI64(self.itemId)
2483 
      oprot.writeFieldEnd()
2484 
    oprot.writeFieldStop()
2485 
    oprot.writeStructEnd()
2486 
 
2487 
  def validate(self):
2488 
    return
2489 
 
2490 
 
2491 
  def __repr__(self):
2492 
    L = ['%s=%r' % (key, value)
2493 
      for key, value in self.__dict__.iteritems()]
2494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2495 
 
2496 
  def __eq__(self, other):
2497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2498 
 
2499 
  def __ne__(self, other):
2500 
    return not (self == other)
2501 
 
2502 
class createItemNumberMapping_result:
2503 
 
2504 
  thrift_spec = (
2505 
  )
2506 
 
2507 
  def read(self, iprot):
2508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2510 
      return
2511 
    iprot.readStructBegin()
2512 
    while True:
2513 
      (fname, ftype, fid) = iprot.readFieldBegin()
2514 
      if ftype == TType.STOP:
2515 
        break
2516 
      else:
2517 
        iprot.skip(ftype)
2518 
      iprot.readFieldEnd()
2519 
    iprot.readStructEnd()
2520 
 
2521 
  def write(self, oprot):
2522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2524 
      return
2525 
    oprot.writeStructBegin('createItemNumberMapping_result')
2526 
    oprot.writeFieldStop()
2527 
    oprot.writeStructEnd()
2528 
 
2529 
  def validate(self):
2530 
    return
2531 
 
2532 
 
2533 
  def __repr__(self):
2534 
    L = ['%s=%r' % (key, value)
2535 
      for key, value in self.__dict__.iteritems()]
2536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2537 
 
2538 
  def __eq__(self, other):
2539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2540 
 
2541 
  def __ne__(self, other):
2542 
    return not (self == other)
4620 amit.gupta 2543 
 
2544 
class getItemNumbers_args:
2545 
  """
2546 
  Attributes:
2547 
   - itemId
2548 
  """
2549 
 
2550 
  thrift_spec = (
2551 
    None, # 0
2552 
    (1, TType.I64, 'itemId', None, None, ), # 1
2553 
  )
2554 
 
2555 
  def __init__(self, itemId=None,):
2556 
    self.itemId = itemId
2557 
 
2558 
  def read(self, iprot):
2559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2561 
      return
2562 
    iprot.readStructBegin()
2563 
    while True:
2564 
      (fname, ftype, fid) = iprot.readFieldBegin()
2565 
      if ftype == TType.STOP:
2566 
        break
2567 
      if fid == 1:
2568 
        if ftype == TType.I64:
2569 
          self.itemId = iprot.readI64();
2570 
        else:
2571 
          iprot.skip(ftype)
2572 
      else:
2573 
        iprot.skip(ftype)
2574 
      iprot.readFieldEnd()
2575 
    iprot.readStructEnd()
2576 
 
2577 
  def write(self, oprot):
2578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2580 
      return
2581 
    oprot.writeStructBegin('getItemNumbers_args')
2582 
    if self.itemId is not None:
2583 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
2584 
      oprot.writeI64(self.itemId)
2585 
      oprot.writeFieldEnd()
2586 
    oprot.writeFieldStop()
2587 
    oprot.writeStructEnd()
2588 
 
2589 
  def validate(self):
2590 
    return
2591 
 
2592 
 
2593 
  def __repr__(self):
2594 
    L = ['%s=%r' % (key, value)
2595 
      for key, value in self.__dict__.iteritems()]
2596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2597 
 
2598 
  def __eq__(self, other):
2599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2600 
 
2601 
  def __ne__(self, other):
2602 
    return not (self == other)
2603 
 
2604 
class getItemNumbers_result:
2605 
  """
2606 
  Attributes:
2607 
   - success
2608 
  """
2609 
 
2610 
  thrift_spec = (
2611 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
2612 
  )
2613 
 
2614 
  def __init__(self, success=None,):
2615 
    self.success = success
2616 
 
2617 
  def read(self, iprot):
2618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2620 
      return
2621 
    iprot.readStructBegin()
2622 
    while True:
2623 
      (fname, ftype, fid) = iprot.readFieldBegin()
2624 
      if ftype == TType.STOP:
2625 
        break
2626 
      if fid == 0:
2627 
        if ftype == TType.LIST:
2628 
          self.success = []
5361 mandeep.dh 2629 
          (_etype3, _size0) = iprot.readListBegin()
2630 
          for _i4 in xrange(_size0):
2631 
            _elem5 = iprot.readString();
2632 
            self.success.append(_elem5)
4620 amit.gupta 2633 
          iprot.readListEnd()
2634 
        else:
2635 
          iprot.skip(ftype)
2636 
      else:
2637 
        iprot.skip(ftype)
2638 
      iprot.readFieldEnd()
2639 
    iprot.readStructEnd()
2640 
 
2641 
  def write(self, oprot):
2642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2644 
      return
2645 
    oprot.writeStructBegin('getItemNumbers_result')
2646 
    if self.success is not None:
2647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2648 
      oprot.writeListBegin(TType.STRING, len(self.success))
5361 mandeep.dh 2649 
      for iter6 in self.success:
2650 
        oprot.writeString(iter6)
4620 amit.gupta 2651 
      oprot.writeListEnd()
2652 
      oprot.writeFieldEnd()
2653 
    oprot.writeFieldStop()
2654 
    oprot.writeStructEnd()
2655 
 
2656 
  def validate(self):
2657 
    return
2658 
 
2659 
 
2660 
  def __repr__(self):
2661 
    L = ['%s=%r' % (key, value)
2662 
      for key, value in self.__dict__.iteritems()]
2663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2664 
 
2665 
  def __eq__(self, other):
2666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2667 
 
2668 
  def __ne__(self, other):
2669 
    return not (self == other)
5110 mandeep.dh 2670 
 
2671 
class getItemIds_args:
2672 
  """
2673 
  Attributes:
2674 
   - itemNumber
2675 
  """
2676 
 
2677 
  thrift_spec = (
2678 
    None, # 0
2679 
    (1, TType.STRING, 'itemNumber', None, None, ), # 1
2680 
  )
2681 
 
2682 
  def __init__(self, itemNumber=None,):
2683 
    self.itemNumber = itemNumber
2684 
 
2685 
  def read(self, iprot):
2686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2688 
      return
2689 
    iprot.readStructBegin()
2690 
    while True:
2691 
      (fname, ftype, fid) = iprot.readFieldBegin()
2692 
      if ftype == TType.STOP:
2693 
        break
2694 
      if fid == 1:
2695 
        if ftype == TType.STRING:
2696 
          self.itemNumber = iprot.readString();
2697 
        else:
2698 
          iprot.skip(ftype)
2699 
      else:
2700 
        iprot.skip(ftype)
2701 
      iprot.readFieldEnd()
2702 
    iprot.readStructEnd()
2703 
 
2704 
  def write(self, oprot):
2705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2707 
      return
2708 
    oprot.writeStructBegin('getItemIds_args')
2709 
    if self.itemNumber is not None:
2710 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 1)
2711 
      oprot.writeString(self.itemNumber)
2712 
      oprot.writeFieldEnd()
2713 
    oprot.writeFieldStop()
2714 
    oprot.writeStructEnd()
2715 
 
2716 
  def validate(self):
2717 
    return
2718 
 
2719 
 
2720 
  def __repr__(self):
2721 
    L = ['%s=%r' % (key, value)
2722 
      for key, value in self.__dict__.iteritems()]
2723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2724 
 
2725 
  def __eq__(self, other):
2726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2727 
 
2728 
  def __ne__(self, other):
2729 
    return not (self == other)
2730 
 
2731 
class getItemIds_result:
2732 
  """
2733 
  Attributes:
2734 
   - success
2735 
  """
2736 
 
2737 
  thrift_spec = (
2738 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
2739 
  )
2740 
 
2741 
  def __init__(self, success=None,):
2742 
    self.success = success
2743 
 
2744 
  def read(self, iprot):
2745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2747 
      return
2748 
    iprot.readStructBegin()
2749 
    while True:
2750 
      (fname, ftype, fid) = iprot.readFieldBegin()
2751 
      if ftype == TType.STOP:
2752 
        break
2753 
      if fid == 0:
2754 
        if ftype == TType.LIST:
2755 
          self.success = []
5361 mandeep.dh 2756 
          (_etype10, _size7) = iprot.readListBegin()
2757 
          for _i11 in xrange(_size7):
2758 
            _elem12 = iprot.readI64();
2759 
            self.success.append(_elem12)
5110 mandeep.dh 2760 
          iprot.readListEnd()
2761 
        else:
2762 
          iprot.skip(ftype)
2763 
      else:
2764 
        iprot.skip(ftype)
2765 
      iprot.readFieldEnd()
2766 
    iprot.readStructEnd()
2767 
 
2768 
  def write(self, oprot):
2769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2771 
      return
2772 
    oprot.writeStructBegin('getItemIds_result')
2773 
    if self.success is not None:
2774 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2775 
      oprot.writeListBegin(TType.I64, len(self.success))
5361 mandeep.dh 2776 
      for iter13 in self.success:
2777 
        oprot.writeI64(iter13)
5110 mandeep.dh 2778 
      oprot.writeListEnd()
2779 
      oprot.writeFieldEnd()
2780 
    oprot.writeFieldStop()
2781 
    oprot.writeStructEnd()
2782 
 
2783 
  def validate(self):
2784 
    return
2785 
 
2786 
 
2787 
  def __repr__(self):
2788 
    L = ['%s=%r' % (key, value)
2789 
      for key, value in self.__dict__.iteritems()]
2790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2791 
 
2792 
  def __eq__(self, other):
2793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2794 
 
2795 
  def __ne__(self, other):
2796 
    return not (self == other)
5185 mandeep.dh 2797 
 
2798 
class getInventoryItemsFromLastScanType_args:
2799 
  """
2800 
  Attributes:
2801 
   - lastScanType
2802 
  """
2803 
 
2804 
  thrift_spec = (
2805 
    None, # 0
2806 
    (1, TType.I32, 'lastScanType', None, None, ), # 1
2807 
  )
2808 
 
2809 
  def __init__(self, lastScanType=None,):
2810 
    self.lastScanType = lastScanType
2811 
 
2812 
  def read(self, iprot):
2813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2815 
      return
2816 
    iprot.readStructBegin()
2817 
    while True:
2818 
      (fname, ftype, fid) = iprot.readFieldBegin()
2819 
      if ftype == TType.STOP:
2820 
        break
2821 
      if fid == 1:
2822 
        if ftype == TType.I32:
2823 
          self.lastScanType = iprot.readI32();
2824 
        else:
2825 
          iprot.skip(ftype)
2826 
      else:
2827 
        iprot.skip(ftype)
2828 
      iprot.readFieldEnd()
2829 
    iprot.readStructEnd()
2830 
 
2831 
  def write(self, oprot):
2832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2834 
      return
2835 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_args')
2836 
    if self.lastScanType is not None:
2837 
      oprot.writeFieldBegin('lastScanType', TType.I32, 1)
2838 
      oprot.writeI32(self.lastScanType)
2839 
      oprot.writeFieldEnd()
2840 
    oprot.writeFieldStop()
2841 
    oprot.writeStructEnd()
2842 
 
2843 
  def validate(self):
2844 
    return
2845 
 
2846 
 
2847 
  def __repr__(self):
2848 
    L = ['%s=%r' % (key, value)
2849 
      for key, value in self.__dict__.iteritems()]
2850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2851 
 
2852 
  def __eq__(self, other):
2853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2854 
 
2855 
  def __ne__(self, other):
2856 
    return not (self == other)
2857 
 
2858 
class getInventoryItemsFromLastScanType_result:
2859 
  """
2860 
  Attributes:
2861 
   - success
2862 
   - wex
2863 
  """
2864 
 
2865 
  thrift_spec = (
2866 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 0
2867 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
2868 
  )
2869 
 
2870 
  def __init__(self, success=None, wex=None,):
2871 
    self.success = success
2872 
    self.wex = wex
2873 
 
2874 
  def read(self, iprot):
2875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2877 
      return
2878 
    iprot.readStructBegin()
2879 
    while True:
2880 
      (fname, ftype, fid) = iprot.readFieldBegin()
2881 
      if ftype == TType.STOP:
2882 
        break
2883 
      if fid == 0:
2884 
        if ftype == TType.LIST:
2885 
          self.success = []
5361 mandeep.dh 2886 
          (_etype17, _size14) = iprot.readListBegin()
2887 
          for _i18 in xrange(_size14):
2888 
            _elem19 = InventoryItem()
2889 
            _elem19.read(iprot)
2890 
            self.success.append(_elem19)
5185 mandeep.dh 2891 
          iprot.readListEnd()
2892 
        else:
2893 
          iprot.skip(ftype)
2894 
      elif fid == 1:
2895 
        if ftype == TType.STRUCT:
2896 
          self.wex = WarehouseServiceException()
2897 
          self.wex.read(iprot)
2898 
        else:
2899 
          iprot.skip(ftype)
2900 
      else:
2901 
        iprot.skip(ftype)
2902 
      iprot.readFieldEnd()
2903 
    iprot.readStructEnd()
2904 
 
2905 
  def write(self, oprot):
2906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2908 
      return
2909 
    oprot.writeStructBegin('getInventoryItemsFromLastScanType_result')
2910 
    if self.success is not None:
2911 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2912 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5361 mandeep.dh 2913 
      for iter20 in self.success:
2914 
        iter20.write(oprot)
5185 mandeep.dh 2915 
      oprot.writeListEnd()
2916 
      oprot.writeFieldEnd()
2917 
    if self.wex is not None:
2918 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
2919 
      self.wex.write(oprot)
2920 
      oprot.writeFieldEnd()
2921 
    oprot.writeFieldStop()
2922 
    oprot.writeStructEnd()
2923 
 
2924 
  def validate(self):
2925 
    return
2926 
 
2927 
 
2928 
  def __repr__(self):
2929 
    L = ['%s=%r' % (key, value)
2930 
      for key, value in self.__dict__.iteritems()]
2931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2932 
 
2933 
  def __eq__(self, other):
2934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2935 
 
2936 
  def __ne__(self, other):
2937 
    return not (self == other)
2938 
 
2939 
class getInventoryItemFromId_args:
2940 
  """
2941 
  Attributes:
2942 
   - inventoryItemId
2943 
  """
2944 
 
2945 
  thrift_spec = (
2946 
    None, # 0
2947 
    (1, TType.I64, 'inventoryItemId', None, None, ), # 1
2948 
  )
2949 
 
2950 
  def __init__(self, inventoryItemId=None,):
2951 
    self.inventoryItemId = inventoryItemId
2952 
 
2953 
  def read(self, iprot):
2954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2956 
      return
2957 
    iprot.readStructBegin()
2958 
    while True:
2959 
      (fname, ftype, fid) = iprot.readFieldBegin()
2960 
      if ftype == TType.STOP:
2961 
        break
2962 
      if fid == 1:
2963 
        if ftype == TType.I64:
2964 
          self.inventoryItemId = iprot.readI64();
2965 
        else:
2966 
          iprot.skip(ftype)
2967 
      else:
2968 
        iprot.skip(ftype)
2969 
      iprot.readFieldEnd()
2970 
    iprot.readStructEnd()
2971 
 
2972 
  def write(self, oprot):
2973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2975 
      return
2976 
    oprot.writeStructBegin('getInventoryItemFromId_args')
2977 
    if self.inventoryItemId is not None:
2978 
      oprot.writeFieldBegin('inventoryItemId', TType.I64, 1)
2979 
      oprot.writeI64(self.inventoryItemId)
2980 
      oprot.writeFieldEnd()
2981 
    oprot.writeFieldStop()
2982 
    oprot.writeStructEnd()
2983 
 
2984 
  def validate(self):
2985 
    return
2986 
 
2987 
 
2988 
  def __repr__(self):
2989 
    L = ['%s=%r' % (key, value)
2990 
      for key, value in self.__dict__.iteritems()]
2991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2992 
 
2993 
  def __eq__(self, other):
2994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2995 
 
2996 
  def __ne__(self, other):
2997 
    return not (self == other)
2998 
 
2999 
class getInventoryItemFromId_result:
3000 
  """
3001 
  Attributes:
3002 
   - success
3003 
   - wex
3004 
  """
3005 
 
3006 
  thrift_spec = (
3007 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3008 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3009 
  )
3010 
 
3011 
  def __init__(self, success=None, wex=None,):
3012 
    self.success = success
3013 
    self.wex = wex
3014 
 
3015 
  def read(self, iprot):
3016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3018 
      return
3019 
    iprot.readStructBegin()
3020 
    while True:
3021 
      (fname, ftype, fid) = iprot.readFieldBegin()
3022 
      if ftype == TType.STOP:
3023 
        break
3024 
      if fid == 0:
3025 
        if ftype == TType.STRUCT:
3026 
          self.success = InventoryItem()
3027 
          self.success.read(iprot)
3028 
        else:
3029 
          iprot.skip(ftype)
3030 
      elif fid == 1:
3031 
        if ftype == TType.STRUCT:
3032 
          self.wex = WarehouseServiceException()
3033 
          self.wex.read(iprot)
3034 
        else:
3035 
          iprot.skip(ftype)
3036 
      else:
3037 
        iprot.skip(ftype)
3038 
      iprot.readFieldEnd()
3039 
    iprot.readStructEnd()
3040 
 
3041 
  def write(self, oprot):
3042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3044 
      return
3045 
    oprot.writeStructBegin('getInventoryItemFromId_result')
3046 
    if self.success is not None:
3047 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3048 
      self.success.write(oprot)
3049 
      oprot.writeFieldEnd()
3050 
    if self.wex is not None:
3051 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
3052 
      self.wex.write(oprot)
3053 
      oprot.writeFieldEnd()
3054 
    oprot.writeFieldStop()
3055 
    oprot.writeStructEnd()
3056 
 
3057 
  def validate(self):
3058 
    return
3059 
 
3060 
 
3061 
  def __repr__(self):
3062 
    L = ['%s=%r' % (key, value)
3063 
      for key, value in self.__dict__.iteritems()]
3064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3065 
 
3066 
  def __eq__(self, other):
3067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3068 
 
3069 
  def __ne__(self, other):
3070 
    return not (self == other)
5372 mandeep.dh 3071 
 
3072 
class getPurchaseScans_args:
3073 
  """
3074 
  Attributes:
3075 
   - startDate
3076 
   - endDate
3077 
  """
3078 
 
3079 
  thrift_spec = (
3080 
    None, # 0
3081 
    (1, TType.I64, 'startDate', None, None, ), # 1
3082 
    (2, TType.I64, 'endDate', None, None, ), # 2
3083 
  )
3084 
 
3085 
  def __init__(self, startDate=None, endDate=None,):
3086 
    self.startDate = startDate
3087 
    self.endDate = endDate
3088 
 
3089 
  def read(self, iprot):
3090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3092 
      return
3093 
    iprot.readStructBegin()
3094 
    while True:
3095 
      (fname, ftype, fid) = iprot.readFieldBegin()
3096 
      if ftype == TType.STOP:
3097 
        break
3098 
      if fid == 1:
3099 
        if ftype == TType.I64:
3100 
          self.startDate = iprot.readI64();
3101 
        else:
3102 
          iprot.skip(ftype)
3103 
      elif fid == 2:
3104 
        if ftype == TType.I64:
3105 
          self.endDate = iprot.readI64();
3106 
        else:
3107 
          iprot.skip(ftype)
3108 
      else:
3109 
        iprot.skip(ftype)
3110 
      iprot.readFieldEnd()
3111 
    iprot.readStructEnd()
3112 
 
3113 
  def write(self, oprot):
3114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3116 
      return
3117 
    oprot.writeStructBegin('getPurchaseScans_args')
3118 
    if self.startDate is not None:
3119 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
3120 
      oprot.writeI64(self.startDate)
3121 
      oprot.writeFieldEnd()
3122 
    if self.endDate is not None:
3123 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
3124 
      oprot.writeI64(self.endDate)
3125 
      oprot.writeFieldEnd()
3126 
    oprot.writeFieldStop()
3127 
    oprot.writeStructEnd()
3128 
 
3129 
  def validate(self):
3130 
    return
3131 
 
3132 
 
3133 
  def __repr__(self):
3134 
    L = ['%s=%r' % (key, value)
3135 
      for key, value in self.__dict__.iteritems()]
3136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3137 
 
3138 
  def __eq__(self, other):
3139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3140 
 
3141 
  def __ne__(self, other):
3142 
    return not (self == other)
3143 
 
3144 
class getPurchaseScans_result:
3145 
  """
3146 
  Attributes:
3147 
   - success
3148 
  """
3149 
 
3150 
  thrift_spec = (
3151 
    (0, TType.LIST, 'success', (TType.STRUCT,(DetailedPurchaseScan, DetailedPurchaseScan.thrift_spec)), None, ), # 0
3152 
  )
3153 
 
3154 
  def __init__(self, success=None,):
3155 
    self.success = success
3156 
 
3157 
  def read(self, iprot):
3158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3160 
      return
3161 
    iprot.readStructBegin()
3162 
    while True:
3163 
      (fname, ftype, fid) = iprot.readFieldBegin()
3164 
      if ftype == TType.STOP:
3165 
        break
3166 
      if fid == 0:
3167 
        if ftype == TType.LIST:
3168 
          self.success = []
3169 
          (_etype24, _size21) = iprot.readListBegin()
3170 
          for _i25 in xrange(_size21):
3171 
            _elem26 = DetailedPurchaseScan()
3172 
            _elem26.read(iprot)
3173 
            self.success.append(_elem26)
3174 
          iprot.readListEnd()
3175 
        else:
3176 
          iprot.skip(ftype)
3177 
      else:
3178 
        iprot.skip(ftype)
3179 
      iprot.readFieldEnd()
3180 
    iprot.readStructEnd()
3181 
 
3182 
  def write(self, oprot):
3183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3185 
      return
3186 
    oprot.writeStructBegin('getPurchaseScans_result')
3187 
    if self.success is not None:
3188 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3189 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3190 
      for iter27 in self.success:
3191 
        iter27.write(oprot)
3192 
      oprot.writeListEnd()
3193 
      oprot.writeFieldEnd()
3194 
    oprot.writeFieldStop()
3195 
    oprot.writeStructEnd()
3196 
 
3197 
  def validate(self):
3198 
    return
3199 
 
3200 
 
3201 
  def __repr__(self):
3202 
    L = ['%s=%r' % (key, value)
3203 
      for key, value in self.__dict__.iteritems()]
3204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3205 
 
3206 
  def __eq__(self, other):
3207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3208 
 
3209 
  def __ne__(self, other):
3210 
    return not (self == other)
5496 mandeep.dh 3211 
 
3212 
class fetchScansPerInvoiceNumber_args:
3213 
  """
3214 
  Attributes:
3215 
   - date
3216 
  """
3217 
 
3218 
  thrift_spec = (
3219 
    None, # 0
3220 
    (1, TType.I64, 'date', None, None, ), # 1
3221 
  )
3222 
 
3223 
  def __init__(self, date=None,):
3224 
    self.date = date
3225 
 
3226 
  def read(self, iprot):
3227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3229 
      return
3230 
    iprot.readStructBegin()
3231 
    while True:
3232 
      (fname, ftype, fid) = iprot.readFieldBegin()
3233 
      if ftype == TType.STOP:
3234 
        break
3235 
      if fid == 1:
3236 
        if ftype == TType.I64:
3237 
          self.date = iprot.readI64();
3238 
        else:
3239 
          iprot.skip(ftype)
3240 
      else:
3241 
        iprot.skip(ftype)
3242 
      iprot.readFieldEnd()
3243 
    iprot.readStructEnd()
3244 
 
3245 
  def write(self, oprot):
3246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3248 
      return
3249 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_args')
3250 
    if self.date is not None:
3251 
      oprot.writeFieldBegin('date', TType.I64, 1)
3252 
      oprot.writeI64(self.date)
3253 
      oprot.writeFieldEnd()
3254 
    oprot.writeFieldStop()
3255 
    oprot.writeStructEnd()
3256 
 
3257 
  def validate(self):
3258 
    return
3259 
 
3260 
 
3261 
  def __repr__(self):
3262 
    L = ['%s=%r' % (key, value)
3263 
      for key, value in self.__dict__.iteritems()]
3264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3265 
 
3266 
  def __eq__(self, other):
3267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3268 
 
3269 
  def __ne__(self, other):
3270 
    return not (self == other)
3271 
 
3272 
class fetchScansPerInvoiceNumber_result:
3273 
  """
3274 
  Attributes:
3275 
   - success
3276 
  """
3277 
 
3278 
  thrift_spec = (
3279 
    (0, TType.LIST, 'success', (TType.STRUCT,(InvoiceScan, InvoiceScan.thrift_spec)), None, ), # 0
3280 
  )
3281 
 
3282 
  def __init__(self, success=None,):
3283 
    self.success = success
3284 
 
3285 
  def read(self, iprot):
3286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3288 
      return
3289 
    iprot.readStructBegin()
3290 
    while True:
3291 
      (fname, ftype, fid) = iprot.readFieldBegin()
3292 
      if ftype == TType.STOP:
3293 
        break
3294 
      if fid == 0:
3295 
        if ftype == TType.LIST:
3296 
          self.success = []
3297 
          (_etype31, _size28) = iprot.readListBegin()
3298 
          for _i32 in xrange(_size28):
3299 
            _elem33 = InvoiceScan()
3300 
            _elem33.read(iprot)
3301 
            self.success.append(_elem33)
3302 
          iprot.readListEnd()
3303 
        else:
3304 
          iprot.skip(ftype)
3305 
      else:
3306 
        iprot.skip(ftype)
3307 
      iprot.readFieldEnd()
3308 
    iprot.readStructEnd()
3309 
 
3310 
  def write(self, oprot):
3311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3313 
      return
3314 
    oprot.writeStructBegin('fetchScansPerInvoiceNumber_result')
3315 
    if self.success is not None:
3316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3318 
      for iter34 in self.success:
3319 
        iter34.write(oprot)
3320 
      oprot.writeListEnd()
3321 
      oprot.writeFieldEnd()
3322 
    oprot.writeFieldStop()
3323 
    oprot.writeStructEnd()
3324 
 
3325 
  def validate(self):
3326 
    return
3327 
 
3328 
 
3329 
  def __repr__(self):
3330 
    L = ['%s=%r' % (key, value)
3331 
      for key, value in self.__dict__.iteritems()]
3332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3333 
 
3334 
  def __eq__(self, other):
3335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3336 
 
3337 
  def __ne__(self, other):
3338 
    return not (self == other)
5620 mandeep.dh 3339 
 
3340 
class getInventoryItemFromOrder_args:
3341 
  """
3342 
  Attributes:
3343 
   - orderId
3344 
  """
3345 
 
3346 
  thrift_spec = (
3347 
    None, # 0
3348 
    (1, TType.I64, 'orderId', None, None, ), # 1
3349 
  )
3350 
 
3351 
  def __init__(self, orderId=None,):
3352 
    self.orderId = orderId
3353 
 
3354 
  def read(self, iprot):
3355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3357 
      return
3358 
    iprot.readStructBegin()
3359 
    while True:
3360 
      (fname, ftype, fid) = iprot.readFieldBegin()
3361 
      if ftype == TType.STOP:
3362 
        break
3363 
      if fid == 1:
3364 
        if ftype == TType.I64:
3365 
          self.orderId = iprot.readI64();
3366 
        else:
3367 
          iprot.skip(ftype)
3368 
      else:
3369 
        iprot.skip(ftype)
3370 
      iprot.readFieldEnd()
3371 
    iprot.readStructEnd()
3372 
 
3373 
  def write(self, oprot):
3374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3376 
      return
3377 
    oprot.writeStructBegin('getInventoryItemFromOrder_args')
3378 
    if self.orderId is not None:
3379 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
3380 
      oprot.writeI64(self.orderId)
3381 
      oprot.writeFieldEnd()
3382 
    oprot.writeFieldStop()
3383 
    oprot.writeStructEnd()
3384 
 
3385 
  def validate(self):
3386 
    return
3387 
 
3388 
 
3389 
  def __repr__(self):
3390 
    L = ['%s=%r' % (key, value)
3391 
      for key, value in self.__dict__.iteritems()]
3392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3393 
 
3394 
  def __eq__(self, other):
3395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3396 
 
3397 
  def __ne__(self, other):
3398 
    return not (self == other)
3399 
 
3400 
class getInventoryItemFromOrder_result:
3401 
  """
3402 
  Attributes:
3403 
   - success
3404 
   - we
3405 
  """
3406 
 
3407 
  thrift_spec = (
3408 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
3409 
    (1, TType.STRUCT, 'we', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3410 
  )
3411 
 
3412 
  def __init__(self, success=None, we=None,):
3413 
    self.success = success
3414 
    self.we = we
3415 
 
3416 
  def read(self, iprot):
3417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3419 
      return
3420 
    iprot.readStructBegin()
3421 
    while True:
3422 
      (fname, ftype, fid) = iprot.readFieldBegin()
3423 
      if ftype == TType.STOP:
3424 
        break
3425 
      if fid == 0:
3426 
        if ftype == TType.STRUCT:
3427 
          self.success = InventoryItem()
3428 
          self.success.read(iprot)
3429 
        else:
3430 
          iprot.skip(ftype)
3431 
      elif fid == 1:
3432 
        if ftype == TType.STRUCT:
3433 
          self.we = WarehouseServiceException()
3434 
          self.we.read(iprot)
3435 
        else:
3436 
          iprot.skip(ftype)
3437 
      else:
3438 
        iprot.skip(ftype)
3439 
      iprot.readFieldEnd()
3440 
    iprot.readStructEnd()
3441 
 
3442 
  def write(self, oprot):
3443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3445 
      return
3446 
    oprot.writeStructBegin('getInventoryItemFromOrder_result')
3447 
    if self.success is not None:
3448 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3449 
      self.success.write(oprot)
3450 
      oprot.writeFieldEnd()
3451 
    if self.we is not None:
3452 
      oprot.writeFieldBegin('we', TType.STRUCT, 1)
3453 
      self.we.write(oprot)
3454 
      oprot.writeFieldEnd()
3455 
    oprot.writeFieldStop()
3456 
    oprot.writeStructEnd()
3457 
 
3458 
  def validate(self):
3459 
    return
3460 
 
3461 
 
3462 
  def __repr__(self):
3463 
    L = ['%s=%r' % (key, value)
3464 
      for key, value in self.__dict__.iteritems()]
3465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3466 
 
3467 
  def __eq__(self, other):
3468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3469 
 
3470 
  def __ne__(self, other):
3471 
    return not (self == other)
5711 mandeep.dh 3472 
 
3473 
class getInventoryAge_args:
3474 
 
3475 
  thrift_spec = (
3476 
  )
3477 
 
3478 
  def read(self, iprot):
3479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3481 
      return
3482 
    iprot.readStructBegin()
3483 
    while True:
3484 
      (fname, ftype, fid) = iprot.readFieldBegin()
3485 
      if ftype == TType.STOP:
3486 
        break
3487 
      else:
3488 
        iprot.skip(ftype)
3489 
      iprot.readFieldEnd()
3490 
    iprot.readStructEnd()
3491 
 
3492 
  def write(self, oprot):
3493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3495 
      return
3496 
    oprot.writeStructBegin('getInventoryAge_args')
3497 
    oprot.writeFieldStop()
3498 
    oprot.writeStructEnd()
3499 
 
3500 
  def validate(self):
3501 
    return
3502 
 
3503 
 
3504 
  def __repr__(self):
3505 
    L = ['%s=%r' % (key, value)
3506 
      for key, value in self.__dict__.iteritems()]
3507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3508 
 
3509 
  def __eq__(self, other):
3510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3511 
 
3512 
  def __ne__(self, other):
3513 
    return not (self == other)
3514 
 
3515 
class getInventoryAge_result:
3516 
  """
3517 
  Attributes:
3518 
   - success
3519 
  """
3520 
 
3521 
  thrift_spec = (
3522 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAge, InventoryAge.thrift_spec)), None, ), # 0
3523 
  )
3524 
 
3525 
  def __init__(self, success=None,):
3526 
    self.success = success
3527 
 
3528 
  def read(self, iprot):
3529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3531 
      return
3532 
    iprot.readStructBegin()
3533 
    while True:
3534 
      (fname, ftype, fid) = iprot.readFieldBegin()
3535 
      if ftype == TType.STOP:
3536 
        break
3537 
      if fid == 0:
3538 
        if ftype == TType.LIST:
3539 
          self.success = []
3540 
          (_etype38, _size35) = iprot.readListBegin()
3541 
          for _i39 in xrange(_size35):
3542 
            _elem40 = InventoryAge()
3543 
            _elem40.read(iprot)
3544 
            self.success.append(_elem40)
3545 
          iprot.readListEnd()
3546 
        else:
3547 
          iprot.skip(ftype)
3548 
      else:
3549 
        iprot.skip(ftype)
3550 
      iprot.readFieldEnd()
3551 
    iprot.readStructEnd()
3552 
 
3553 
  def write(self, oprot):
3554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3556 
      return
3557 
    oprot.writeStructBegin('getInventoryAge_result')
3558 
    if self.success is not None:
3559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3561 
      for iter41 in self.success:
3562 
        iter41.write(oprot)
3563 
      oprot.writeListEnd()
3564 
      oprot.writeFieldEnd()
3565 
    oprot.writeFieldStop()
3566 
    oprot.writeStructEnd()
3567 
 
3568 
  def validate(self):
3569 
    return
3570 
 
3571 
 
3572 
  def __repr__(self):
3573 
    L = ['%s=%r' % (key, value)
3574 
      for key, value in self.__dict__.iteritems()]
3575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3576 
 
3577 
  def __eq__(self, other):
3578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3579 
 
3580 
  def __ne__(self, other):
3581 
    return not (self == other)
6361 rajveer 3582 
 
3583 
class getInventoryScansForItem_args:
3584 
  """
3585 
  Attributes:
3586 
   - itemId
3587 
   - fromDate
3588 
   - toDate
3589 
  """
3590 
 
3591 
  thrift_spec = (
3592 
    None, # 0
3593 
    (1, TType.I64, 'itemId', None, None, ), # 1
3594 
    (2, TType.I64, 'fromDate', None, None, ), # 2
3595 
    (3, TType.I64, 'toDate', None, None, ), # 3
3596 
  )
3597 
 
3598 
  def __init__(self, itemId=None, fromDate=None, toDate=None,):
3599 
    self.itemId = itemId
3600 
    self.fromDate = fromDate
3601 
    self.toDate = toDate
3602 
 
3603 
  def read(self, iprot):
3604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3606 
      return
3607 
    iprot.readStructBegin()
3608 
    while True:
3609 
      (fname, ftype, fid) = iprot.readFieldBegin()
3610 
      if ftype == TType.STOP:
3611 
        break
3612 
      if fid == 1:
3613 
        if ftype == TType.I64:
3614 
          self.itemId = iprot.readI64();
3615 
        else:
3616 
          iprot.skip(ftype)
3617 
      elif fid == 2:
3618 
        if ftype == TType.I64:
3619 
          self.fromDate = iprot.readI64();
3620 
        else:
3621 
          iprot.skip(ftype)
3622 
      elif fid == 3:
3623 
        if ftype == TType.I64:
3624 
          self.toDate = iprot.readI64();
3625 
        else:
3626 
          iprot.skip(ftype)
3627 
      else:
3628 
        iprot.skip(ftype)
3629 
      iprot.readFieldEnd()
3630 
    iprot.readStructEnd()
3631 
 
3632 
  def write(self, oprot):
3633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3635 
      return
3636 
    oprot.writeStructBegin('getInventoryScansForItem_args')
3637 
    if self.itemId is not None:
3638 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
3639 
      oprot.writeI64(self.itemId)
3640 
      oprot.writeFieldEnd()
3641 
    if self.fromDate is not None:
3642 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
3643 
      oprot.writeI64(self.fromDate)
3644 
      oprot.writeFieldEnd()
3645 
    if self.toDate is not None:
3646 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
3647 
      oprot.writeI64(self.toDate)
3648 
      oprot.writeFieldEnd()
3649 
    oprot.writeFieldStop()
3650 
    oprot.writeStructEnd()
3651 
 
3652 
  def validate(self):
3653 
    return
3654 
 
3655 
 
3656 
  def __repr__(self):
3657 
    L = ['%s=%r' % (key, value)
3658 
      for key, value in self.__dict__.iteritems()]
3659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3660 
 
3661 
  def __eq__(self, other):
3662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3663 
 
3664 
  def __ne__(self, other):
3665 
    return not (self == other)
3666 
 
3667 
class getInventoryScansForItem_result:
3668 
  """
3669 
  Attributes:
3670 
   - success
3671 
  """
3672 
 
3673 
  thrift_spec = (
3674 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
3675 
  )
3676 
 
3677 
  def __init__(self, success=None,):
3678 
    self.success = success
3679 
 
3680 
  def read(self, iprot):
3681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3683 
      return
3684 
    iprot.readStructBegin()
3685 
    while True:
3686 
      (fname, ftype, fid) = iprot.readFieldBegin()
3687 
      if ftype == TType.STOP:
3688 
        break
3689 
      if fid == 0:
3690 
        if ftype == TType.LIST:
3691 
          self.success = []
3692 
          (_etype45, _size42) = iprot.readListBegin()
3693 
          for _i46 in xrange(_size42):
3694 
            _elem47 = Scan()
3695 
            _elem47.read(iprot)
3696 
            self.success.append(_elem47)
3697 
          iprot.readListEnd()
3698 
        else:
3699 
          iprot.skip(ftype)
3700 
      else:
3701 
        iprot.skip(ftype)
3702 
      iprot.readFieldEnd()
3703 
    iprot.readStructEnd()
3704 
 
3705 
  def write(self, oprot):
3706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3708 
      return
3709 
    oprot.writeStructBegin('getInventoryScansForItem_result')
3710 
    if self.success is not None:
3711 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3712 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3713 
      for iter48 in self.success:
3714 
        iter48.write(oprot)
3715 
      oprot.writeListEnd()
3716 
      oprot.writeFieldEnd()
3717 
    oprot.writeFieldStop()
3718 
    oprot.writeStructEnd()
3719 
 
3720 
  def validate(self):
3721 
    return
3722 
 
3723 
 
3724 
  def __repr__(self):
3725 
    L = ['%s=%r' % (key, value)
3726 
      for key, value in self.__dict__.iteritems()]
3727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3728 
 
3729 
  def __eq__(self, other):
3730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3731 
 
3732 
  def __ne__(self, other):
3733 
    return not (self == other)
3734 
 
3735 
class getScanRecordsForSerialNumber_args:
3736 
  """
3737 
  Attributes:
3738 
   - serialNumber
3739 
  """
3740 
 
3741 
  thrift_spec = (
3742 
    None, # 0
3743 
    (1, TType.I64, 'serialNumber', None, None, ), # 1
3744 
  )
3745 
 
3746 
  def __init__(self, serialNumber=None,):
3747 
    self.serialNumber = serialNumber
3748 
 
3749 
  def read(self, iprot):
3750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3752 
      return
3753 
    iprot.readStructBegin()
3754 
    while True:
3755 
      (fname, ftype, fid) = iprot.readFieldBegin()
3756 
      if ftype == TType.STOP:
3757 
        break
3758 
      if fid == 1:
3759 
        if ftype == TType.I64:
3760 
          self.serialNumber = iprot.readI64();
3761 
        else:
3762 
          iprot.skip(ftype)
3763 
      else:
3764 
        iprot.skip(ftype)
3765 
      iprot.readFieldEnd()
3766 
    iprot.readStructEnd()
3767 
 
3768 
  def write(self, oprot):
3769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3771 
      return
3772 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_args')
3773 
    if self.serialNumber is not None:
3774 
      oprot.writeFieldBegin('serialNumber', TType.I64, 1)
3775 
      oprot.writeI64(self.serialNumber)
3776 
      oprot.writeFieldEnd()
3777 
    oprot.writeFieldStop()
3778 
    oprot.writeStructEnd()
3779 
 
3780 
  def validate(self):
3781 
    return
3782 
 
3783 
 
3784 
  def __repr__(self):
3785 
    L = ['%s=%r' % (key, value)
3786 
      for key, value in self.__dict__.iteritems()]
3787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3788 
 
3789 
  def __eq__(self, other):
3790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3791 
 
3792 
  def __ne__(self, other):
3793 
    return not (self == other)
3794 
 
3795 
class getScanRecordsForSerialNumber_result:
3796 
  """
3797 
  Attributes:
3798 
   - success
3799 
  """
3800 
 
3801 
  thrift_spec = (
3802 
    (0, TType.LIST, 'success', (TType.STRUCT,(Scan, Scan.thrift_spec)), None, ), # 0
3803 
  )
3804 
 
3805 
  def __init__(self, success=None,):
3806 
    self.success = success
3807 
 
3808 
  def read(self, iprot):
3809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3811 
      return
3812 
    iprot.readStructBegin()
3813 
    while True:
3814 
      (fname, ftype, fid) = iprot.readFieldBegin()
3815 
      if ftype == TType.STOP:
3816 
        break
3817 
      if fid == 0:
3818 
        if ftype == TType.LIST:
3819 
          self.success = []
3820 
          (_etype52, _size49) = iprot.readListBegin()
3821 
          for _i53 in xrange(_size49):
3822 
            _elem54 = Scan()
3823 
            _elem54.read(iprot)
3824 
            self.success.append(_elem54)
3825 
          iprot.readListEnd()
3826 
        else:
3827 
          iprot.skip(ftype)
3828 
      else:
3829 
        iprot.skip(ftype)
3830 
      iprot.readFieldEnd()
3831 
    iprot.readStructEnd()
3832 
 
3833 
  def write(self, oprot):
3834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3836 
      return
3837 
    oprot.writeStructBegin('getScanRecordsForSerialNumber_result')
3838 
    if self.success is not None:
3839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3841 
      for iter55 in self.success:
3842 
        iter55.write(oprot)
3843 
      oprot.writeListEnd()
3844 
      oprot.writeFieldEnd()
3845 
    oprot.writeFieldStop()
3846 
    oprot.writeStructEnd()
3847 
 
3848 
  def validate(self):
3849 
    return
3850 
 
3851 
 
3852 
  def __repr__(self):
3853 
    L = ['%s=%r' % (key, value)
3854 
      for key, value in self.__dict__.iteritems()]
3855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3856 
 
3857 
  def __eq__(self, other):
3858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3859 
 
3860 
  def __ne__(self, other):
3861 
    return not (self == other)
6467 amar.kumar 3862 
 
3863 
class scanForPurchaseReturn_args:
3864 
  """
3865 
  Attributes:
3866 
   - saleReturnItems
3867 
   - vendorId
3868 
  """
3869 
 
3870 
  thrift_spec = (
3871 
    None, # 0
3872 
    (1, TType.LIST, 'saleReturnItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
3873 
    (2, TType.I64, 'vendorId', None, None, ), # 2
3874 
  )
3875 
 
3876 
  def __init__(self, saleReturnItems=None, vendorId=None,):
3877 
    self.saleReturnItems = saleReturnItems
3878 
    self.vendorId = vendorId
3879 
 
3880 
  def read(self, iprot):
3881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3883 
      return
3884 
    iprot.readStructBegin()
3885 
    while True:
3886 
      (fname, ftype, fid) = iprot.readFieldBegin()
3887 
      if ftype == TType.STOP:
3888 
        break
3889 
      if fid == 1:
3890 
        if ftype == TType.LIST:
3891 
          self.saleReturnItems = []
3892 
          (_etype59, _size56) = iprot.readListBegin()
3893 
          for _i60 in xrange(_size56):
3894 
            _elem61 = InventoryItem()
3895 
            _elem61.read(iprot)
3896 
            self.saleReturnItems.append(_elem61)
3897 
          iprot.readListEnd()
3898 
        else:
3899 
          iprot.skip(ftype)
3900 
      elif fid == 2:
3901 
        if ftype == TType.I64:
3902 
          self.vendorId = iprot.readI64();
3903 
        else:
3904 
          iprot.skip(ftype)
3905 
      else:
3906 
        iprot.skip(ftype)
3907 
      iprot.readFieldEnd()
3908 
    iprot.readStructEnd()
3909 
 
3910 
  def write(self, oprot):
3911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3913 
      return
3914 
    oprot.writeStructBegin('scanForPurchaseReturn_args')
3915 
    if self.saleReturnItems is not None:
3916 
      oprot.writeFieldBegin('saleReturnItems', TType.LIST, 1)
3917 
      oprot.writeListBegin(TType.STRUCT, len(self.saleReturnItems))
3918 
      for iter62 in self.saleReturnItems:
3919 
        iter62.write(oprot)
3920 
      oprot.writeListEnd()
3921 
      oprot.writeFieldEnd()
3922 
    if self.vendorId is not None:
3923 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
3924 
      oprot.writeI64(self.vendorId)
3925 
      oprot.writeFieldEnd()
3926 
    oprot.writeFieldStop()
3927 
    oprot.writeStructEnd()
3928 
 
3929 
  def validate(self):
3930 
    return
3931 
 
3932 
 
3933 
  def __repr__(self):
3934 
    L = ['%s=%r' % (key, value)
3935 
      for key, value in self.__dict__.iteritems()]
3936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3937 
 
3938 
  def __eq__(self, other):
3939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3940 
 
3941 
  def __ne__(self, other):
3942 
    return not (self == other)
3943 
 
3944 
class scanForPurchaseReturn_result:
3945 
  """
3946 
  Attributes:
3947 
   - ex
3948 
  """
3949 
 
3950 
  thrift_spec = (
3951 
    None, # 0
3952 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
3953 
  )
3954 
 
3955 
  def __init__(self, ex=None,):
3956 
    self.ex = ex
3957 
 
3958 
  def read(self, iprot):
3959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3961 
      return
3962 
    iprot.readStructBegin()
3963 
    while True:
3964 
      (fname, ftype, fid) = iprot.readFieldBegin()
3965 
      if ftype == TType.STOP:
3966 
        break
3967 
      if fid == 1:
3968 
        if ftype == TType.STRUCT:
3969 
          self.ex = WarehouseServiceException()
3970 
          self.ex.read(iprot)
3971 
        else:
3972 
          iprot.skip(ftype)
3973 
      else:
3974 
        iprot.skip(ftype)
3975 
      iprot.readFieldEnd()
3976 
    iprot.readStructEnd()
3977 
 
3978 
  def write(self, oprot):
3979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3981 
      return
3982 
    oprot.writeStructBegin('scanForPurchaseReturn_result')
3983 
    if self.ex is not None:
3984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3985 
      self.ex.write(oprot)
3986 
      oprot.writeFieldEnd()
3987 
    oprot.writeFieldStop()
3988 
    oprot.writeStructEnd()
3989 
 
3990 
  def validate(self):
3991 
    return
3992 
 
3993 
 
3994 
  def __repr__(self):
3995 
    L = ['%s=%r' % (key, value)
3996 
      for key, value in self.__dict__.iteritems()]
3997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3998 
 
3999 
  def __eq__(self, other):
4000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4001 
 
4002 
  def __ne__(self, other):
4003 
    return not (self == other)
6630 amar.kumar 4004 
 
4005 
class scanForLostItem_args:
4006 
  """
4007 
  Attributes:
4008 
   - lostItems
4009 
   - vendorId
4010 
  """
4011 
 
4012 
  thrift_spec = (
4013 
    None, # 0
4014 
    (1, TType.LIST, 'lostItems', (TType.STRUCT,(InventoryItem, InventoryItem.thrift_spec)), None, ), # 1
4015 
    (2, TType.I64, 'vendorId', None, None, ), # 2
4016 
  )
4017 
 
4018 
  def __init__(self, lostItems=None, vendorId=None,):
4019 
    self.lostItems = lostItems
4020 
    self.vendorId = vendorId
4021 
 
4022 
  def read(self, iprot):
4023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4025 
      return
4026 
    iprot.readStructBegin()
4027 
    while True:
4028 
      (fname, ftype, fid) = iprot.readFieldBegin()
4029 
      if ftype == TType.STOP:
4030 
        break
4031 
      if fid == 1:
4032 
        if ftype == TType.LIST:
4033 
          self.lostItems = []
4034 
          (_etype66, _size63) = iprot.readListBegin()
4035 
          for _i67 in xrange(_size63):
4036 
            _elem68 = InventoryItem()
4037 
            _elem68.read(iprot)
4038 
            self.lostItems.append(_elem68)
4039 
          iprot.readListEnd()
4040 
        else:
4041 
          iprot.skip(ftype)
4042 
      elif fid == 2:
4043 
        if ftype == TType.I64:
4044 
          self.vendorId = iprot.readI64();
4045 
        else:
4046 
          iprot.skip(ftype)
4047 
      else:
4048 
        iprot.skip(ftype)
4049 
      iprot.readFieldEnd()
4050 
    iprot.readStructEnd()
4051 
 
4052 
  def write(self, oprot):
4053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4055 
      return
4056 
    oprot.writeStructBegin('scanForLostItem_args')
4057 
    if self.lostItems is not None:
4058 
      oprot.writeFieldBegin('lostItems', TType.LIST, 1)
4059 
      oprot.writeListBegin(TType.STRUCT, len(self.lostItems))
4060 
      for iter69 in self.lostItems:
4061 
        iter69.write(oprot)
4062 
      oprot.writeListEnd()
4063 
      oprot.writeFieldEnd()
4064 
    if self.vendorId is not None:
4065 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
4066 
      oprot.writeI64(self.vendorId)
4067 
      oprot.writeFieldEnd()
4068 
    oprot.writeFieldStop()
4069 
    oprot.writeStructEnd()
4070 
 
4071 
  def validate(self):
4072 
    return
4073 
 
4074 
 
4075 
  def __repr__(self):
4076 
    L = ['%s=%r' % (key, value)
4077 
      for key, value in self.__dict__.iteritems()]
4078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4079 
 
4080 
  def __eq__(self, other):
4081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4082 
 
4083 
  def __ne__(self, other):
4084 
    return not (self == other)
4085 
 
4086 
class scanForLostItem_result:
4087 
  """
4088 
  Attributes:
4089 
   - ex
4090 
  """
4091 
 
4092 
  thrift_spec = (
4093 
    None, # 0
4094 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4095 
  )
4096 
 
4097 
  def __init__(self, ex=None,):
4098 
    self.ex = ex
4099 
 
4100 
  def read(self, iprot):
4101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4103 
      return
4104 
    iprot.readStructBegin()
4105 
    while True:
4106 
      (fname, ftype, fid) = iprot.readFieldBegin()
4107 
      if ftype == TType.STOP:
4108 
        break
4109 
      if fid == 1:
4110 
        if ftype == TType.STRUCT:
4111 
          self.ex = WarehouseServiceException()
4112 
          self.ex.read(iprot)
4113 
        else:
4114 
          iprot.skip(ftype)
4115 
      else:
4116 
        iprot.skip(ftype)
4117 
      iprot.readFieldEnd()
4118 
    iprot.readStructEnd()
4119 
 
4120 
  def write(self, oprot):
4121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4123 
      return
4124 
    oprot.writeStructBegin('scanForLostItem_result')
4125 
    if self.ex is not None:
4126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4127 
      self.ex.write(oprot)
4128 
      oprot.writeFieldEnd()
4129 
    oprot.writeFieldStop()
4130 
    oprot.writeStructEnd()
4131 
 
4132 
  def validate(self):
4133 
    return
4134 
 
4135 
 
4136 
  def __repr__(self):
4137 
    L = ['%s=%r' % (key, value)
4138 
      for key, value in self.__dict__.iteritems()]
4139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4140 
 
4141 
  def __eq__(self, other):
4142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4143 
 
4144 
  def __ne__(self, other):
4145 
    return not (self == other)
4146 
 
4147 
class getCurrentSerializedInventoryByScans_args:
4148 
 
4149 
  thrift_spec = (
4150 
  )
4151 
 
4152 
  def read(self, iprot):
4153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4155 
      return
4156 
    iprot.readStructBegin()
4157 
    while True:
4158 
      (fname, ftype, fid) = iprot.readFieldBegin()
4159 
      if ftype == TType.STOP:
4160 
        break
4161 
      else:
4162 
        iprot.skip(ftype)
4163 
      iprot.readFieldEnd()
4164 
    iprot.readStructEnd()
4165 
 
4166 
  def write(self, oprot):
4167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4169 
      return
4170 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_args')
4171 
    oprot.writeFieldStop()
4172 
    oprot.writeStructEnd()
4173 
 
4174 
  def validate(self):
4175 
    return
4176 
 
4177 
 
4178 
  def __repr__(self):
4179 
    L = ['%s=%r' % (key, value)
4180 
      for key, value in self.__dict__.iteritems()]
4181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4182 
 
4183 
  def __eq__(self, other):
4184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4185 
 
4186 
  def __ne__(self, other):
4187 
    return not (self == other)
4188 
 
4189 
class getCurrentSerializedInventoryByScans_result:
4190 
  """
4191 
  Attributes:
4192 
   - success
4193 
  """
4194 
 
4195 
  thrift_spec = (
4196 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4197 
  )
4198 
 
4199 
  def __init__(self, success=None,):
4200 
    self.success = success
4201 
 
4202 
  def read(self, iprot):
4203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4205 
      return
4206 
    iprot.readStructBegin()
4207 
    while True:
4208 
      (fname, ftype, fid) = iprot.readFieldBegin()
4209 
      if ftype == TType.STOP:
4210 
        break
4211 
      if fid == 0:
4212 
        if ftype == TType.LIST:
4213 
          self.success = []
4214 
          (_etype73, _size70) = iprot.readListBegin()
4215 
          for _i74 in xrange(_size70):
4216 
            _elem75 = InventoryAvailability()
4217 
            _elem75.read(iprot)
4218 
            self.success.append(_elem75)
4219 
          iprot.readListEnd()
4220 
        else:
4221 
          iprot.skip(ftype)
4222 
      else:
4223 
        iprot.skip(ftype)
4224 
      iprot.readFieldEnd()
4225 
    iprot.readStructEnd()
4226 
 
4227 
  def write(self, oprot):
4228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4230 
      return
4231 
    oprot.writeStructBegin('getCurrentSerializedInventoryByScans_result')
4232 
    if self.success is not None:
4233 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4234 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4235 
      for iter76 in self.success:
4236 
        iter76.write(oprot)
4237 
      oprot.writeListEnd()
4238 
      oprot.writeFieldEnd()
4239 
    oprot.writeFieldStop()
4240 
    oprot.writeStructEnd()
4241 
 
4242 
  def validate(self):
4243 
    return
4244 
 
4245 
 
4246 
  def __repr__(self):
4247 
    L = ['%s=%r' % (key, value)
4248 
      for key, value in self.__dict__.iteritems()]
4249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4250 
 
4251 
  def __eq__(self, other):
4252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4253 
 
4254 
  def __ne__(self, other):
4255 
    return not (self == other)
4256 
 
4257 
class getCurrentNonSerializedInventoryByScans_args:
4258 
 
4259 
  thrift_spec = (
4260 
  )
4261 
 
4262 
  def read(self, iprot):
4263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4265 
      return
4266 
    iprot.readStructBegin()
4267 
    while True:
4268 
      (fname, ftype, fid) = iprot.readFieldBegin()
4269 
      if ftype == TType.STOP:
4270 
        break
4271 
      else:
4272 
        iprot.skip(ftype)
4273 
      iprot.readFieldEnd()
4274 
    iprot.readStructEnd()
4275 
 
4276 
  def write(self, oprot):
4277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4279 
      return
4280 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_args')
4281 
    oprot.writeFieldStop()
4282 
    oprot.writeStructEnd()
4283 
 
4284 
  def validate(self):
4285 
    return
4286 
 
4287 
 
4288 
  def __repr__(self):
4289 
    L = ['%s=%r' % (key, value)
4290 
      for key, value in self.__dict__.iteritems()]
4291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4292 
 
4293 
  def __eq__(self, other):
4294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4295 
 
4296 
  def __ne__(self, other):
4297 
    return not (self == other)
4298 
 
4299 
class getCurrentNonSerializedInventoryByScans_result:
4300 
  """
4301 
  Attributes:
4302 
   - success
4303 
  """
4304 
 
4305 
  thrift_spec = (
4306 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4307 
  )
4308 
 
4309 
  def __init__(self, success=None,):
4310 
    self.success = success
4311 
 
4312 
  def read(self, iprot):
4313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4315 
      return
4316 
    iprot.readStructBegin()
4317 
    while True:
4318 
      (fname, ftype, fid) = iprot.readFieldBegin()
4319 
      if ftype == TType.STOP:
4320 
        break
4321 
      if fid == 0:
4322 
        if ftype == TType.LIST:
4323 
          self.success = []
4324 
          (_etype80, _size77) = iprot.readListBegin()
4325 
          for _i81 in xrange(_size77):
4326 
            _elem82 = InventoryAvailability()
4327 
            _elem82.read(iprot)
4328 
            self.success.append(_elem82)
4329 
          iprot.readListEnd()
4330 
        else:
4331 
          iprot.skip(ftype)
4332 
      else:
4333 
        iprot.skip(ftype)
4334 
      iprot.readFieldEnd()
4335 
    iprot.readStructEnd()
4336 
 
4337 
  def write(self, oprot):
4338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4340 
      return
4341 
    oprot.writeStructBegin('getCurrentNonSerializedInventoryByScans_result')
4342 
    if self.success is not None:
4343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4345 
      for iter83 in self.success:
4346 
        iter83.write(oprot)
4347 
      oprot.writeListEnd()
4348 
      oprot.writeFieldEnd()
4349 
    oprot.writeFieldStop()
4350 
    oprot.writeStructEnd()
4351 
 
4352 
  def validate(self):
4353 
    return
4354 
 
4355 
 
4356 
  def __repr__(self):
4357 
    L = ['%s=%r' % (key, value)
4358 
      for key, value in self.__dict__.iteritems()]
4359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4360 
 
4361 
  def __eq__(self, other):
4362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4363 
 
4364 
  def __ne__(self, other):
4365 
    return not (self == other)
6762 amar.kumar 4366 
 
4367 
class getHistoricSerializedInventoryByScans_args:
4368 
  """
4369 
  Attributes:
4370 
   - date
4371 
  """
4372 
 
4373 
  thrift_spec = (
4374 
    None, # 0
4375 
    (1, TType.I64, 'date', None, None, ), # 1
4376 
  )
4377 
 
4378 
  def __init__(self, date=None,):
4379 
    self.date = date
4380 
 
4381 
  def read(self, iprot):
4382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4384 
      return
4385 
    iprot.readStructBegin()
4386 
    while True:
4387 
      (fname, ftype, fid) = iprot.readFieldBegin()
4388 
      if ftype == TType.STOP:
4389 
        break
4390 
      if fid == 1:
4391 
        if ftype == TType.I64:
4392 
          self.date = iprot.readI64();
4393 
        else:
4394 
          iprot.skip(ftype)
4395 
      else:
4396 
        iprot.skip(ftype)
4397 
      iprot.readFieldEnd()
4398 
    iprot.readStructEnd()
4399 
 
4400 
  def write(self, oprot):
4401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4403 
      return
4404 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_args')
4405 
    if self.date is not None:
4406 
      oprot.writeFieldBegin('date', TType.I64, 1)
4407 
      oprot.writeI64(self.date)
4408 
      oprot.writeFieldEnd()
4409 
    oprot.writeFieldStop()
4410 
    oprot.writeStructEnd()
4411 
 
4412 
  def validate(self):
4413 
    return
4414 
 
4415 
 
4416 
  def __repr__(self):
4417 
    L = ['%s=%r' % (key, value)
4418 
      for key, value in self.__dict__.iteritems()]
4419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4420 
 
4421 
  def __eq__(self, other):
4422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4423 
 
4424 
  def __ne__(self, other):
4425 
    return not (self == other)
4426 
 
4427 
class getHistoricSerializedInventoryByScans_result:
4428 
  """
4429 
  Attributes:
4430 
   - success
4431 
  """
4432 
 
4433 
  thrift_spec = (
4434 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4435 
  )
4436 
 
4437 
  def __init__(self, success=None,):
4438 
    self.success = success
4439 
 
4440 
  def read(self, iprot):
4441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4443 
      return
4444 
    iprot.readStructBegin()
4445 
    while True:
4446 
      (fname, ftype, fid) = iprot.readFieldBegin()
4447 
      if ftype == TType.STOP:
4448 
        break
4449 
      if fid == 0:
4450 
        if ftype == TType.LIST:
4451 
          self.success = []
4452 
          (_etype87, _size84) = iprot.readListBegin()
4453 
          for _i88 in xrange(_size84):
4454 
            _elem89 = InventoryAvailability()
4455 
            _elem89.read(iprot)
4456 
            self.success.append(_elem89)
4457 
          iprot.readListEnd()
4458 
        else:
4459 
          iprot.skip(ftype)
4460 
      else:
4461 
        iprot.skip(ftype)
4462 
      iprot.readFieldEnd()
4463 
    iprot.readStructEnd()
4464 
 
4465 
  def write(self, oprot):
4466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4468 
      return
4469 
    oprot.writeStructBegin('getHistoricSerializedInventoryByScans_result')
4470 
    if self.success is not None:
4471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4473 
      for iter90 in self.success:
4474 
        iter90.write(oprot)
4475 
      oprot.writeListEnd()
4476 
      oprot.writeFieldEnd()
4477 
    oprot.writeFieldStop()
4478 
    oprot.writeStructEnd()
4479 
 
4480 
  def validate(self):
4481 
    return
4482 
 
4483 
 
4484 
  def __repr__(self):
4485 
    L = ['%s=%r' % (key, value)
4486 
      for key, value in self.__dict__.iteritems()]
4487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4488 
 
4489 
  def __eq__(self, other):
4490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4491 
 
4492 
  def __ne__(self, other):
4493 
    return not (self == other)
4494 
 
4495 
class getHistoricNonSerializedInventoryByScans_args:
4496 
  """
4497 
  Attributes:
4498 
   - date
4499 
  """
4500 
 
4501 
  thrift_spec = (
4502 
    None, # 0
4503 
    (1, TType.I64, 'date', None, None, ), # 1
4504 
  )
4505 
 
4506 
  def __init__(self, date=None,):
4507 
    self.date = date
4508 
 
4509 
  def read(self, iprot):
4510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4512 
      return
4513 
    iprot.readStructBegin()
4514 
    while True:
4515 
      (fname, ftype, fid) = iprot.readFieldBegin()
4516 
      if ftype == TType.STOP:
4517 
        break
4518 
      if fid == 1:
4519 
        if ftype == TType.I64:
4520 
          self.date = iprot.readI64();
4521 
        else:
4522 
          iprot.skip(ftype)
4523 
      else:
4524 
        iprot.skip(ftype)
4525 
      iprot.readFieldEnd()
4526 
    iprot.readStructEnd()
4527 
 
4528 
  def write(self, oprot):
4529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4531 
      return
4532 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_args')
4533 
    if self.date is not None:
4534 
      oprot.writeFieldBegin('date', TType.I64, 1)
4535 
      oprot.writeI64(self.date)
4536 
      oprot.writeFieldEnd()
4537 
    oprot.writeFieldStop()
4538 
    oprot.writeStructEnd()
4539 
 
4540 
  def validate(self):
4541 
    return
4542 
 
4543 
 
4544 
  def __repr__(self):
4545 
    L = ['%s=%r' % (key, value)
4546 
      for key, value in self.__dict__.iteritems()]
4547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4548 
 
4549 
  def __eq__(self, other):
4550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4551 
 
4552 
  def __ne__(self, other):
4553 
    return not (self == other)
4554 
 
4555 
class getHistoricNonSerializedInventoryByScans_result:
4556 
  """
4557 
  Attributes:
4558 
   - success
4559 
  """
4560 
 
4561 
  thrift_spec = (
4562 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryAvailability, InventoryAvailability.thrift_spec)), None, ), # 0
4563 
  )
4564 
 
4565 
  def __init__(self, success=None,):
4566 
    self.success = success
4567 
 
4568 
  def read(self, iprot):
4569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4571 
      return
4572 
    iprot.readStructBegin()
4573 
    while True:
4574 
      (fname, ftype, fid) = iprot.readFieldBegin()
4575 
      if ftype == TType.STOP:
4576 
        break
4577 
      if fid == 0:
4578 
        if ftype == TType.LIST:
4579 
          self.success = []
4580 
          (_etype94, _size91) = iprot.readListBegin()
4581 
          for _i95 in xrange(_size91):
4582 
            _elem96 = InventoryAvailability()
4583 
            _elem96.read(iprot)
4584 
            self.success.append(_elem96)
4585 
          iprot.readListEnd()
4586 
        else:
4587 
          iprot.skip(ftype)
4588 
      else:
4589 
        iprot.skip(ftype)
4590 
      iprot.readFieldEnd()
4591 
    iprot.readStructEnd()
4592 
 
4593 
  def write(self, oprot):
4594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4596 
      return
4597 
    oprot.writeStructBegin('getHistoricNonSerializedInventoryByScans_result')
4598 
    if self.success is not None:
4599 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4600 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4601 
      for iter97 in self.success:
4602 
        iter97.write(oprot)
4603 
      oprot.writeListEnd()
4604 
      oprot.writeFieldEnd()
4605 
    oprot.writeFieldStop()
4606 
    oprot.writeStructEnd()
4607 
 
4608 
  def validate(self):
4609 
    return
4610 
 
4611 
 
4612 
  def __repr__(self):
4613 
    L = ['%s=%r' % (key, value)
4614 
      for key, value in self.__dict__.iteritems()]
4615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4616 
 
4617 
  def __eq__(self, other):
4618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4619 
 
4620 
  def __ne__(self, other):
4621 
    return not (self == other)
4622 
 
4623 
class scanForOursExternalSale_args:
4624 
  """
4625 
  Attributes:
4626 
   - itemId
4627 
   - serialNumber
4628 
   - itemNumber
4629 
   - invoiceNumber
4630 
   - warehouseId
4631 
   - unitPrice
4632 
   - orderId
4633 
  """
4634 
 
4635 
  thrift_spec = (
4636 
    None, # 0
4637 
    (1, TType.I64, 'itemId', None, None, ), # 1
4638 
    (2, TType.STRING, 'serialNumber', None, None, ), # 2
4639 
    (3, TType.STRING, 'itemNumber', None, None, ), # 3
4640 
    (4, TType.STRING, 'invoiceNumber', None, None, ), # 4
4641 
    (5, TType.I64, 'warehouseId', None, None, ), # 5
4642 
    (6, TType.DOUBLE, 'unitPrice', None, None, ), # 6
4643 
    (7, TType.I64, 'orderId', None, None, ), # 7
4644 
  )
4645 
 
4646 
  def __init__(self, itemId=None, serialNumber=None, itemNumber=None, invoiceNumber=None, warehouseId=None, unitPrice=None, orderId=None,):
4647 
    self.itemId = itemId
4648 
    self.serialNumber = serialNumber
4649 
    self.itemNumber = itemNumber
4650 
    self.invoiceNumber = invoiceNumber
4651 
    self.warehouseId = warehouseId
4652 
    self.unitPrice = unitPrice
4653 
    self.orderId = orderId
4654 
 
4655 
  def read(self, iprot):
4656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4658 
      return
4659 
    iprot.readStructBegin()
4660 
    while True:
4661 
      (fname, ftype, fid) = iprot.readFieldBegin()
4662 
      if ftype == TType.STOP:
4663 
        break
4664 
      if fid == 1:
4665 
        if ftype == TType.I64:
4666 
          self.itemId = iprot.readI64();
4667 
        else:
4668 
          iprot.skip(ftype)
4669 
      elif fid == 2:
4670 
        if ftype == TType.STRING:
4671 
          self.serialNumber = iprot.readString();
4672 
        else:
4673 
          iprot.skip(ftype)
4674 
      elif fid == 3:
4675 
        if ftype == TType.STRING:
4676 
          self.itemNumber = iprot.readString();
4677 
        else:
4678 
          iprot.skip(ftype)
4679 
      elif fid == 4:
4680 
        if ftype == TType.STRING:
4681 
          self.invoiceNumber = iprot.readString();
4682 
        else:
4683 
          iprot.skip(ftype)
4684 
      elif fid == 5:
4685 
        if ftype == TType.I64:
4686 
          self.warehouseId = iprot.readI64();
4687 
        else:
4688 
          iprot.skip(ftype)
4689 
      elif fid == 6:
4690 
        if ftype == TType.DOUBLE:
4691 
          self.unitPrice = iprot.readDouble();
4692 
        else:
4693 
          iprot.skip(ftype)
4694 
      elif fid == 7:
4695 
        if ftype == TType.I64:
4696 
          self.orderId = iprot.readI64();
4697 
        else:
4698 
          iprot.skip(ftype)
4699 
      else:
4700 
        iprot.skip(ftype)
4701 
      iprot.readFieldEnd()
4702 
    iprot.readStructEnd()
4703 
 
4704 
  def write(self, oprot):
4705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4707 
      return
4708 
    oprot.writeStructBegin('scanForOursExternalSale_args')
4709 
    if self.itemId is not None:
4710 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
4711 
      oprot.writeI64(self.itemId)
4712 
      oprot.writeFieldEnd()
4713 
    if self.serialNumber is not None:
4714 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 2)
4715 
      oprot.writeString(self.serialNumber)
4716 
      oprot.writeFieldEnd()
4717 
    if self.itemNumber is not None:
4718 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 3)
4719 
      oprot.writeString(self.itemNumber)
4720 
      oprot.writeFieldEnd()
4721 
    if self.invoiceNumber is not None:
4722 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 4)
4723 
      oprot.writeString(self.invoiceNumber)
4724 
      oprot.writeFieldEnd()
4725 
    if self.warehouseId is not None:
4726 
      oprot.writeFieldBegin('warehouseId', TType.I64, 5)
4727 
      oprot.writeI64(self.warehouseId)
4728 
      oprot.writeFieldEnd()
4729 
    if self.unitPrice is not None:
4730 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 6)
4731 
      oprot.writeDouble(self.unitPrice)
4732 
      oprot.writeFieldEnd()
4733 
    if self.orderId is not None:
4734 
      oprot.writeFieldBegin('orderId', TType.I64, 7)
4735 
      oprot.writeI64(self.orderId)
4736 
      oprot.writeFieldEnd()
4737 
    oprot.writeFieldStop()
4738 
    oprot.writeStructEnd()
4739 
 
4740 
  def validate(self):
4741 
    return
4742 
 
4743 
 
4744 
  def __repr__(self):
4745 
    L = ['%s=%r' % (key, value)
4746 
      for key, value in self.__dict__.iteritems()]
4747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4748 
 
4749 
  def __eq__(self, other):
4750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4751 
 
4752 
  def __ne__(self, other):
4753 
    return not (self == other)
4754 
 
4755 
class scanForOursExternalSale_result:
4756 
  """
4757 
  Attributes:
4758 
   - success
4759 
   - ex
4760 
  """
4761 
 
4762 
  thrift_spec = (
4763 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
4764 
    (1, TType.STRUCT, 'ex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
4765 
  )
4766 
 
4767 
  def __init__(self, success=None, ex=None,):
4768 
    self.success = success
4769 
    self.ex = ex
4770 
 
4771 
  def read(self, iprot):
4772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4774 
      return
4775 
    iprot.readStructBegin()
4776 
    while True:
4777 
      (fname, ftype, fid) = iprot.readFieldBegin()
4778 
      if ftype == TType.STOP:
4779 
        break
4780 
      if fid == 0:
4781 
        if ftype == TType.STRUCT:
4782 
          self.success = InventoryItem()
4783 
          self.success.read(iprot)
4784 
        else:
4785 
          iprot.skip(ftype)
4786 
      elif fid == 1:
4787 
        if ftype == TType.STRUCT:
4788 
          self.ex = WarehouseServiceException()
4789 
          self.ex.read(iprot)
4790 
        else:
4791 
          iprot.skip(ftype)
4792 
      else:
4793 
        iprot.skip(ftype)
4794 
      iprot.readFieldEnd()
4795 
    iprot.readStructEnd()
4796 
 
4797 
  def write(self, oprot):
4798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4800 
      return
4801 
    oprot.writeStructBegin('scanForOursExternalSale_result')
4802 
    if self.success is not None:
4803 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4804 
      self.success.write(oprot)
4805 
      oprot.writeFieldEnd()
4806 
    if self.ex is not None:
4807 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4808 
      self.ex.write(oprot)
4809 
      oprot.writeFieldEnd()
4810 
    oprot.writeFieldStop()
4811 
    oprot.writeStructEnd()
4812 
 
4813 
  def validate(self):
4814 
    return
4815 
 
4816 
 
4817 
  def __repr__(self):
4818 
    L = ['%s=%r' % (key, value)
4819 
      for key, value in self.__dict__.iteritems()]
4820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4821 
 
4822 
  def __eq__(self, other):
4823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4824 
 
4825 
  def __ne__(self, other):
4826 
    return not (self == other)
4827 
 
4828 
class scanForOursExternalSaleReturn_args:
4829 
  """
4830 
  Attributes:
4831 
   - orderId
4832 
   - unitPrice
4833 
  """
4834 
 
4835 
  thrift_spec = (
4836 
    None, # 0
4837 
    (1, TType.I64, 'orderId', None, None, ), # 1
4838 
    (2, TType.DOUBLE, 'unitPrice', None, None, ), # 2
4839 
  )
4840 
 
4841 
  def __init__(self, orderId=None, unitPrice=None,):
4842 
    self.orderId = orderId
4843 
    self.unitPrice = unitPrice
4844 
 
4845 
  def read(self, iprot):
4846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4848 
      return
4849 
    iprot.readStructBegin()
4850 
    while True:
4851 
      (fname, ftype, fid) = iprot.readFieldBegin()
4852 
      if ftype == TType.STOP:
4853 
        break
4854 
      if fid == 1:
4855 
        if ftype == TType.I64:
4856 
          self.orderId = iprot.readI64();
4857 
        else:
4858 
          iprot.skip(ftype)
4859 
      elif fid == 2:
4860 
        if ftype == TType.DOUBLE:
4861 
          self.unitPrice = iprot.readDouble();
4862 
        else:
4863 
          iprot.skip(ftype)
4864 
      else:
4865 
        iprot.skip(ftype)
4866 
      iprot.readFieldEnd()
4867 
    iprot.readStructEnd()
4868 
 
4869 
  def write(self, oprot):
4870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4872 
      return
4873 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_args')
4874 
    if self.orderId is not None:
4875 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4876 
      oprot.writeI64(self.orderId)
4877 
      oprot.writeFieldEnd()
4878 
    if self.unitPrice is not None:
4879 
      oprot.writeFieldBegin('unitPrice', TType.DOUBLE, 2)
4880 
      oprot.writeDouble(self.unitPrice)
4881 
      oprot.writeFieldEnd()
4882 
    oprot.writeFieldStop()
4883 
    oprot.writeStructEnd()
4884 
 
4885 
  def validate(self):
4886 
    return
4887 
 
4888 
 
4889 
  def __repr__(self):
4890 
    L = ['%s=%r' % (key, value)
4891 
      for key, value in self.__dict__.iteritems()]
4892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4893 
 
4894 
  def __eq__(self, other):
4895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4896 
 
4897 
  def __ne__(self, other):
4898 
    return not (self == other)
4899 
 
4900 
class scanForOursExternalSaleReturn_result:
4901 
 
4902 
  thrift_spec = (
4903 
  )
4904 
 
4905 
  def read(self, iprot):
4906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4908 
      return
4909 
    iprot.readStructBegin()
4910 
    while True:
4911 
      (fname, ftype, fid) = iprot.readFieldBegin()
4912 
      if ftype == TType.STOP:
4913 
        break
4914 
      else:
4915 
        iprot.skip(ftype)
4916 
      iprot.readFieldEnd()
4917 
    iprot.readStructEnd()
4918 
 
4919 
  def write(self, oprot):
4920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4922 
      return
4923 
    oprot.writeStructBegin('scanForOursExternalSaleReturn_result')
4924 
    oprot.writeFieldStop()
4925 
    oprot.writeStructEnd()
4926 
 
4927 
  def validate(self):
4928 
    return
4929 
 
4930 
 
4931 
  def __repr__(self):
4932 
    L = ['%s=%r' % (key, value)
4933 
      for key, value in self.__dict__.iteritems()]
4934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4935 
 
4936 
  def __eq__(self, other):
4937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4938 
 
4939 
  def __ne__(self, other):
4940 
    return not (self == other)
6880 amar.kumar 4941 
 
4942 
class getMovementNonSerializedInventoryByScans_args:
4943 
  """
4944 
  Attributes:
4945 
   - startDate
4946 
   - endDate
4947 
  """
4948 
 
4949 
  thrift_spec = (
4950 
    None, # 0
4951 
    (1, TType.I64, 'startDate', None, None, ), # 1
4952 
    (2, TType.I64, 'endDate', None, None, ), # 2
4953 
  )
4954 
 
4955 
  def __init__(self, startDate=None, endDate=None,):
4956 
    self.startDate = startDate
4957 
    self.endDate = endDate
4958 
 
4959 
  def read(self, iprot):
4960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4962 
      return
4963 
    iprot.readStructBegin()
4964 
    while True:
4965 
      (fname, ftype, fid) = iprot.readFieldBegin()
4966 
      if ftype == TType.STOP:
4967 
        break
4968 
      if fid == 1:
4969 
        if ftype == TType.I64:
4970 
          self.startDate = iprot.readI64();
4971 
        else:
4972 
          iprot.skip(ftype)
4973 
      elif fid == 2:
4974 
        if ftype == TType.I64:
4975 
          self.endDate = iprot.readI64();
4976 
        else:
4977 
          iprot.skip(ftype)
4978 
      else:
4979 
        iprot.skip(ftype)
4980 
      iprot.readFieldEnd()
4981 
    iprot.readStructEnd()
4982 
 
4983 
  def write(self, oprot):
4984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4986 
      return
4987 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_args')
4988 
    if self.startDate is not None:
4989 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
4990 
      oprot.writeI64(self.startDate)
4991 
      oprot.writeFieldEnd()
4992 
    if self.endDate is not None:
4993 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
4994 
      oprot.writeI64(self.endDate)
4995 
      oprot.writeFieldEnd()
4996 
    oprot.writeFieldStop()
4997 
    oprot.writeStructEnd()
4998 
 
4999 
  def validate(self):
5000 
    return
5001 
 
5002 
 
5003 
  def __repr__(self):
5004 
    L = ['%s=%r' % (key, value)
5005 
      for key, value in self.__dict__.iteritems()]
5006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5007 
 
5008 
  def __eq__(self, other):
5009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5010 
 
5011 
  def __ne__(self, other):
5012 
    return not (self == other)
5013 
 
5014 
class getMovementNonSerializedInventoryByScans_result:
5015 
  """
5016 
  Attributes:
5017 
   - success
5018 
  """
5019 
 
5020 
  thrift_spec = (
5021 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5022 
  )
5023 
 
5024 
  def __init__(self, success=None,):
5025 
    self.success = success
5026 
 
5027 
  def read(self, iprot):
5028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5030 
      return
5031 
    iprot.readStructBegin()
5032 
    while True:
5033 
      (fname, ftype, fid) = iprot.readFieldBegin()
5034 
      if ftype == TType.STOP:
5035 
        break
5036 
      if fid == 0:
5037 
        if ftype == TType.LIST:
5038 
          self.success = []
5039 
          (_etype101, _size98) = iprot.readListBegin()
5040 
          for _i102 in xrange(_size98):
5041 
            _elem103 = InventoryMovement()
5042 
            _elem103.read(iprot)
5043 
            self.success.append(_elem103)
5044 
          iprot.readListEnd()
5045 
        else:
5046 
          iprot.skip(ftype)
5047 
      else:
5048 
        iprot.skip(ftype)
5049 
      iprot.readFieldEnd()
5050 
    iprot.readStructEnd()
5051 
 
5052 
  def write(self, oprot):
5053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5055 
      return
5056 
    oprot.writeStructBegin('getMovementNonSerializedInventoryByScans_result')
5057 
    if self.success is not None:
5058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5060 
      for iter104 in self.success:
5061 
        iter104.write(oprot)
5062 
      oprot.writeListEnd()
5063 
      oprot.writeFieldEnd()
5064 
    oprot.writeFieldStop()
5065 
    oprot.writeStructEnd()
5066 
 
5067 
  def validate(self):
5068 
    return
5069 
 
5070 
 
5071 
  def __repr__(self):
5072 
    L = ['%s=%r' % (key, value)
5073 
      for key, value in self.__dict__.iteritems()]
5074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5075 
 
5076 
  def __eq__(self, other):
5077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5078 
 
5079 
  def __ne__(self, other):
5080 
    return not (self == other)
5081 
 
5082 
class getMovementSerializedInventoryByScans_args:
5083 
  """
5084 
  Attributes:
5085 
   - startDate
5086 
   - endDate
5087 
  """
5088 
 
5089 
  thrift_spec = (
5090 
    None, # 0
5091 
    (1, TType.I64, 'startDate', None, None, ), # 1
5092 
    (2, TType.I64, 'endDate', None, None, ), # 2
5093 
  )
5094 
 
5095 
  def __init__(self, startDate=None, endDate=None,):
5096 
    self.startDate = startDate
5097 
    self.endDate = endDate
5098 
 
5099 
  def read(self, iprot):
5100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5102 
      return
5103 
    iprot.readStructBegin()
5104 
    while True:
5105 
      (fname, ftype, fid) = iprot.readFieldBegin()
5106 
      if ftype == TType.STOP:
5107 
        break
5108 
      if fid == 1:
5109 
        if ftype == TType.I64:
5110 
          self.startDate = iprot.readI64();
5111 
        else:
5112 
          iprot.skip(ftype)
5113 
      elif fid == 2:
5114 
        if ftype == TType.I64:
5115 
          self.endDate = iprot.readI64();
5116 
        else:
5117 
          iprot.skip(ftype)
5118 
      else:
5119 
        iprot.skip(ftype)
5120 
      iprot.readFieldEnd()
5121 
    iprot.readStructEnd()
5122 
 
5123 
  def write(self, oprot):
5124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5126 
      return
5127 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_args')
5128 
    if self.startDate is not None:
5129 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
5130 
      oprot.writeI64(self.startDate)
5131 
      oprot.writeFieldEnd()
5132 
    if self.endDate is not None:
5133 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
5134 
      oprot.writeI64(self.endDate)
5135 
      oprot.writeFieldEnd()
5136 
    oprot.writeFieldStop()
5137 
    oprot.writeStructEnd()
5138 
 
5139 
  def validate(self):
5140 
    return
5141 
 
5142 
 
5143 
  def __repr__(self):
5144 
    L = ['%s=%r' % (key, value)
5145 
      for key, value in self.__dict__.iteritems()]
5146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5147 
 
5148 
  def __eq__(self, other):
5149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5150 
 
5151 
  def __ne__(self, other):
5152 
    return not (self == other)
5153 
 
5154 
class getMovementSerializedInventoryByScans_result:
5155 
  """
5156 
  Attributes:
5157 
   - success
5158 
  """
5159 
 
5160 
  thrift_spec = (
5161 
    (0, TType.LIST, 'success', (TType.STRUCT,(InventoryMovement, InventoryMovement.thrift_spec)), None, ), # 0
5162 
  )
5163 
 
5164 
  def __init__(self, success=None,):
5165 
    self.success = success
5166 
 
5167 
  def read(self, iprot):
5168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5170 
      return
5171 
    iprot.readStructBegin()
5172 
    while True:
5173 
      (fname, ftype, fid) = iprot.readFieldBegin()
5174 
      if ftype == TType.STOP:
5175 
        break
5176 
      if fid == 0:
5177 
        if ftype == TType.LIST:
5178 
          self.success = []
5179 
          (_etype108, _size105) = iprot.readListBegin()
5180 
          for _i109 in xrange(_size105):
5181 
            _elem110 = InventoryMovement()
5182 
            _elem110.read(iprot)
5183 
            self.success.append(_elem110)
5184 
          iprot.readListEnd()
5185 
        else:
5186 
          iprot.skip(ftype)
5187 
      else:
5188 
        iprot.skip(ftype)
5189 
      iprot.readFieldEnd()
5190 
    iprot.readStructEnd()
5191 
 
5192 
  def write(self, oprot):
5193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5195 
      return
5196 
    oprot.writeStructBegin('getMovementSerializedInventoryByScans_result')
5197 
    if self.success is not None:
5198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
5200 
      for iter111 in self.success:
5201 
        iter111.write(oprot)
5202 
      oprot.writeListEnd()
5203 
      oprot.writeFieldEnd()
5204 
    oprot.writeFieldStop()
5205 
    oprot.writeStructEnd()
5206 
 
5207 
  def validate(self):
5208 
    return
5209 
 
5210 
 
5211 
  def __repr__(self):
5212 
    L = ['%s=%r' % (key, value)
5213 
      for key, value in self.__dict__.iteritems()]
5214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5215 
 
5216 
  def __eq__(self, other):
5217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5218 
 
5219 
  def __ne__(self, other):
5220 
    return not (self == other)
7190 amar.kumar 5221 
 
5222 
class scanfreebie_args:
5223 
  """
5224 
  Attributes:
5225 
   - orderId
5226 
   - freebieItemId
5227 
   - freebieWarehouseId
5228 
   - scanType
5229 
  """
5230 
 
5231 
  thrift_spec = (
5232 
    None, # 0
5233 
    (1, TType.I64, 'orderId', None, None, ), # 1
5234 
    (2, TType.I64, 'freebieItemId', None, None, ), # 2
5235 
    (3, TType.I64, 'freebieWarehouseId', None, None, ), # 3
5236 
    (4, TType.I32, 'scanType', None, None, ), # 4
5237 
  )
5238 
 
5239 
  def __init__(self, orderId=None, freebieItemId=None, freebieWarehouseId=None, scanType=None,):
5240 
    self.orderId = orderId
5241 
    self.freebieItemId = freebieItemId
5242 
    self.freebieWarehouseId = freebieWarehouseId
5243 
    self.scanType = scanType
5244 
 
5245 
  def read(self, iprot):
5246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5248 
      return
5249 
    iprot.readStructBegin()
5250 
    while True:
5251 
      (fname, ftype, fid) = iprot.readFieldBegin()
5252 
      if ftype == TType.STOP:
5253 
        break
5254 
      if fid == 1:
5255 
        if ftype == TType.I64:
5256 
          self.orderId = iprot.readI64();
5257 
        else:
5258 
          iprot.skip(ftype)
5259 
      elif fid == 2:
5260 
        if ftype == TType.I64:
5261 
          self.freebieItemId = iprot.readI64();
5262 
        else:
5263 
          iprot.skip(ftype)
5264 
      elif fid == 3:
5265 
        if ftype == TType.I64:
5266 
          self.freebieWarehouseId = iprot.readI64();
5267 
        else:
5268 
          iprot.skip(ftype)
5269 
      elif fid == 4:
5270 
        if ftype == TType.I32:
5271 
          self.scanType = iprot.readI32();
5272 
        else:
5273 
          iprot.skip(ftype)
5274 
      else:
5275 
        iprot.skip(ftype)
5276 
      iprot.readFieldEnd()
5277 
    iprot.readStructEnd()
5278 
 
5279 
  def write(self, oprot):
5280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5282 
      return
5283 
    oprot.writeStructBegin('scanfreebie_args')
5284 
    if self.orderId is not None:
5285 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5286 
      oprot.writeI64(self.orderId)
5287 
      oprot.writeFieldEnd()
5288 
    if self.freebieItemId is not None:
5289 
      oprot.writeFieldBegin('freebieItemId', TType.I64, 2)
5290 
      oprot.writeI64(self.freebieItemId)
5291 
      oprot.writeFieldEnd()
5292 
    if self.freebieWarehouseId is not None:
5293 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 3)
5294 
      oprot.writeI64(self.freebieWarehouseId)
5295 
      oprot.writeFieldEnd()
5296 
    if self.scanType is not None:
5297 
      oprot.writeFieldBegin('scanType', TType.I32, 4)
5298 
      oprot.writeI32(self.scanType)
5299 
      oprot.writeFieldEnd()
5300 
    oprot.writeFieldStop()
5301 
    oprot.writeStructEnd()
5302 
 
5303 
  def validate(self):
5304 
    return
5305 
 
5306 
 
5307 
  def __repr__(self):
5308 
    L = ['%s=%r' % (key, value)
5309 
      for key, value in self.__dict__.iteritems()]
5310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5311 
 
5312 
  def __eq__(self, other):
5313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5314 
 
5315 
  def __ne__(self, other):
5316 
    return not (self == other)
5317 
 
5318 
class scanfreebie_result:
5319 
  """
5320 
  Attributes:
5321 
   - success
5322 
   - wex
5323 
  """
5324 
 
5325 
  thrift_spec = (
5326 
    (0, TType.STRUCT, 'success', (InventoryItem, InventoryItem.thrift_spec), None, ), # 0
5327 
    (1, TType.STRUCT, 'wex', (WarehouseServiceException, WarehouseServiceException.thrift_spec), None, ), # 1
5328 
  )
5329 
 
5330 
  def __init__(self, success=None, wex=None,):
5331 
    self.success = success
5332 
    self.wex = wex
5333 
 
5334 
  def read(self, iprot):
5335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5337 
      return
5338 
    iprot.readStructBegin()
5339 
    while True:
5340 
      (fname, ftype, fid) = iprot.readFieldBegin()
5341 
      if ftype == TType.STOP:
5342 
        break
5343 
      if fid == 0:
5344 
        if ftype == TType.STRUCT:
5345 
          self.success = InventoryItem()
5346 
          self.success.read(iprot)
5347 
        else:
5348 
          iprot.skip(ftype)
5349 
      elif fid == 1:
5350 
        if ftype == TType.STRUCT:
5351 
          self.wex = WarehouseServiceException()
5352 
          self.wex.read(iprot)
5353 
        else:
5354 
          iprot.skip(ftype)
5355 
      else:
5356 
        iprot.skip(ftype)
5357 
      iprot.readFieldEnd()
5358 
    iprot.readStructEnd()
5359 
 
5360 
  def write(self, oprot):
5361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5363 
      return
5364 
    oprot.writeStructBegin('scanfreebie_result')
5365 
    if self.success is not None:
5366 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5367 
      self.success.write(oprot)
5368 
      oprot.writeFieldEnd()
5369 
    if self.wex is not None:
5370 
      oprot.writeFieldBegin('wex', TType.STRUCT, 1)
5371 
      self.wex.write(oprot)
5372 
      oprot.writeFieldEnd()
5373 
    oprot.writeFieldStop()
5374 
    oprot.writeStructEnd()
5375 
 
5376 
  def validate(self):
5377 
    return
5378 
 
5379 
 
5380 
  def __repr__(self):
5381 
    L = ['%s=%r' % (key, value)
5382 
      for key, value in self.__dict__.iteritems()]
5383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5384 
 
5385 
  def __eq__(self, other):
5386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5387 
 
5388 
  def __ne__(self, other):
5389 
    return not (self == other)