Subversion Repositories SmartDukaan

Rev

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