Subversion Repositories SmartDukaan

Rev

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