Subversion Repositories SmartDukaan

Rev

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