Subversion Repositories SmartDukaan

Rev

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