Subversion Repositories SmartDukaan

Rev

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

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