Subversion Repositories SmartDukaan

Rev

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

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