Subversion Repositories SmartDukaan

Rev

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

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