Subversion Repositories SmartDukaan

Rev

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

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