Subversion Repositories SmartDukaan

Rev

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