Subversion Repositories SmartDukaan

Rev

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

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