Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
412 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
412 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
412 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
412 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
669 chandransh 20 
  def getProvider(self, providerId):
21 
    """
22 
    Returns a provider for a given provider ID. Throws an exception if none found.
3431 rajveer 23 
 
669 chandransh 24 
    Parameters:
25 
     - providerId
26 
    """
27 
    pass
28 
 
675 chandransh 29 
  def getAllProviders(self, ):
30 
    """
31 
    Returns a list containing all the providers.
32 
    """
33 
    pass
34 
 
4630 mandeep.dh 35 
  def getLogisticsEstimation(self, itemId, destination_pin, type):
483 rajveer 36 
    """
647 chandransh 37 
    Returns a LogisticsInfo structure w/o an airway bill number. Use this method during the estimation phase.
38 
    Raises an exception if this pincode is not allocated to any warehouse zone or provider. Also, if the pincode
39 
    is allocated to a warehouse zone but there are no actual warehouses in that zone, an exception is raised.
3431 rajveer 40 
 
483 rajveer 41 
    Parameters:
647 chandransh 42 
     - itemId
43 
     - destination_pin
4630 mandeep.dh 44 
     - type
483 rajveer 45 
    """
46 
    pass
47 
 
7256 rajveer 48 
  def getLogisticsEstimationForStore(self, itemId, destination_pin, type):
49 
    """
50 
    Parameters:
51 
     - itemId
52 
     - destination_pin
53 
     - type
54 
    """
55 
    pass
56 
 
5767 rajveer 57 
  def getLogisticsInfo(self, destination_pincode, item_id, type, pickUp):
472 rajveer 58 
    """
647 chandransh 59 
    Same as above excpet that an airway bill number is also allocated and returned.
3431 rajveer 60 
 
472 rajveer 61 
    Parameters:
647 chandransh 62 
     - destination_pincode
63 
     - item_id
3044 chandransh 64 
     - type
5767 rajveer 65 
     - pickUp
472 rajveer 66 
    """
67 
    pass
68 
 
20724 kshitij.so 69 
  def getEmptyAWB(self, providerId, logisticsTransactionId):
412 ashish 70 
    """
647 chandransh 71 
    Returns an unused AWB number for the given provider.
3431 rajveer 72 
 
412 ashish 73 
    Parameters:
647 chandransh 74 
     - providerId
20724 kshitij.so 75 
     - logisticsTransactionId
412 ashish 76 
    """
77 
    pass
78 
 
6643 rajveer 79 
  def getShipmentInfo(self, awbNumber, providerId):
412 ashish 80 
    """
647 chandransh 81 
    Returns the list of updates for the given AWB number and provider id. The list is empty if there are no updates yet.
3431 rajveer 82 
 
412 ashish 83 
    Parameters:
6643 rajveer 84 
     - awbNumber
647 chandransh 85 
     - providerId
412 ashish 86 
    """
87 
    pass
88 
 
6643 rajveer 89 
  def storeShipmentInfo(self, update):
90 
    """
91 
    Store the update for the given AWB number and provider id.
92 
 
93 
    Parameters:
94 
     - update
95 
    """
96 
    pass
97 
 
732 chandransh 98 
  def getDestinationCode(self, providerId, pinCode):
99 
    """
100 
    Returns the short three letter code of a pincode for the given provider.
101 
       Raises an exception if the pin code is not serviced by the given provider.
3431 rajveer 102 
 
732 chandransh 103 
    Parameters:
104 
     - providerId
105 
     - pinCode
106 
    """
107 
    pass
412 ashish 108 
 
3103 chandransh 109 
  def getFreeAwbCount(self, providerId, type):
1137 chandransh 110 
    """
3103 chandransh 111 
    Returns the number of unused AWB numbers for the given provider of the given type
3431 rajveer 112 
 
1137 chandransh 113 
    Parameters:
114 
     - providerId
3103 chandransh 115 
     - type
1137 chandransh 116 
    """
117 
    pass
732 chandransh 118 
 
1730 ankur.sing 119 
  def getHolidays(self, fromDate, toDate):
120 
    """
121 
    Returns list of Holiday dates between fromDate and toDate (both inclusive)
122 
    fromDate should be passed as milliseconds corresponding to the start of the day.
123 
    If fromDate is passed as -1, fromDate is not considered for filtering
124 
    If toDate is passed as -1, toDate is not considered for filtering
3431 rajveer 125 
 
1730 ankur.sing 126 
    Parameters:
127 
     - fromDate
128 
     - toDate
129 
    """
130 
    pass
1137 chandransh 131 
 
4934 amit.gupta 132 
  def getEntityLogisticsEstimation(self, catalogItemId, destination_pin, type):
133 
    """
134 
    Returns a LogisticsInfo structure w/o an airway bill number. Use this method during the estimation phase.
135 
    Raises an exception if this pincode is not allocated to any warehouse zone or provider. Also, if the pincode
136 
    is allocated to a warehouse zone but there are no actual warehouses in that zone, an exception is raised.
3431 rajveer 137 
 
4934 amit.gupta 138 
    Parameters:
139 
     - catalogItemId
140 
     - destination_pin
141 
     - type
142 
    """
143 
    pass
144 
 
5527 anupam.sin 145 
  def getProviderForPickupType(self, pickUp):
146 
    """
147 
    Returns the id for a given pickUpType
4934 amit.gupta 148 
 
5527 anupam.sin 149 
    Parameters:
150 
     - pickUp
151 
    """
152 
    pass
153 
 
5553 rajveer 154 
  def getAllPickupStores(self, ):
155 
    pass
5527 anupam.sin 156 
 
5553 rajveer 157 
  def getPickupStore(self, storeId):
158 
    """
159 
    Parameters:
160 
     - storeId
161 
    """
162 
    pass
163 
 
5719 rajveer 164 
  def getPickupStoreByHotspotId(self, hotspotId):
165 
    """
166 
    Parameters:
167 
     - hotspotId
168 
    """
169 
    pass
5553 rajveer 170 
 
6524 rajveer 171 
  def addPincode(self, providerId, pincode, destCode, exp, cod, stationType, otgAvailable):
6322 amar.kumar 172 
    """
173 
    Parameters:
174 
     - providerId
175 
     - pincode
176 
     - destCode
177 
     - exp
178 
     - cod
179 
     - stationType
6524 rajveer 180 
     - otgAvailable
6322 amar.kumar 181 
    """
182 
    pass
5719 rajveer 183 
 
6524 rajveer 184 
  def updatePincode(self, providerId, pincode, exp, cod, otgAvailable):
6322 amar.kumar 185 
    """
186 
    Parameters:
187 
     - providerId
188 
     - pincode
189 
     - exp
190 
     - cod
6524 rajveer 191 
     - otgAvailable
6322 amar.kumar 192 
    """
193 
    pass
194 
 
13146 manish.sha 195 
  def addNewAwbs(self, providerId, cod, awbs, awbUsedFor):
7567 rajveer 196 
    """
197 
    Parameters:
198 
     - providerId
199 
     - cod
200 
     - awbs
13146 manish.sha 201 
     - awbUsedFor
7567 rajveer 202 
    """
203 
    pass
6322 amar.kumar 204 
 
7787 manish.sha 205 
  def runLogisticsLocationInfoUpdate(self, logisticsLocationInfoList, runCompleteUpdate):
7738 manish.sha 206 
    """
207 
    Parameters:
7787 manish.sha 208 
     - logisticsLocationInfoList
209 
     - runCompleteUpdate
7738 manish.sha 210 
    """
211 
    pass
212 
 
7888 rajveer 213 
  def adjustDeliveryDays(self, startDate, days):
214 
    """
215 
    Parameters:
216 
     - startDate
217 
     - days
218 
    """
219 
    pass
7738 manish.sha 220 
 
12895 manish.sha 221 
  def getFirstDeliveryEstimateForWhLocation(self, pincode, whLocation):
222 
    """
223 
    Parameters:
224 
     - pincode
225 
     - whLocation
226 
    """
227 
    pass
7888 rajveer 228 
 
13146 manish.sha 229 
  def getNewEmptyAwb(self, providerId, type, orderQuantity):
230 
    """
231 
    Parameters:
232 
     - providerId
233 
     - type
234 
     - orderQuantity
235 
    """
236 
    pass
12895 manish.sha 237 
 
13146 manish.sha 238 
  def getProviderLimitDetailsForPincode(self, providerId, pincode):
239 
    """
240 
    Parameters:
241 
     - providerId
242 
     - pincode
243 
    """
244 
    pass
245 
 
19413 amit.gupta 246 
  def getLocationInfoMap(self, destPincode, price):
247 
    """
248 
    This returns map for locations and providers corresponding their serviceability and delay
13146 manish.sha 249 
 
19413 amit.gupta 250 
    Parameters:
251 
     - destPincode
252 
     - price
253 
    """
254 
    pass
255 
 
19474 manish.sha 256 
  def getCostingAndDeliveryEstimateForPincode(self, pincode, transactionAmount, isCod, weight, billingWarehouseId, isCompleteTxn):
257 
    """
258 
    Parameters:
259 
     - pincode
260 
     - transactionAmount
261 
     - isCod
262 
     - weight
263 
     - billingWarehouseId
264 
     - isCompleteTxn
265 
    """
266 
    pass
19413 amit.gupta 267 
 
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 
 
20724 kshitij.so 453 
  def getEmptyAWB(self, providerId, logisticsTransactionId):
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
20724 kshitij.so 459 
     - logisticsTransactionId
412 ashish 460 
    """
20724 kshitij.so 461 
    self.send_getEmptyAWB(providerId, logisticsTransactionId)
412 ashish 462 
    return self.recv_getEmptyAWB()
463 
 
20724 kshitij.so 464 
  def send_getEmptyAWB(self, providerId, logisticsTransactionId):
412 ashish 465 
    self._oprot.writeMessageBegin('getEmptyAWB', TMessageType.CALL, self._seqid)
466 
    args = getEmptyAWB_args()
647 chandransh 467 
    args.providerId = providerId
20724 kshitij.so 468 
    args.logisticsTransactionId = logisticsTransactionId
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:
20724 kshitij.so 1296 
      result.success = self._handler.getEmptyAWB(args.providerId, args.logisticsTransactionId)
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
20724 kshitij.so 2291 
   - logisticsTransactionId
412 ashish 2292 
  """
2293 
 
20724 kshitij.so 2294 
  thrift_spec = (
2295 
    None, # 0
2296 
    (1, TType.I64, 'providerId', None, None, ), # 1
2297 
    (2, TType.STRING, 'logisticsTransactionId', None, None, ), # 2
2298 
  )
2299 
 
2300 
  def __init__(self, providerId=None, logisticsTransactionId=None,):
647 chandransh 2301 
    self.providerId = providerId
20724 kshitij.so 2302 
    self.logisticsTransactionId = logisticsTransactionId
412 ashish 2303 
 
2304 
  def read(self, iprot):
2305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2307 
      return
2308 
    iprot.readStructBegin()
2309 
    while True:
2310 
      (fname, ftype, fid) = iprot.readFieldBegin()
2311 
      if ftype == TType.STOP:
2312 
        break
2313 
      if fid == 1:
2314 
        if ftype == TType.I64:
647 chandransh 2315 
          self.providerId = iprot.readI64();
412 ashish 2316 
        else:
2317 
          iprot.skip(ftype)
20724 kshitij.so 2318 
      elif fid == 2:
2319 
        if ftype == TType.STRING:
2320 
          self.logisticsTransactionId = iprot.readString();
5247 rajveer 2321 
        else:
2322 
          iprot.skip(ftype)
412 ashish 2323 
      else:
2324 
        iprot.skip(ftype)
2325 
      iprot.readFieldEnd()
2326 
    iprot.readStructEnd()
2327 
 
2328 
  def write(self, oprot):
2329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2331 
      return
2332 
    oprot.writeStructBegin('getEmptyAWB_args')
3431 rajveer 2333 
    if self.providerId is not None:
647 chandransh 2334 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
2335 
      oprot.writeI64(self.providerId)
412 ashish 2336 
      oprot.writeFieldEnd()
20724 kshitij.so 2337 
    if self.logisticsTransactionId is not None:
2338 
      oprot.writeFieldBegin('logisticsTransactionId', TType.STRING, 2)
2339 
      oprot.writeString(self.logisticsTransactionId)
2340 
      oprot.writeFieldEnd()
412 ashish 2341 
    oprot.writeFieldStop()
2342 
    oprot.writeStructEnd()
2343 
 
3431 rajveer 2344 
  def validate(self):
2345 
    return
2346 
 
2347 
 
412 ashish 2348 
  def __repr__(self):
2349 
    L = ['%s=%r' % (key, value)
2350 
      for key, value in self.__dict__.iteritems()]
2351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2352 
 
2353 
  def __eq__(self, other):
2354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2355 
 
2356 
  def __ne__(self, other):
2357 
    return not (self == other)
2358 
 
2359 
class getEmptyAWB_result:
2360 
  """
2361 
  Attributes:
2362 
   - success
647 chandransh 2363 
   - se
412 ashish 2364 
  """
2365 
 
2366 
  thrift_spec = (
2367 
    (0, TType.STRING, 'success', None, None, ), # 0
647 chandransh 2368 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
412 ashish 2369 
  )
2370 
 
647 chandransh 2371 
  def __init__(self, success=None, se=None,):
412 ashish 2372 
    self.success = success
647 chandransh 2373 
    self.se = se
412 ashish 2374 
 
2375 
  def read(self, iprot):
2376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2378 
      return
2379 
    iprot.readStructBegin()
2380 
    while True:
2381 
      (fname, ftype, fid) = iprot.readFieldBegin()
2382 
      if ftype == TType.STOP:
2383 
        break
2384 
      if fid == 0:
2385 
        if ftype == TType.STRING:
2386 
          self.success = iprot.readString();
2387 
        else:
2388 
          iprot.skip(ftype)
647 chandransh 2389 
      elif fid == 1:
2390 
        if ftype == TType.STRUCT:
2391 
          self.se = LogisticsServiceException()
2392 
          self.se.read(iprot)
2393 
        else:
2394 
          iprot.skip(ftype)
412 ashish 2395 
      else:
2396 
        iprot.skip(ftype)
2397 
      iprot.readFieldEnd()
2398 
    iprot.readStructEnd()
2399 
 
2400 
  def write(self, oprot):
2401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2403 
      return
2404 
    oprot.writeStructBegin('getEmptyAWB_result')
3431 rajveer 2405 
    if self.success is not None:
412 ashish 2406 
      oprot.writeFieldBegin('success', TType.STRING, 0)
2407 
      oprot.writeString(self.success)
2408 
      oprot.writeFieldEnd()
3431 rajveer 2409 
    if self.se is not None:
647 chandransh 2410 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2411 
      self.se.write(oprot)
2412 
      oprot.writeFieldEnd()
412 ashish 2413 
    oprot.writeFieldStop()
2414 
    oprot.writeStructEnd()
2415 
 
3431 rajveer 2416 
  def validate(self):
2417 
    return
2418 
 
2419 
 
412 ashish 2420 
  def __repr__(self):
2421 
    L = ['%s=%r' % (key, value)
2422 
      for key, value in self.__dict__.iteritems()]
2423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2424 
 
2425 
  def __eq__(self, other):
2426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2427 
 
2428 
  def __ne__(self, other):
2429 
    return not (self == other)
2430 
 
2431 
class getShipmentInfo_args:
2432 
  """
2433 
  Attributes:
6643 rajveer 2434 
   - awbNumber
647 chandransh 2435 
   - providerId
412 ashish 2436 
  """
2437 
 
2438 
  thrift_spec = (
2439 
    None, # 0
6643 rajveer 2440 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
647 chandransh 2441 
    (2, TType.I64, 'providerId', None, None, ), # 2
412 ashish 2442 
  )
2443 
 
6643 rajveer 2444 
  def __init__(self, awbNumber=None, providerId=None,):
2445 
    self.awbNumber = awbNumber
647 chandransh 2446 
    self.providerId = providerId
412 ashish 2447 
 
2448 
  def read(self, iprot):
2449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2451 
      return
2452 
    iprot.readStructBegin()
2453 
    while True:
2454 
      (fname, ftype, fid) = iprot.readFieldBegin()
2455 
      if ftype == TType.STOP:
2456 
        break
2457 
      if fid == 1:
2458 
        if ftype == TType.STRING:
6643 rajveer 2459 
          self.awbNumber = iprot.readString();
412 ashish 2460 
        else:
2461 
          iprot.skip(ftype)
647 chandransh 2462 
      elif fid == 2:
2463 
        if ftype == TType.I64:
2464 
          self.providerId = iprot.readI64();
2465 
        else:
2466 
          iprot.skip(ftype)
412 ashish 2467 
      else:
2468 
        iprot.skip(ftype)
2469 
      iprot.readFieldEnd()
2470 
    iprot.readStructEnd()
2471 
 
2472 
  def write(self, oprot):
2473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2475 
      return
2476 
    oprot.writeStructBegin('getShipmentInfo_args')
6643 rajveer 2477 
    if self.awbNumber is not None:
2478 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
2479 
      oprot.writeString(self.awbNumber)
412 ashish 2480 
      oprot.writeFieldEnd()
3431 rajveer 2481 
    if self.providerId is not None:
647 chandransh 2482 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
2483 
      oprot.writeI64(self.providerId)
2484 
      oprot.writeFieldEnd()
412 ashish 2485 
    oprot.writeFieldStop()
2486 
    oprot.writeStructEnd()
2487 
 
3431 rajveer 2488 
  def validate(self):
2489 
    return
2490 
 
2491 
 
412 ashish 2492 
  def __repr__(self):
2493 
    L = ['%s=%r' % (key, value)
2494 
      for key, value in self.__dict__.iteritems()]
2495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2496 
 
2497 
  def __eq__(self, other):
2498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2499 
 
2500 
  def __ne__(self, other):
2501 
    return not (self == other)
2502 
 
2503 
class getShipmentInfo_result:
2504 
  """
2505 
  Attributes:
2506 
   - success
647 chandransh 2507 
   - se
412 ashish 2508 
  """
2509 
 
2510 
  thrift_spec = (
644 chandransh 2511 
    (0, TType.LIST, 'success', (TType.STRUCT,(AwbUpdate, AwbUpdate.thrift_spec)), None, ), # 0
647 chandransh 2512 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
412 ashish 2513 
  )
2514 
 
647 chandransh 2515 
  def __init__(self, success=None, se=None,):
412 ashish 2516 
    self.success = success
647 chandransh 2517 
    self.se = se
412 ashish 2518 
 
2519 
  def read(self, iprot):
2520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2522 
      return
2523 
    iprot.readStructBegin()
2524 
    while True:
2525 
      (fname, ftype, fid) = iprot.readFieldBegin()
2526 
      if ftype == TType.STOP:
2527 
        break
2528 
      if fid == 0:
2529 
        if ftype == TType.LIST:
2530 
          self.success = []
7792 anupam.sin 2531 
          (_etype17, _size14) = iprot.readListBegin()
2532 
          for _i18 in xrange(_size14):
2533 
            _elem19 = AwbUpdate()
2534 
            _elem19.read(iprot)
2535 
            self.success.append(_elem19)
412 ashish 2536 
          iprot.readListEnd()
2537 
        else:
2538 
          iprot.skip(ftype)
647 chandransh 2539 
      elif fid == 1:
2540 
        if ftype == TType.STRUCT:
2541 
          self.se = LogisticsServiceException()
2542 
          self.se.read(iprot)
2543 
        else:
2544 
          iprot.skip(ftype)
412 ashish 2545 
      else:
2546 
        iprot.skip(ftype)
2547 
      iprot.readFieldEnd()
2548 
    iprot.readStructEnd()
2549 
 
2550 
  def write(self, oprot):
2551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2553 
      return
644 chandransh 2554 
    oprot.writeStructBegin('getShipmentInfo_result')
3431 rajveer 2555 
    if self.success is not None:
412 ashish 2556 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2557 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7792 anupam.sin 2558 
      for iter20 in self.success:
2559 
        iter20.write(oprot)
412 ashish 2560 
      oprot.writeListEnd()
2561 
      oprot.writeFieldEnd()
3431 rajveer 2562 
    if self.se is not None:
647 chandransh 2563 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2564 
      self.se.write(oprot)
2565 
      oprot.writeFieldEnd()
412 ashish 2566 
    oprot.writeFieldStop()
2567 
    oprot.writeStructEnd()
2568 
 
3431 rajveer 2569 
  def validate(self):
2570 
    return
2571 
 
2572 
 
412 ashish 2573 
  def __repr__(self):
2574 
    L = ['%s=%r' % (key, value)
2575 
      for key, value in self.__dict__.iteritems()]
2576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2577 
 
2578 
  def __eq__(self, other):
2579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2580 
 
2581 
  def __ne__(self, other):
2582 
    return not (self == other)
2583 
 
6643 rajveer 2584 
class storeShipmentInfo_args:
2585 
  """
2586 
  Attributes:
2587 
   - update
2588 
  """
2589 
 
2590 
  thrift_spec = (
2591 
    None, # 0
2592 
    (1, TType.STRUCT, 'update', (AwbUpdate, AwbUpdate.thrift_spec), None, ), # 1
2593 
  )
2594 
 
2595 
  def __init__(self, update=None,):
2596 
    self.update = update
2597 
 
2598 
  def read(self, iprot):
2599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2601 
      return
2602 
    iprot.readStructBegin()
2603 
    while True:
2604 
      (fname, ftype, fid) = iprot.readFieldBegin()
2605 
      if ftype == TType.STOP:
2606 
        break
2607 
      if fid == 1:
2608 
        if ftype == TType.STRUCT:
2609 
          self.update = AwbUpdate()
2610 
          self.update.read(iprot)
2611 
        else:
2612 
          iprot.skip(ftype)
2613 
      else:
2614 
        iprot.skip(ftype)
2615 
      iprot.readFieldEnd()
2616 
    iprot.readStructEnd()
2617 
 
2618 
  def write(self, oprot):
2619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2621 
      return
2622 
    oprot.writeStructBegin('storeShipmentInfo_args')
2623 
    if self.update is not None:
2624 
      oprot.writeFieldBegin('update', TType.STRUCT, 1)
2625 
      self.update.write(oprot)
2626 
      oprot.writeFieldEnd()
2627 
    oprot.writeFieldStop()
2628 
    oprot.writeStructEnd()
2629 
 
2630 
  def validate(self):
2631 
    return
2632 
 
2633 
 
2634 
  def __repr__(self):
2635 
    L = ['%s=%r' % (key, value)
2636 
      for key, value in self.__dict__.iteritems()]
2637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2638 
 
2639 
  def __eq__(self, other):
2640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2641 
 
2642 
  def __ne__(self, other):
2643 
    return not (self == other)
2644 
 
2645 
class storeShipmentInfo_result:
2646 
  """
2647 
  Attributes:
2648 
   - se
2649 
  """
2650 
 
2651 
  thrift_spec = (
2652 
    None, # 0
2653 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
2654 
  )
2655 
 
2656 
  def __init__(self, se=None,):
2657 
    self.se = se
2658 
 
2659 
  def read(self, iprot):
2660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2662 
      return
2663 
    iprot.readStructBegin()
2664 
    while True:
2665 
      (fname, ftype, fid) = iprot.readFieldBegin()
2666 
      if ftype == TType.STOP:
2667 
        break
2668 
      if fid == 1:
2669 
        if ftype == TType.STRUCT:
2670 
          self.se = LogisticsServiceException()
2671 
          self.se.read(iprot)
2672 
        else:
2673 
          iprot.skip(ftype)
2674 
      else:
2675 
        iprot.skip(ftype)
2676 
      iprot.readFieldEnd()
2677 
    iprot.readStructEnd()
2678 
 
2679 
  def write(self, oprot):
2680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2682 
      return
2683 
    oprot.writeStructBegin('storeShipmentInfo_result')
2684 
    if self.se is not None:
2685 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2686 
      self.se.write(oprot)
2687 
      oprot.writeFieldEnd()
2688 
    oprot.writeFieldStop()
2689 
    oprot.writeStructEnd()
2690 
 
2691 
  def validate(self):
2692 
    return
2693 
 
2694 
 
2695 
  def __repr__(self):
2696 
    L = ['%s=%r' % (key, value)
2697 
      for key, value in self.__dict__.iteritems()]
2698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2699 
 
2700 
  def __eq__(self, other):
2701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2702 
 
2703 
  def __ne__(self, other):
2704 
    return not (self == other)
2705 
 
732 chandransh 2706 
class getDestinationCode_args:
2707 
  """
2708 
  Attributes:
2709 
   - providerId
2710 
   - pinCode
2711 
  """
412 ashish 2712 
 
732 chandransh 2713 
  thrift_spec = (
2714 
    None, # 0
2715 
    (1, TType.I64, 'providerId', None, None, ), # 1
2716 
    (2, TType.STRING, 'pinCode', None, None, ), # 2
2717 
  )
2718 
 
2719 
  def __init__(self, providerId=None, pinCode=None,):
2720 
    self.providerId = providerId
2721 
    self.pinCode = pinCode
2722 
 
2723 
  def read(self, iprot):
2724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2726 
      return
2727 
    iprot.readStructBegin()
2728 
    while True:
2729 
      (fname, ftype, fid) = iprot.readFieldBegin()
2730 
      if ftype == TType.STOP:
2731 
        break
2732 
      if fid == 1:
2733 
        if ftype == TType.I64:
2734 
          self.providerId = iprot.readI64();
2735 
        else:
2736 
          iprot.skip(ftype)
2737 
      elif fid == 2:
2738 
        if ftype == TType.STRING:
2739 
          self.pinCode = iprot.readString();
2740 
        else:
2741 
          iprot.skip(ftype)
2742 
      else:
2743 
        iprot.skip(ftype)
2744 
      iprot.readFieldEnd()
2745 
    iprot.readStructEnd()
2746 
 
2747 
  def write(self, oprot):
2748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2750 
      return
2751 
    oprot.writeStructBegin('getDestinationCode_args')
3431 rajveer 2752 
    if self.providerId is not None:
732 chandransh 2753 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
2754 
      oprot.writeI64(self.providerId)
2755 
      oprot.writeFieldEnd()
3431 rajveer 2756 
    if self.pinCode is not None:
732 chandransh 2757 
      oprot.writeFieldBegin('pinCode', TType.STRING, 2)
2758 
      oprot.writeString(self.pinCode)
2759 
      oprot.writeFieldEnd()
2760 
    oprot.writeFieldStop()
2761 
    oprot.writeStructEnd()
2762 
 
3431 rajveer 2763 
  def validate(self):
2764 
    return
2765 
 
2766 
 
732 chandransh 2767 
  def __repr__(self):
2768 
    L = ['%s=%r' % (key, value)
2769 
      for key, value in self.__dict__.iteritems()]
2770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2771 
 
2772 
  def __eq__(self, other):
2773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2774 
 
2775 
  def __ne__(self, other):
2776 
    return not (self == other)
2777 
 
2778 
class getDestinationCode_result:
2779 
  """
2780 
  Attributes:
2781 
   - success
2782 
   - se
2783 
  """
2784 
 
2785 
  thrift_spec = (
2786 
    (0, TType.STRING, 'success', None, None, ), # 0
2787 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
2788 
  )
2789 
 
2790 
  def __init__(self, success=None, se=None,):
2791 
    self.success = success
2792 
    self.se = se
2793 
 
2794 
  def read(self, iprot):
2795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2797 
      return
2798 
    iprot.readStructBegin()
2799 
    while True:
2800 
      (fname, ftype, fid) = iprot.readFieldBegin()
2801 
      if ftype == TType.STOP:
2802 
        break
2803 
      if fid == 0:
2804 
        if ftype == TType.STRING:
2805 
          self.success = iprot.readString();
2806 
        else:
2807 
          iprot.skip(ftype)
2808 
      elif fid == 1:
2809 
        if ftype == TType.STRUCT:
2810 
          self.se = LogisticsServiceException()
2811 
          self.se.read(iprot)
2812 
        else:
2813 
          iprot.skip(ftype)
2814 
      else:
2815 
        iprot.skip(ftype)
2816 
      iprot.readFieldEnd()
2817 
    iprot.readStructEnd()
2818 
 
2819 
  def write(self, oprot):
2820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2822 
      return
2823 
    oprot.writeStructBegin('getDestinationCode_result')
3431 rajveer 2824 
    if self.success is not None:
732 chandransh 2825 
      oprot.writeFieldBegin('success', TType.STRING, 0)
2826 
      oprot.writeString(self.success)
2827 
      oprot.writeFieldEnd()
3431 rajveer 2828 
    if self.se is not None:
732 chandransh 2829 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
2830 
      self.se.write(oprot)
2831 
      oprot.writeFieldEnd()
2832 
    oprot.writeFieldStop()
2833 
    oprot.writeStructEnd()
2834 
 
3431 rajveer 2835 
  def validate(self):
2836 
    return
2837 
 
2838 
 
732 chandransh 2839 
  def __repr__(self):
2840 
    L = ['%s=%r' % (key, value)
2841 
      for key, value in self.__dict__.iteritems()]
2842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2843 
 
2844 
  def __eq__(self, other):
2845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2846 
 
2847 
  def __ne__(self, other):
2848 
    return not (self == other)
2849 
 
1137 chandransh 2850 
class getFreeAwbCount_args:
2851 
  """
2852 
  Attributes:
2853 
   - providerId
3103 chandransh 2854 
   - type
1137 chandransh 2855 
  """
732 chandransh 2856 
 
1137 chandransh 2857 
  thrift_spec = (
2858 
    None, # 0
2859 
    (1, TType.I64, 'providerId', None, None, ), # 1
3103 chandransh 2860 
    (2, TType.STRING, 'type', None, None, ), # 2
1137 chandransh 2861 
  )
2862 
 
3103 chandransh 2863 
  def __init__(self, providerId=None, type=None,):
1137 chandransh 2864 
    self.providerId = providerId
3103 chandransh 2865 
    self.type = type
1137 chandransh 2866 
 
2867 
  def read(self, iprot):
2868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2870 
      return
2871 
    iprot.readStructBegin()
2872 
    while True:
2873 
      (fname, ftype, fid) = iprot.readFieldBegin()
2874 
      if ftype == TType.STOP:
2875 
        break
2876 
      if fid == 1:
2877 
        if ftype == TType.I64:
2878 
          self.providerId = iprot.readI64();
2879 
        else:
2880 
          iprot.skip(ftype)
3103 chandransh 2881 
      elif fid == 2:
2882 
        if ftype == TType.STRING:
2883 
          self.type = iprot.readString();
2884 
        else:
2885 
          iprot.skip(ftype)
1137 chandransh 2886 
      else:
2887 
        iprot.skip(ftype)
2888 
      iprot.readFieldEnd()
2889 
    iprot.readStructEnd()
2890 
 
2891 
  def write(self, oprot):
2892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2894 
      return
2895 
    oprot.writeStructBegin('getFreeAwbCount_args')
3431 rajveer 2896 
    if self.providerId is not None:
1137 chandransh 2897 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
2898 
      oprot.writeI64(self.providerId)
2899 
      oprot.writeFieldEnd()
3431 rajveer 2900 
    if self.type is not None:
3103 chandransh 2901 
      oprot.writeFieldBegin('type', TType.STRING, 2)
2902 
      oprot.writeString(self.type)
2903 
      oprot.writeFieldEnd()
1137 chandransh 2904 
    oprot.writeFieldStop()
2905 
    oprot.writeStructEnd()
2906 
 
3431 rajveer 2907 
  def validate(self):
2908 
    return
2909 
 
2910 
 
1137 chandransh 2911 
  def __repr__(self):
2912 
    L = ['%s=%r' % (key, value)
2913 
      for key, value in self.__dict__.iteritems()]
2914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2915 
 
2916 
  def __eq__(self, other):
2917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2918 
 
2919 
  def __ne__(self, other):
2920 
    return not (self == other)
2921 
 
2922 
class getFreeAwbCount_result:
2923 
  """
2924 
  Attributes:
2925 
   - success
2926 
  """
2927 
 
2928 
  thrift_spec = (
2929 
    (0, TType.I64, 'success', None, None, ), # 0
2930 
  )
2931 
 
2932 
  def __init__(self, success=None,):
2933 
    self.success = success
2934 
 
2935 
  def read(self, iprot):
2936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2938 
      return
2939 
    iprot.readStructBegin()
2940 
    while True:
2941 
      (fname, ftype, fid) = iprot.readFieldBegin()
2942 
      if ftype == TType.STOP:
2943 
        break
2944 
      if fid == 0:
2945 
        if ftype == TType.I64:
2946 
          self.success = iprot.readI64();
2947 
        else:
2948 
          iprot.skip(ftype)
2949 
      else:
2950 
        iprot.skip(ftype)
2951 
      iprot.readFieldEnd()
2952 
    iprot.readStructEnd()
2953 
 
2954 
  def write(self, oprot):
2955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2957 
      return
2958 
    oprot.writeStructBegin('getFreeAwbCount_result')
3431 rajveer 2959 
    if self.success is not None:
1137 chandransh 2960 
      oprot.writeFieldBegin('success', TType.I64, 0)
2961 
      oprot.writeI64(self.success)
2962 
      oprot.writeFieldEnd()
2963 
    oprot.writeFieldStop()
2964 
    oprot.writeStructEnd()
2965 
 
3431 rajveer 2966 
  def validate(self):
2967 
    return
2968 
 
2969 
 
1137 chandransh 2970 
  def __repr__(self):
2971 
    L = ['%s=%r' % (key, value)
2972 
      for key, value in self.__dict__.iteritems()]
2973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2974 
 
2975 
  def __eq__(self, other):
2976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2977 
 
2978 
  def __ne__(self, other):
2979 
    return not (self == other)
2980 
 
1730 ankur.sing 2981 
class getHolidays_args:
2982 
  """
2983 
  Attributes:
2984 
   - fromDate
2985 
   - toDate
2986 
  """
1137 chandransh 2987 
 
1730 ankur.sing 2988 
  thrift_spec = (
2989 
    None, # 0
2990 
    (1, TType.I64, 'fromDate', None, None, ), # 1
2991 
    (2, TType.I64, 'toDate', None, None, ), # 2
2992 
  )
2993 
 
2994 
  def __init__(self, fromDate=None, toDate=None,):
2995 
    self.fromDate = fromDate
2996 
    self.toDate = toDate
2997 
 
2998 
  def read(self, iprot):
2999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3001 
      return
3002 
    iprot.readStructBegin()
3003 
    while True:
3004 
      (fname, ftype, fid) = iprot.readFieldBegin()
3005 
      if ftype == TType.STOP:
3006 
        break
3007 
      if fid == 1:
3008 
        if ftype == TType.I64:
3009 
          self.fromDate = iprot.readI64();
3010 
        else:
3011 
          iprot.skip(ftype)
3012 
      elif fid == 2:
3013 
        if ftype == TType.I64:
3014 
          self.toDate = iprot.readI64();
3015 
        else:
3016 
          iprot.skip(ftype)
3017 
      else:
3018 
        iprot.skip(ftype)
3019 
      iprot.readFieldEnd()
3020 
    iprot.readStructEnd()
3021 
 
3022 
  def write(self, oprot):
3023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3025 
      return
3026 
    oprot.writeStructBegin('getHolidays_args')
3431 rajveer 3027 
    if self.fromDate is not None:
1730 ankur.sing 3028 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
3029 
      oprot.writeI64(self.fromDate)
3030 
      oprot.writeFieldEnd()
3431 rajveer 3031 
    if self.toDate is not None:
1730 ankur.sing 3032 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
3033 
      oprot.writeI64(self.toDate)
3034 
      oprot.writeFieldEnd()
3035 
    oprot.writeFieldStop()
3036 
    oprot.writeStructEnd()
3037 
 
3431 rajveer 3038 
  def validate(self):
3039 
    return
3040 
 
3041 
 
1730 ankur.sing 3042 
  def __repr__(self):
3043 
    L = ['%s=%r' % (key, value)
3044 
      for key, value in self.__dict__.iteritems()]
3045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3046 
 
3047 
  def __eq__(self, other):
3048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3049 
 
3050 
  def __ne__(self, other):
3051 
    return not (self == other)
3052 
 
3053 
class getHolidays_result:
3054 
  """
3055 
  Attributes:
3056 
   - success
3057 
  """
3058 
 
3059 
  thrift_spec = (
3060 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
3061 
  )
3062 
 
3063 
  def __init__(self, success=None,):
3064 
    self.success = success
3065 
 
3066 
  def read(self, iprot):
3067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3069 
      return
3070 
    iprot.readStructBegin()
3071 
    while True:
3072 
      (fname, ftype, fid) = iprot.readFieldBegin()
3073 
      if ftype == TType.STOP:
3074 
        break
3075 
      if fid == 0:
3076 
        if ftype == TType.LIST:
3077 
          self.success = []
7792 anupam.sin 3078 
          (_etype24, _size21) = iprot.readListBegin()
3079 
          for _i25 in xrange(_size21):
3080 
            _elem26 = iprot.readI64();
3081 
            self.success.append(_elem26)
1730 ankur.sing 3082 
          iprot.readListEnd()
3083 
        else:
3084 
          iprot.skip(ftype)
3085 
      else:
3086 
        iprot.skip(ftype)
3087 
      iprot.readFieldEnd()
3088 
    iprot.readStructEnd()
3089 
 
3090 
  def write(self, oprot):
3091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3093 
      return
3094 
    oprot.writeStructBegin('getHolidays_result')
3431 rajveer 3095 
    if self.success is not None:
1730 ankur.sing 3096 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3097 
      oprot.writeListBegin(TType.I64, len(self.success))
7792 anupam.sin 3098 
      for iter27 in self.success:
3099 
        oprot.writeI64(iter27)
1730 ankur.sing 3100 
      oprot.writeListEnd()
3101 
      oprot.writeFieldEnd()
3102 
    oprot.writeFieldStop()
3103 
    oprot.writeStructEnd()
3104 
 
3431 rajveer 3105 
  def validate(self):
3106 
    return
3107 
 
3108 
 
1730 ankur.sing 3109 
  def __repr__(self):
3110 
    L = ['%s=%r' % (key, value)
3111 
      for key, value in self.__dict__.iteritems()]
3112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3113 
 
3114 
  def __eq__(self, other):
3115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3116 
 
3117 
  def __ne__(self, other):
3118 
    return not (self == other)
4934 amit.gupta 3119 
 
3120 
class getEntityLogisticsEstimation_args:
3121 
  """
3122 
  Attributes:
3123 
   - catalogItemId
3124 
   - destination_pin
3125 
   - type
3126 
  """
3127 
 
3128 
  thrift_spec = (
3129 
    None, # 0
3130 
    (1, TType.I64, 'catalogItemId', None, None, ), # 1
3131 
    (2, TType.STRING, 'destination_pin', None, None, ), # 2
3132 
    (3, TType.I32, 'type', None, None, ), # 3
3133 
  )
3134 
 
3135 
  def __init__(self, catalogItemId=None, destination_pin=None, type=None,):
3136 
    self.catalogItemId = catalogItemId
3137 
    self.destination_pin = destination_pin
3138 
    self.type = type
3139 
 
3140 
  def read(self, iprot):
3141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3143 
      return
3144 
    iprot.readStructBegin()
3145 
    while True:
3146 
      (fname, ftype, fid) = iprot.readFieldBegin()
3147 
      if ftype == TType.STOP:
3148 
        break
3149 
      if fid == 1:
3150 
        if ftype == TType.I64:
3151 
          self.catalogItemId = iprot.readI64();
3152 
        else:
3153 
          iprot.skip(ftype)
3154 
      elif fid == 2:
3155 
        if ftype == TType.STRING:
3156 
          self.destination_pin = iprot.readString();
3157 
        else:
3158 
          iprot.skip(ftype)
3159 
      elif fid == 3:
3160 
        if ftype == TType.I32:
3161 
          self.type = iprot.readI32();
3162 
        else:
3163 
          iprot.skip(ftype)
3164 
      else:
3165 
        iprot.skip(ftype)
3166 
      iprot.readFieldEnd()
3167 
    iprot.readStructEnd()
3168 
 
3169 
  def write(self, oprot):
3170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3172 
      return
3173 
    oprot.writeStructBegin('getEntityLogisticsEstimation_args')
3174 
    if self.catalogItemId is not None:
3175 
      oprot.writeFieldBegin('catalogItemId', TType.I64, 1)
3176 
      oprot.writeI64(self.catalogItemId)
3177 
      oprot.writeFieldEnd()
3178 
    if self.destination_pin is not None:
3179 
      oprot.writeFieldBegin('destination_pin', TType.STRING, 2)
3180 
      oprot.writeString(self.destination_pin)
3181 
      oprot.writeFieldEnd()
3182 
    if self.type is not None:
3183 
      oprot.writeFieldBegin('type', TType.I32, 3)
3184 
      oprot.writeI32(self.type)
3185 
      oprot.writeFieldEnd()
3186 
    oprot.writeFieldStop()
3187 
    oprot.writeStructEnd()
3188 
 
3189 
  def validate(self):
3190 
    return
3191 
 
3192 
 
3193 
  def __repr__(self):
3194 
    L = ['%s=%r' % (key, value)
3195 
      for key, value in self.__dict__.iteritems()]
3196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3197 
 
3198 
  def __eq__(self, other):
3199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3200 
 
3201 
  def __ne__(self, other):
3202 
    return not (self == other)
3203 
 
3204 
class getEntityLogisticsEstimation_result:
3205 
  """
3206 
  Attributes:
3207 
   - success
3208 
   - se
3209 
  """
3210 
 
3211 
  thrift_spec = (
9840 amit.gupta 3212 
    (0, TType.LIST, 'success', (TType.STRUCT,(ItemText, ItemText.thrift_spec)), None, ), # 0
4934 amit.gupta 3213 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
3214 
  )
3215 
 
3216 
  def __init__(self, success=None, se=None,):
3217 
    self.success = success
3218 
    self.se = se
3219 
 
3220 
  def read(self, iprot):
3221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3223 
      return
3224 
    iprot.readStructBegin()
3225 
    while True:
3226 
      (fname, ftype, fid) = iprot.readFieldBegin()
3227 
      if ftype == TType.STOP:
3228 
        break
3229 
      if fid == 0:
3230 
        if ftype == TType.LIST:
3231 
          self.success = []
7792 anupam.sin 3232 
          (_etype31, _size28) = iprot.readListBegin()
3233 
          for _i32 in xrange(_size28):
9840 amit.gupta 3234 
            _elem33 = ItemText()
3235 
            _elem33.read(iprot)
7792 anupam.sin 3236 
            self.success.append(_elem33)
4934 amit.gupta 3237 
          iprot.readListEnd()
3238 
        else:
3239 
          iprot.skip(ftype)
3240 
      elif fid == 1:
3241 
        if ftype == TType.STRUCT:
3242 
          self.se = LogisticsServiceException()
3243 
          self.se.read(iprot)
3244 
        else:
3245 
          iprot.skip(ftype)
3246 
      else:
3247 
        iprot.skip(ftype)
3248 
      iprot.readFieldEnd()
3249 
    iprot.readStructEnd()
3250 
 
3251 
  def write(self, oprot):
3252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3254 
      return
3255 
    oprot.writeStructBegin('getEntityLogisticsEstimation_result')
3256 
    if self.success is not None:
3257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9840 amit.gupta 3258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7792 anupam.sin 3259 
      for iter34 in self.success:
9840 amit.gupta 3260 
        iter34.write(oprot)
4934 amit.gupta 3261 
      oprot.writeListEnd()
3262 
      oprot.writeFieldEnd()
3263 
    if self.se is not None:
3264 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
3265 
      self.se.write(oprot)
3266 
      oprot.writeFieldEnd()
3267 
    oprot.writeFieldStop()
3268 
    oprot.writeStructEnd()
3269 
 
3270 
  def validate(self):
3271 
    return
3272 
 
3273 
 
3274 
  def __repr__(self):
3275 
    L = ['%s=%r' % (key, value)
3276 
      for key, value in self.__dict__.iteritems()]
3277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3278 
 
3279 
  def __eq__(self, other):
3280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3281 
 
3282 
  def __ne__(self, other):
3283 
    return not (self == other)
5527 anupam.sin 3284 
 
3285 
class getProviderForPickupType_args:
3286 
  """
3287 
  Attributes:
3288 
   - pickUp
3289 
  """
3290 
 
3291 
  thrift_spec = (
3292 
    None, # 0
3293 
    (1, TType.I64, 'pickUp', None, None, ), # 1
3294 
  )
3295 
 
3296 
  def __init__(self, pickUp=None,):
3297 
    self.pickUp = pickUp
3298 
 
3299 
  def read(self, iprot):
3300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3302 
      return
3303 
    iprot.readStructBegin()
3304 
    while True:
3305 
      (fname, ftype, fid) = iprot.readFieldBegin()
3306 
      if ftype == TType.STOP:
3307 
        break
3308 
      if fid == 1:
3309 
        if ftype == TType.I64:
3310 
          self.pickUp = iprot.readI64();
3311 
        else:
3312 
          iprot.skip(ftype)
3313 
      else:
3314 
        iprot.skip(ftype)
3315 
      iprot.readFieldEnd()
3316 
    iprot.readStructEnd()
3317 
 
3318 
  def write(self, oprot):
3319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3321 
      return
3322 
    oprot.writeStructBegin('getProviderForPickupType_args')
3323 
    if self.pickUp is not None:
3324 
      oprot.writeFieldBegin('pickUp', TType.I64, 1)
3325 
      oprot.writeI64(self.pickUp)
3326 
      oprot.writeFieldEnd()
3327 
    oprot.writeFieldStop()
3328 
    oprot.writeStructEnd()
3329 
 
3330 
  def validate(self):
3331 
    return
3332 
 
3333 
 
3334 
  def __repr__(self):
3335 
    L = ['%s=%r' % (key, value)
3336 
      for key, value in self.__dict__.iteritems()]
3337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3338 
 
3339 
  def __eq__(self, other):
3340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3341 
 
3342 
  def __ne__(self, other):
3343 
    return not (self == other)
3344 
 
3345 
class getProviderForPickupType_result:
3346 
  """
3347 
  Attributes:
3348 
   - success
3349 
  """
3350 
 
3351 
  thrift_spec = (
3352 
    (0, TType.I64, 'success', None, None, ), # 0
3353 
  )
3354 
 
3355 
  def __init__(self, success=None,):
3356 
    self.success = success
3357 
 
3358 
  def read(self, iprot):
3359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3361 
      return
3362 
    iprot.readStructBegin()
3363 
    while True:
3364 
      (fname, ftype, fid) = iprot.readFieldBegin()
3365 
      if ftype == TType.STOP:
3366 
        break
3367 
      if fid == 0:
3368 
        if ftype == TType.I64:
3369 
          self.success = iprot.readI64();
3370 
        else:
3371 
          iprot.skip(ftype)
3372 
      else:
3373 
        iprot.skip(ftype)
3374 
      iprot.readFieldEnd()
3375 
    iprot.readStructEnd()
3376 
 
3377 
  def write(self, oprot):
3378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3380 
      return
3381 
    oprot.writeStructBegin('getProviderForPickupType_result')
3382 
    if self.success is not None:
3383 
      oprot.writeFieldBegin('success', TType.I64, 0)
3384 
      oprot.writeI64(self.success)
3385 
      oprot.writeFieldEnd()
3386 
    oprot.writeFieldStop()
3387 
    oprot.writeStructEnd()
3388 
 
3389 
  def validate(self):
3390 
    return
3391 
 
3392 
 
3393 
  def __repr__(self):
3394 
    L = ['%s=%r' % (key, value)
3395 
      for key, value in self.__dict__.iteritems()]
3396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3397 
 
3398 
  def __eq__(self, other):
3399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3400 
 
3401 
  def __ne__(self, other):
3402 
    return not (self == other)
5553 rajveer 3403 
 
3404 
class getAllPickupStores_args:
3405 
 
3406 
  thrift_spec = (
3407 
  )
3408 
 
3409 
  def read(self, iprot):
3410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3412 
      return
3413 
    iprot.readStructBegin()
3414 
    while True:
3415 
      (fname, ftype, fid) = iprot.readFieldBegin()
3416 
      if ftype == TType.STOP:
3417 
        break
3418 
      else:
3419 
        iprot.skip(ftype)
3420 
      iprot.readFieldEnd()
3421 
    iprot.readStructEnd()
3422 
 
3423 
  def write(self, oprot):
3424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3426 
      return
3427 
    oprot.writeStructBegin('getAllPickupStores_args')
3428 
    oprot.writeFieldStop()
3429 
    oprot.writeStructEnd()
3430 
 
3431 
  def validate(self):
3432 
    return
3433 
 
3434 
 
3435 
  def __repr__(self):
3436 
    L = ['%s=%r' % (key, value)
3437 
      for key, value in self.__dict__.iteritems()]
3438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3439 
 
3440 
  def __eq__(self, other):
3441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3442 
 
3443 
  def __ne__(self, other):
3444 
    return not (self == other)
3445 
 
3446 
class getAllPickupStores_result:
3447 
  """
3448 
  Attributes:
3449 
   - success
3450 
  """
3451 
 
3452 
  thrift_spec = (
3453 
    (0, TType.LIST, 'success', (TType.STRUCT,(PickupStore, PickupStore.thrift_spec)), None, ), # 0
3454 
  )
3455 
 
3456 
  def __init__(self, success=None,):
3457 
    self.success = success
3458 
 
3459 
  def read(self, iprot):
3460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3462 
      return
3463 
    iprot.readStructBegin()
3464 
    while True:
3465 
      (fname, ftype, fid) = iprot.readFieldBegin()
3466 
      if ftype == TType.STOP:
3467 
        break
3468 
      if fid == 0:
3469 
        if ftype == TType.LIST:
3470 
          self.success = []
7792 anupam.sin 3471 
          (_etype38, _size35) = iprot.readListBegin()
3472 
          for _i39 in xrange(_size35):
3473 
            _elem40 = PickupStore()
3474 
            _elem40.read(iprot)
3475 
            self.success.append(_elem40)
5553 rajveer 3476 
          iprot.readListEnd()
3477 
        else:
3478 
          iprot.skip(ftype)
3479 
      else:
3480 
        iprot.skip(ftype)
3481 
      iprot.readFieldEnd()
3482 
    iprot.readStructEnd()
3483 
 
3484 
  def write(self, oprot):
3485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3487 
      return
3488 
    oprot.writeStructBegin('getAllPickupStores_result')
3489 
    if self.success is not None:
3490 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3491 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7792 anupam.sin 3492 
      for iter41 in self.success:
3493 
        iter41.write(oprot)
5553 rajveer 3494 
      oprot.writeListEnd()
3495 
      oprot.writeFieldEnd()
3496 
    oprot.writeFieldStop()
3497 
    oprot.writeStructEnd()
3498 
 
3499 
  def validate(self):
3500 
    return
3501 
 
3502 
 
3503 
  def __repr__(self):
3504 
    L = ['%s=%r' % (key, value)
3505 
      for key, value in self.__dict__.iteritems()]
3506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3507 
 
3508 
  def __eq__(self, other):
3509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3510 
 
3511 
  def __ne__(self, other):
3512 
    return not (self == other)
3513 
 
3514 
class getPickupStore_args:
3515 
  """
3516 
  Attributes:
3517 
   - storeId
3518 
  """
3519 
 
3520 
  thrift_spec = (
3521 
    None, # 0
3522 
    (1, TType.I64, 'storeId', None, None, ), # 1
3523 
  )
3524 
 
3525 
  def __init__(self, storeId=None,):
3526 
    self.storeId = storeId
3527 
 
3528 
  def read(self, iprot):
3529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3531 
      return
3532 
    iprot.readStructBegin()
3533 
    while True:
3534 
      (fname, ftype, fid) = iprot.readFieldBegin()
3535 
      if ftype == TType.STOP:
3536 
        break
3537 
      if fid == 1:
3538 
        if ftype == TType.I64:
3539 
          self.storeId = iprot.readI64();
3540 
        else:
3541 
          iprot.skip(ftype)
3542 
      else:
3543 
        iprot.skip(ftype)
3544 
      iprot.readFieldEnd()
3545 
    iprot.readStructEnd()
3546 
 
3547 
  def write(self, oprot):
3548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3550 
      return
3551 
    oprot.writeStructBegin('getPickupStore_args')
3552 
    if self.storeId is not None:
3553 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
3554 
      oprot.writeI64(self.storeId)
3555 
      oprot.writeFieldEnd()
3556 
    oprot.writeFieldStop()
3557 
    oprot.writeStructEnd()
3558 
 
3559 
  def validate(self):
3560 
    return
3561 
 
3562 
 
3563 
  def __repr__(self):
3564 
    L = ['%s=%r' % (key, value)
3565 
      for key, value in self.__dict__.iteritems()]
3566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3567 
 
3568 
  def __eq__(self, other):
3569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3570 
 
3571 
  def __ne__(self, other):
3572 
    return not (self == other)
3573 
 
3574 
class getPickupStore_result:
3575 
  """
3576 
  Attributes:
3577 
   - success
3578 
  """
3579 
 
3580 
  thrift_spec = (
3581 
    (0, TType.STRUCT, 'success', (PickupStore, PickupStore.thrift_spec), None, ), # 0
3582 
  )
3583 
 
3584 
  def __init__(self, success=None,):
3585 
    self.success = success
3586 
 
3587 
  def read(self, iprot):
3588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3590 
      return
3591 
    iprot.readStructBegin()
3592 
    while True:
3593 
      (fname, ftype, fid) = iprot.readFieldBegin()
3594 
      if ftype == TType.STOP:
3595 
        break
3596 
      if fid == 0:
3597 
        if ftype == TType.STRUCT:
3598 
          self.success = PickupStore()
3599 
          self.success.read(iprot)
3600 
        else:
3601 
          iprot.skip(ftype)
3602 
      else:
3603 
        iprot.skip(ftype)
3604 
      iprot.readFieldEnd()
3605 
    iprot.readStructEnd()
3606 
 
3607 
  def write(self, oprot):
3608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3610 
      return
3611 
    oprot.writeStructBegin('getPickupStore_result')
3612 
    if self.success is not None:
3613 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3614 
      self.success.write(oprot)
3615 
      oprot.writeFieldEnd()
3616 
    oprot.writeFieldStop()
3617 
    oprot.writeStructEnd()
3618 
 
3619 
  def validate(self):
3620 
    return
3621 
 
3622 
 
3623 
  def __repr__(self):
3624 
    L = ['%s=%r' % (key, value)
3625 
      for key, value in self.__dict__.iteritems()]
3626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3627 
 
3628 
  def __eq__(self, other):
3629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3630 
 
3631 
  def __ne__(self, other):
3632 
    return not (self == other)
5719 rajveer 3633 
 
3634 
class getPickupStoreByHotspotId_args:
3635 
  """
3636 
  Attributes:
3637 
   - hotspotId
3638 
  """
3639 
 
3640 
  thrift_spec = (
3641 
    None, # 0
3642 
    (1, TType.STRING, 'hotspotId', None, None, ), # 1
3643 
  )
3644 
 
3645 
  def __init__(self, hotspotId=None,):
3646 
    self.hotspotId = hotspotId
3647 
 
3648 
  def read(self, iprot):
3649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3651 
      return
3652 
    iprot.readStructBegin()
3653 
    while True:
3654 
      (fname, ftype, fid) = iprot.readFieldBegin()
3655 
      if ftype == TType.STOP:
3656 
        break
3657 
      if fid == 1:
3658 
        if ftype == TType.STRING:
3659 
          self.hotspotId = iprot.readString();
3660 
        else:
3661 
          iprot.skip(ftype)
3662 
      else:
3663 
        iprot.skip(ftype)
3664 
      iprot.readFieldEnd()
3665 
    iprot.readStructEnd()
3666 
 
3667 
  def write(self, oprot):
3668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3670 
      return
3671 
    oprot.writeStructBegin('getPickupStoreByHotspotId_args')
3672 
    if self.hotspotId is not None:
3673 
      oprot.writeFieldBegin('hotspotId', TType.STRING, 1)
3674 
      oprot.writeString(self.hotspotId)
3675 
      oprot.writeFieldEnd()
3676 
    oprot.writeFieldStop()
3677 
    oprot.writeStructEnd()
3678 
 
3679 
  def validate(self):
3680 
    return
3681 
 
3682 
 
3683 
  def __repr__(self):
3684 
    L = ['%s=%r' % (key, value)
3685 
      for key, value in self.__dict__.iteritems()]
3686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3687 
 
3688 
  def __eq__(self, other):
3689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3690 
 
3691 
  def __ne__(self, other):
3692 
    return not (self == other)
3693 
 
3694 
class getPickupStoreByHotspotId_result:
3695 
  """
3696 
  Attributes:
3697 
   - success
3698 
  """
3699 
 
3700 
  thrift_spec = (
3701 
    (0, TType.STRUCT, 'success', (PickupStore, PickupStore.thrift_spec), None, ), # 0
3702 
  )
3703 
 
3704 
  def __init__(self, success=None,):
3705 
    self.success = success
3706 
 
3707 
  def read(self, iprot):
3708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3710 
      return
3711 
    iprot.readStructBegin()
3712 
    while True:
3713 
      (fname, ftype, fid) = iprot.readFieldBegin()
3714 
      if ftype == TType.STOP:
3715 
        break
3716 
      if fid == 0:
3717 
        if ftype == TType.STRUCT:
3718 
          self.success = PickupStore()
3719 
          self.success.read(iprot)
3720 
        else:
3721 
          iprot.skip(ftype)
3722 
      else:
3723 
        iprot.skip(ftype)
3724 
      iprot.readFieldEnd()
3725 
    iprot.readStructEnd()
3726 
 
3727 
  def write(self, oprot):
3728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3730 
      return
3731 
    oprot.writeStructBegin('getPickupStoreByHotspotId_result')
3732 
    if self.success is not None:
3733 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3734 
      self.success.write(oprot)
3735 
      oprot.writeFieldEnd()
3736 
    oprot.writeFieldStop()
3737 
    oprot.writeStructEnd()
3738 
 
3739 
  def validate(self):
3740 
    return
3741 
 
3742 
 
3743 
  def __repr__(self):
3744 
    L = ['%s=%r' % (key, value)
3745 
      for key, value in self.__dict__.iteritems()]
3746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3747 
 
3748 
  def __eq__(self, other):
3749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3750 
 
3751 
  def __ne__(self, other):
3752 
    return not (self == other)
6322 amar.kumar 3753 
 
3754 
class addPincode_args:
3755 
  """
3756 
  Attributes:
3757 
   - providerId
3758 
   - pincode
3759 
   - destCode
3760 
   - exp
3761 
   - cod
3762 
   - stationType
6524 rajveer 3763 
   - otgAvailable
6322 amar.kumar 3764 
  """
3765 
 
3766 
  thrift_spec = (
3767 
    None, # 0
3768 
    (1, TType.I64, 'providerId', None, None, ), # 1
3769 
    (2, TType.STRING, 'pincode', None, None, ), # 2
3770 
    (3, TType.STRING, 'destCode', None, None, ), # 3
3771 
    (4, TType.BOOL, 'exp', None, None, ), # 4
3772 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3773 
    (6, TType.I32, 'stationType', None, None, ), # 6
6524 rajveer 3774 
    (7, TType.BOOL, 'otgAvailable', None, None, ), # 7
6322 amar.kumar 3775 
  )
3776 
 
6524 rajveer 3777 
  def __init__(self, providerId=None, pincode=None, destCode=None, exp=None, cod=None, stationType=None, otgAvailable=None,):
6322 amar.kumar 3778 
    self.providerId = providerId
3779 
    self.pincode = pincode
3780 
    self.destCode = destCode
3781 
    self.exp = exp
3782 
    self.cod = cod
3783 
    self.stationType = stationType
6524 rajveer 3784 
    self.otgAvailable = otgAvailable
6322 amar.kumar 3785 
 
3786 
  def read(self, iprot):
3787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3789 
      return
3790 
    iprot.readStructBegin()
3791 
    while True:
3792 
      (fname, ftype, fid) = iprot.readFieldBegin()
3793 
      if ftype == TType.STOP:
3794 
        break
3795 
      if fid == 1:
3796 
        if ftype == TType.I64:
3797 
          self.providerId = iprot.readI64();
3798 
        else:
3799 
          iprot.skip(ftype)
3800 
      elif fid == 2:
3801 
        if ftype == TType.STRING:
3802 
          self.pincode = iprot.readString();
3803 
        else:
3804 
          iprot.skip(ftype)
3805 
      elif fid == 3:
3806 
        if ftype == TType.STRING:
3807 
          self.destCode = iprot.readString();
3808 
        else:
3809 
          iprot.skip(ftype)
3810 
      elif fid == 4:
3811 
        if ftype == TType.BOOL:
3812 
          self.exp = iprot.readBool();
3813 
        else:
3814 
          iprot.skip(ftype)
3815 
      elif fid == 5:
3816 
        if ftype == TType.BOOL:
3817 
          self.cod = iprot.readBool();
3818 
        else:
3819 
          iprot.skip(ftype)
3820 
      elif fid == 6:
3821 
        if ftype == TType.I32:
3822 
          self.stationType = iprot.readI32();
3823 
        else:
3824 
          iprot.skip(ftype)
6524 rajveer 3825 
      elif fid == 7:
3826 
        if ftype == TType.BOOL:
3827 
          self.otgAvailable = iprot.readBool();
3828 
        else:
3829 
          iprot.skip(ftype)
6322 amar.kumar 3830 
      else:
3831 
        iprot.skip(ftype)
3832 
      iprot.readFieldEnd()
3833 
    iprot.readStructEnd()
3834 
 
3835 
  def write(self, oprot):
3836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3838 
      return
3839 
    oprot.writeStructBegin('addPincode_args')
3840 
    if self.providerId is not None:
3841 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
3842 
      oprot.writeI64(self.providerId)
3843 
      oprot.writeFieldEnd()
3844 
    if self.pincode is not None:
3845 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
3846 
      oprot.writeString(self.pincode)
3847 
      oprot.writeFieldEnd()
3848 
    if self.destCode is not None:
3849 
      oprot.writeFieldBegin('destCode', TType.STRING, 3)
3850 
      oprot.writeString(self.destCode)
3851 
      oprot.writeFieldEnd()
3852 
    if self.exp is not None:
3853 
      oprot.writeFieldBegin('exp', TType.BOOL, 4)
3854 
      oprot.writeBool(self.exp)
3855 
      oprot.writeFieldEnd()
3856 
    if self.cod is not None:
3857 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
3858 
      oprot.writeBool(self.cod)
3859 
      oprot.writeFieldEnd()
3860 
    if self.stationType is not None:
3861 
      oprot.writeFieldBegin('stationType', TType.I32, 6)
3862 
      oprot.writeI32(self.stationType)
3863 
      oprot.writeFieldEnd()
6524 rajveer 3864 
    if self.otgAvailable is not None:
3865 
      oprot.writeFieldBegin('otgAvailable', TType.BOOL, 7)
3866 
      oprot.writeBool(self.otgAvailable)
3867 
      oprot.writeFieldEnd()
6322 amar.kumar 3868 
    oprot.writeFieldStop()
3869 
    oprot.writeStructEnd()
3870 
 
3871 
  def validate(self):
3872 
    return
3873 
 
3874 
 
3875 
  def __repr__(self):
3876 
    L = ['%s=%r' % (key, value)
3877 
      for key, value in self.__dict__.iteritems()]
3878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3879 
 
3880 
  def __eq__(self, other):
3881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3882 
 
3883 
  def __ne__(self, other):
3884 
    return not (self == other)
3885 
 
3886 
class addPincode_result:
3887 
 
3888 
  thrift_spec = (
3889 
  )
3890 
 
3891 
  def read(self, iprot):
3892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3894 
      return
3895 
    iprot.readStructBegin()
3896 
    while True:
3897 
      (fname, ftype, fid) = iprot.readFieldBegin()
3898 
      if ftype == TType.STOP:
3899 
        break
3900 
      else:
3901 
        iprot.skip(ftype)
3902 
      iprot.readFieldEnd()
3903 
    iprot.readStructEnd()
3904 
 
3905 
  def write(self, oprot):
3906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3908 
      return
3909 
    oprot.writeStructBegin('addPincode_result')
3910 
    oprot.writeFieldStop()
3911 
    oprot.writeStructEnd()
3912 
 
3913 
  def validate(self):
3914 
    return
3915 
 
3916 
 
3917 
  def __repr__(self):
3918 
    L = ['%s=%r' % (key, value)
3919 
      for key, value in self.__dict__.iteritems()]
3920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3921 
 
3922 
  def __eq__(self, other):
3923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3924 
 
3925 
  def __ne__(self, other):
3926 
    return not (self == other)
3927 
 
3928 
class updatePincode_args:
3929 
  """
3930 
  Attributes:
3931 
   - providerId
3932 
   - pincode
3933 
   - exp
3934 
   - cod
6524 rajveer 3935 
   - otgAvailable
6322 amar.kumar 3936 
  """
3937 
 
3938 
  thrift_spec = (
3939 
    None, # 0
3940 
    (1, TType.I64, 'providerId', None, None, ), # 1
3941 
    (2, TType.STRING, 'pincode', None, None, ), # 2
3942 
    (3, TType.BOOL, 'exp', None, None, ), # 3
3943 
    (4, TType.BOOL, 'cod', None, None, ), # 4
6524 rajveer 3944 
    (5, TType.BOOL, 'otgAvailable', None, None, ), # 5
6322 amar.kumar 3945 
  )
3946 
 
6524 rajveer 3947 
  def __init__(self, providerId=None, pincode=None, exp=None, cod=None, otgAvailable=None,):
6322 amar.kumar 3948 
    self.providerId = providerId
3949 
    self.pincode = pincode
3950 
    self.exp = exp
3951 
    self.cod = cod
6524 rajveer 3952 
    self.otgAvailable = otgAvailable
6322 amar.kumar 3953 
 
3954 
  def read(self, iprot):
3955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3957 
      return
3958 
    iprot.readStructBegin()
3959 
    while True:
3960 
      (fname, ftype, fid) = iprot.readFieldBegin()
3961 
      if ftype == TType.STOP:
3962 
        break
3963 
      if fid == 1:
3964 
        if ftype == TType.I64:
3965 
          self.providerId = iprot.readI64();
3966 
        else:
3967 
          iprot.skip(ftype)
3968 
      elif fid == 2:
3969 
        if ftype == TType.STRING:
3970 
          self.pincode = iprot.readString();
3971 
        else:
3972 
          iprot.skip(ftype)
3973 
      elif fid == 3:
3974 
        if ftype == TType.BOOL:
3975 
          self.exp = iprot.readBool();
3976 
        else:
3977 
          iprot.skip(ftype)
3978 
      elif fid == 4:
3979 
        if ftype == TType.BOOL:
3980 
          self.cod = iprot.readBool();
3981 
        else:
3982 
          iprot.skip(ftype)
6524 rajveer 3983 
      elif fid == 5:
3984 
        if ftype == TType.BOOL:
3985 
          self.otgAvailable = iprot.readBool();
3986 
        else:
3987 
          iprot.skip(ftype)
6322 amar.kumar 3988 
      else:
3989 
        iprot.skip(ftype)
3990 
      iprot.readFieldEnd()
3991 
    iprot.readStructEnd()
3992 
 
3993 
  def write(self, oprot):
3994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3996 
      return
3997 
    oprot.writeStructBegin('updatePincode_args')
3998 
    if self.providerId is not None:
3999 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4000 
      oprot.writeI64(self.providerId)
4001 
      oprot.writeFieldEnd()
4002 
    if self.pincode is not None:
4003 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
4004 
      oprot.writeString(self.pincode)
4005 
      oprot.writeFieldEnd()
4006 
    if self.exp is not None:
4007 
      oprot.writeFieldBegin('exp', TType.BOOL, 3)
4008 
      oprot.writeBool(self.exp)
4009 
      oprot.writeFieldEnd()
4010 
    if self.cod is not None:
4011 
      oprot.writeFieldBegin('cod', TType.BOOL, 4)
4012 
      oprot.writeBool(self.cod)
4013 
      oprot.writeFieldEnd()
6524 rajveer 4014 
    if self.otgAvailable is not None:
4015 
      oprot.writeFieldBegin('otgAvailable', TType.BOOL, 5)
4016 
      oprot.writeBool(self.otgAvailable)
4017 
      oprot.writeFieldEnd()
6322 amar.kumar 4018 
    oprot.writeFieldStop()
4019 
    oprot.writeStructEnd()
4020 
 
4021 
  def validate(self):
4022 
    return
4023 
 
4024 
 
4025 
  def __repr__(self):
4026 
    L = ['%s=%r' % (key, value)
4027 
      for key, value in self.__dict__.iteritems()]
4028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4029 
 
4030 
  def __eq__(self, other):
4031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4032 
 
4033 
  def __ne__(self, other):
4034 
    return not (self == other)
4035 
 
4036 
class updatePincode_result:
4037 
 
4038 
  thrift_spec = (
4039 
  )
4040 
 
4041 
  def read(self, iprot):
4042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4044 
      return
4045 
    iprot.readStructBegin()
4046 
    while True:
4047 
      (fname, ftype, fid) = iprot.readFieldBegin()
4048 
      if ftype == TType.STOP:
4049 
        break
4050 
      else:
4051 
        iprot.skip(ftype)
4052 
      iprot.readFieldEnd()
4053 
    iprot.readStructEnd()
4054 
 
4055 
  def write(self, oprot):
4056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4058 
      return
4059 
    oprot.writeStructBegin('updatePincode_result')
4060 
    oprot.writeFieldStop()
4061 
    oprot.writeStructEnd()
4062 
 
4063 
  def validate(self):
4064 
    return
4065 
 
4066 
 
4067 
  def __repr__(self):
4068 
    L = ['%s=%r' % (key, value)
4069 
      for key, value in self.__dict__.iteritems()]
4070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4071 
 
4072 
  def __eq__(self, other):
4073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4074 
 
4075 
  def __ne__(self, other):
4076 
    return not (self == other)
7567 rajveer 4077 
 
4078 
class addNewAwbs_args:
4079 
  """
4080 
  Attributes:
4081 
   - providerId
4082 
   - cod
4083 
   - awbs
13146 manish.sha 4084 
   - awbUsedFor
7567 rajveer 4085 
  """
4086 
 
4087 
  thrift_spec = (
4088 
    None, # 0
4089 
    (1, TType.I64, 'providerId', None, None, ), # 1
4090 
    (2, TType.BOOL, 'cod', None, None, ), # 2
4091 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
13146 manish.sha 4092 
    (4, TType.I64, 'awbUsedFor', None, None, ), # 4
7567 rajveer 4093 
  )
4094 
 
13146 manish.sha 4095 
  def __init__(self, providerId=None, cod=None, awbs=None, awbUsedFor=None,):
7567 rajveer 4096 
    self.providerId = providerId
4097 
    self.cod = cod
4098 
    self.awbs = awbs
13146 manish.sha 4099 
    self.awbUsedFor = awbUsedFor
7567 rajveer 4100 
 
4101 
  def read(self, iprot):
4102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4104 
      return
4105 
    iprot.readStructBegin()
4106 
    while True:
4107 
      (fname, ftype, fid) = iprot.readFieldBegin()
4108 
      if ftype == TType.STOP:
4109 
        break
4110 
      if fid == 1:
4111 
        if ftype == TType.I64:
4112 
          self.providerId = iprot.readI64();
4113 
        else:
4114 
          iprot.skip(ftype)
4115 
      elif fid == 2:
4116 
        if ftype == TType.BOOL:
4117 
          self.cod = iprot.readBool();
4118 
        else:
4119 
          iprot.skip(ftype)
4120 
      elif fid == 3:
4121 
        if ftype == TType.LIST:
4122 
          self.awbs = []
7792 anupam.sin 4123 
          (_etype45, _size42) = iprot.readListBegin()
4124 
          for _i46 in xrange(_size42):
4125 
            _elem47 = iprot.readString();
4126 
            self.awbs.append(_elem47)
7567 rajveer 4127 
          iprot.readListEnd()
4128 
        else:
4129 
          iprot.skip(ftype)
13146 manish.sha 4130 
      elif fid == 4:
4131 
        if ftype == TType.I64:
4132 
          self.awbUsedFor = iprot.readI64();
4133 
        else:
4134 
          iprot.skip(ftype)
7567 rajveer 4135 
      else:
4136 
        iprot.skip(ftype)
4137 
      iprot.readFieldEnd()
4138 
    iprot.readStructEnd()
4139 
 
4140 
  def write(self, oprot):
4141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4143 
      return
4144 
    oprot.writeStructBegin('addNewAwbs_args')
4145 
    if self.providerId is not None:
4146 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4147 
      oprot.writeI64(self.providerId)
4148 
      oprot.writeFieldEnd()
4149 
    if self.cod is not None:
4150 
      oprot.writeFieldBegin('cod', TType.BOOL, 2)
4151 
      oprot.writeBool(self.cod)
4152 
      oprot.writeFieldEnd()
4153 
    if self.awbs is not None:
4154 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
4155 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
7792 anupam.sin 4156 
      for iter48 in self.awbs:
4157 
        oprot.writeString(iter48)
7567 rajveer 4158 
      oprot.writeListEnd()
4159 
      oprot.writeFieldEnd()
13146 manish.sha 4160 
    if self.awbUsedFor is not None:
4161 
      oprot.writeFieldBegin('awbUsedFor', TType.I64, 4)
4162 
      oprot.writeI64(self.awbUsedFor)
4163 
      oprot.writeFieldEnd()
7567 rajveer 4164 
    oprot.writeFieldStop()
4165 
    oprot.writeStructEnd()
4166 
 
4167 
  def validate(self):
4168 
    return
4169 
 
4170 
 
4171 
  def __repr__(self):
4172 
    L = ['%s=%r' % (key, value)
4173 
      for key, value in self.__dict__.iteritems()]
4174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4175 
 
4176 
  def __eq__(self, other):
4177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4178 
 
4179 
  def __ne__(self, other):
4180 
    return not (self == other)
4181 
 
4182 
class addNewAwbs_result:
4183 
  """
4184 
  Attributes:
4185 
   - success
4186 
  """
4187 
 
4188 
  thrift_spec = (
4189 
    (0, TType.BOOL, 'success', None, None, ), # 0
4190 
  )
4191 
 
4192 
  def __init__(self, success=None,):
4193 
    self.success = success
4194 
 
4195 
  def read(self, iprot):
4196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4198 
      return
4199 
    iprot.readStructBegin()
4200 
    while True:
4201 
      (fname, ftype, fid) = iprot.readFieldBegin()
4202 
      if ftype == TType.STOP:
4203 
        break
4204 
      if fid == 0:
4205 
        if ftype == TType.BOOL:
4206 
          self.success = iprot.readBool();
4207 
        else:
4208 
          iprot.skip(ftype)
4209 
      else:
4210 
        iprot.skip(ftype)
4211 
      iprot.readFieldEnd()
4212 
    iprot.readStructEnd()
4213 
 
4214 
  def write(self, oprot):
4215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4217 
      return
4218 
    oprot.writeStructBegin('addNewAwbs_result')
4219 
    if self.success is not None:
4220 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4221 
      oprot.writeBool(self.success)
4222 
      oprot.writeFieldEnd()
4223 
    oprot.writeFieldStop()
4224 
    oprot.writeStructEnd()
4225 
 
4226 
  def validate(self):
4227 
    return
4228 
 
4229 
 
4230 
  def __repr__(self):
4231 
    L = ['%s=%r' % (key, value)
4232 
      for key, value in self.__dict__.iteritems()]
4233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4234 
 
4235 
  def __eq__(self, other):
4236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4237 
 
4238 
  def __ne__(self, other):
4239 
    return not (self == other)
7738 manish.sha 4240 
 
7787 manish.sha 4241 
class runLogisticsLocationInfoUpdate_args:
7738 manish.sha 4242 
  """
4243 
  Attributes:
7787 manish.sha 4244 
   - logisticsLocationInfoList
4245 
   - runCompleteUpdate
7738 manish.sha 4246 
  """
4247 
 
4248 
  thrift_spec = (
4249 
    None, # 0
7787 manish.sha 4250 
    (1, TType.LIST, 'logisticsLocationInfoList', (TType.STRUCT,(LogisticsLocationInfo, LogisticsLocationInfo.thrift_spec)), None, ), # 1
4251 
    (2, TType.BOOL, 'runCompleteUpdate', None, None, ), # 2
7738 manish.sha 4252 
  )
4253 
 
7787 manish.sha 4254 
  def __init__(self, logisticsLocationInfoList=None, runCompleteUpdate=None,):
4255 
    self.logisticsLocationInfoList = logisticsLocationInfoList
4256 
    self.runCompleteUpdate = runCompleteUpdate
7738 manish.sha 4257 
 
4258 
  def read(self, iprot):
4259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4261 
      return
4262 
    iprot.readStructBegin()
4263 
    while True:
4264 
      (fname, ftype, fid) = iprot.readFieldBegin()
4265 
      if ftype == TType.STOP:
4266 
        break
4267 
      if fid == 1:
7787 manish.sha 4268 
        if ftype == TType.LIST:
4269 
          self.logisticsLocationInfoList = []
7808 anupam.sin 4270 
          (_etype52, _size49) = iprot.readListBegin()
4271 
          for _i53 in xrange(_size49):
4272 
            _elem54 = LogisticsLocationInfo()
4273 
            _elem54.read(iprot)
4274 
            self.logisticsLocationInfoList.append(_elem54)
7787 manish.sha 4275 
          iprot.readListEnd()
7738 manish.sha 4276 
        else:
4277 
          iprot.skip(ftype)
4278 
      elif fid == 2:
7787 manish.sha 4279 
        if ftype == TType.BOOL:
4280 
          self.runCompleteUpdate = iprot.readBool();
7738 manish.sha 4281 
        else:
4282 
          iprot.skip(ftype)
4283 
      else:
4284 
        iprot.skip(ftype)
4285 
      iprot.readFieldEnd()
4286 
    iprot.readStructEnd()
4287 
 
4288 
  def write(self, oprot):
4289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4291 
      return
7787 manish.sha 4292 
    oprot.writeStructBegin('runLogisticsLocationInfoUpdate_args')
4293 
    if self.logisticsLocationInfoList is not None:
4294 
      oprot.writeFieldBegin('logisticsLocationInfoList', TType.LIST, 1)
4295 
      oprot.writeListBegin(TType.STRUCT, len(self.logisticsLocationInfoList))
7808 anupam.sin 4296 
      for iter55 in self.logisticsLocationInfoList:
4297 
        iter55.write(oprot)
7787 manish.sha 4298 
      oprot.writeListEnd()
7738 manish.sha 4299 
      oprot.writeFieldEnd()
7787 manish.sha 4300 
    if self.runCompleteUpdate is not None:
4301 
      oprot.writeFieldBegin('runCompleteUpdate', TType.BOOL, 2)
4302 
      oprot.writeBool(self.runCompleteUpdate)
7738 manish.sha 4303 
      oprot.writeFieldEnd()
4304 
    oprot.writeFieldStop()
4305 
    oprot.writeStructEnd()
4306 
 
4307 
  def validate(self):
4308 
    return
4309 
 
4310 
 
4311 
  def __repr__(self):
4312 
    L = ['%s=%r' % (key, value)
4313 
      for key, value in self.__dict__.iteritems()]
4314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4315 
 
4316 
  def __eq__(self, other):
4317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4318 
 
4319 
  def __ne__(self, other):
4320 
    return not (self == other)
4321 
 
7787 manish.sha 4322 
class runLogisticsLocationInfoUpdate_result:
7738 manish.sha 4323 
 
4324 
  thrift_spec = (
4325 
  )
4326 
 
4327 
  def read(self, iprot):
4328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4330 
      return
4331 
    iprot.readStructBegin()
4332 
    while True:
4333 
      (fname, ftype, fid) = iprot.readFieldBegin()
4334 
      if ftype == TType.STOP:
4335 
        break
4336 
      else:
4337 
        iprot.skip(ftype)
4338 
      iprot.readFieldEnd()
4339 
    iprot.readStructEnd()
4340 
 
4341 
  def write(self, oprot):
4342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4344 
      return
7787 manish.sha 4345 
    oprot.writeStructBegin('runLogisticsLocationInfoUpdate_result')
7738 manish.sha 4346 
    oprot.writeFieldStop()
4347 
    oprot.writeStructEnd()
4348 
 
4349 
  def validate(self):
4350 
    return
4351 
 
4352 
 
4353 
  def __repr__(self):
4354 
    L = ['%s=%r' % (key, value)
4355 
      for key, value in self.__dict__.iteritems()]
4356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4357 
 
4358 
  def __eq__(self, other):
4359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4360 
 
4361 
  def __ne__(self, other):
4362 
    return not (self == other)
7888 rajveer 4363 
 
4364 
class adjustDeliveryDays_args:
4365 
  """
4366 
  Attributes:
4367 
   - startDate
4368 
   - days
4369 
  """
4370 
 
4371 
  thrift_spec = (
4372 
    None, # 0
4373 
    (1, TType.I64, 'startDate', None, None, ), # 1
4374 
    (2, TType.I64, 'days', None, None, ), # 2
4375 
  )
4376 
 
4377 
  def __init__(self, startDate=None, days=None,):
4378 
    self.startDate = startDate
4379 
    self.days = days
4380 
 
4381 
  def read(self, iprot):
4382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4384 
      return
4385 
    iprot.readStructBegin()
4386 
    while True:
4387 
      (fname, ftype, fid) = iprot.readFieldBegin()
4388 
      if ftype == TType.STOP:
4389 
        break
4390 
      if fid == 1:
4391 
        if ftype == TType.I64:
4392 
          self.startDate = iprot.readI64();
4393 
        else:
4394 
          iprot.skip(ftype)
4395 
      elif fid == 2:
4396 
        if ftype == TType.I64:
4397 
          self.days = iprot.readI64();
4398 
        else:
4399 
          iprot.skip(ftype)
4400 
      else:
4401 
        iprot.skip(ftype)
4402 
      iprot.readFieldEnd()
4403 
    iprot.readStructEnd()
4404 
 
4405 
  def write(self, oprot):
4406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4408 
      return
4409 
    oprot.writeStructBegin('adjustDeliveryDays_args')
4410 
    if self.startDate is not None:
4411 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
4412 
      oprot.writeI64(self.startDate)
4413 
      oprot.writeFieldEnd()
4414 
    if self.days is not None:
4415 
      oprot.writeFieldBegin('days', TType.I64, 2)
4416 
      oprot.writeI64(self.days)
4417 
      oprot.writeFieldEnd()
4418 
    oprot.writeFieldStop()
4419 
    oprot.writeStructEnd()
4420 
 
4421 
  def validate(self):
4422 
    return
4423 
 
4424 
 
4425 
  def __repr__(self):
4426 
    L = ['%s=%r' % (key, value)
4427 
      for key, value in self.__dict__.iteritems()]
4428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4429 
 
4430 
  def __eq__(self, other):
4431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4432 
 
4433 
  def __ne__(self, other):
4434 
    return not (self == other)
4435 
 
4436 
class adjustDeliveryDays_result:
4437 
  """
4438 
  Attributes:
4439 
   - success
4440 
  """
4441 
 
4442 
  thrift_spec = (
4443 
    (0, TType.I64, 'success', None, None, ), # 0
4444 
  )
4445 
 
4446 
  def __init__(self, success=None,):
4447 
    self.success = success
4448 
 
4449 
  def read(self, iprot):
4450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4452 
      return
4453 
    iprot.readStructBegin()
4454 
    while True:
4455 
      (fname, ftype, fid) = iprot.readFieldBegin()
4456 
      if ftype == TType.STOP:
4457 
        break
4458 
      if fid == 0:
4459 
        if ftype == TType.I64:
4460 
          self.success = iprot.readI64();
4461 
        else:
4462 
          iprot.skip(ftype)
4463 
      else:
4464 
        iprot.skip(ftype)
4465 
      iprot.readFieldEnd()
4466 
    iprot.readStructEnd()
4467 
 
4468 
  def write(self, oprot):
4469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4471 
      return
4472 
    oprot.writeStructBegin('adjustDeliveryDays_result')
4473 
    if self.success is not None:
4474 
      oprot.writeFieldBegin('success', TType.I64, 0)
4475 
      oprot.writeI64(self.success)
4476 
      oprot.writeFieldEnd()
4477 
    oprot.writeFieldStop()
4478 
    oprot.writeStructEnd()
4479 
 
4480 
  def validate(self):
4481 
    return
4482 
 
4483 
 
4484 
  def __repr__(self):
4485 
    L = ['%s=%r' % (key, value)
4486 
      for key, value in self.__dict__.iteritems()]
4487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4488 
 
4489 
  def __eq__(self, other):
4490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4491 
 
4492 
  def __ne__(self, other):
4493 
    return not (self == other)
12895 manish.sha 4494 
 
4495 
class getFirstDeliveryEstimateForWhLocation_args:
4496 
  """
4497 
  Attributes:
4498 
   - pincode
4499 
   - whLocation
4500 
  """
4501 
 
4502 
  thrift_spec = (
4503 
    None, # 0
4504 
    (1, TType.STRING, 'pincode', None, None, ), # 1
4505 
    (2, TType.I64, 'whLocation', None, None, ), # 2
4506 
  )
4507 
 
4508 
  def __init__(self, pincode=None, whLocation=None,):
4509 
    self.pincode = pincode
4510 
    self.whLocation = whLocation
4511 
 
4512 
  def read(self, iprot):
4513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4515 
      return
4516 
    iprot.readStructBegin()
4517 
    while True:
4518 
      (fname, ftype, fid) = iprot.readFieldBegin()
4519 
      if ftype == TType.STOP:
4520 
        break
4521 
      if fid == 1:
4522 
        if ftype == TType.STRING:
4523 
          self.pincode = iprot.readString();
4524 
        else:
4525 
          iprot.skip(ftype)
4526 
      elif fid == 2:
4527 
        if ftype == TType.I64:
4528 
          self.whLocation = iprot.readI64();
4529 
        else:
4530 
          iprot.skip(ftype)
4531 
      else:
4532 
        iprot.skip(ftype)
4533 
      iprot.readFieldEnd()
4534 
    iprot.readStructEnd()
4535 
 
4536 
  def write(self, oprot):
4537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4539 
      return
4540 
    oprot.writeStructBegin('getFirstDeliveryEstimateForWhLocation_args')
4541 
    if self.pincode is not None:
4542 
      oprot.writeFieldBegin('pincode', TType.STRING, 1)
4543 
      oprot.writeString(self.pincode)
4544 
      oprot.writeFieldEnd()
4545 
    if self.whLocation is not None:
4546 
      oprot.writeFieldBegin('whLocation', TType.I64, 2)
4547 
      oprot.writeI64(self.whLocation)
4548 
      oprot.writeFieldEnd()
4549 
    oprot.writeFieldStop()
4550 
    oprot.writeStructEnd()
4551 
 
4552 
  def validate(self):
4553 
    return
4554 
 
4555 
 
4556 
  def __repr__(self):
4557 
    L = ['%s=%r' % (key, value)
4558 
      for key, value in self.__dict__.iteritems()]
4559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4560 
 
4561 
  def __eq__(self, other):
4562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4563 
 
4564 
  def __ne__(self, other):
4565 
    return not (self == other)
4566 
 
4567 
class getFirstDeliveryEstimateForWhLocation_result:
4568 
  """
4569 
  Attributes:
4570 
   - success
4571 
  """
4572 
 
4573 
  thrift_spec = (
4574 
    (0, TType.I64, 'success', None, None, ), # 0
4575 
  )
4576 
 
4577 
  def __init__(self, success=None,):
4578 
    self.success = success
4579 
 
4580 
  def read(self, iprot):
4581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4583 
      return
4584 
    iprot.readStructBegin()
4585 
    while True:
4586 
      (fname, ftype, fid) = iprot.readFieldBegin()
4587 
      if ftype == TType.STOP:
4588 
        break
4589 
      if fid == 0:
4590 
        if ftype == TType.I64:
4591 
          self.success = iprot.readI64();
4592 
        else:
4593 
          iprot.skip(ftype)
4594 
      else:
4595 
        iprot.skip(ftype)
4596 
      iprot.readFieldEnd()
4597 
    iprot.readStructEnd()
4598 
 
4599 
  def write(self, oprot):
4600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4602 
      return
4603 
    oprot.writeStructBegin('getFirstDeliveryEstimateForWhLocation_result')
4604 
    if self.success is not None:
4605 
      oprot.writeFieldBegin('success', TType.I64, 0)
4606 
      oprot.writeI64(self.success)
4607 
      oprot.writeFieldEnd()
4608 
    oprot.writeFieldStop()
4609 
    oprot.writeStructEnd()
4610 
 
4611 
  def validate(self):
4612 
    return
4613 
 
4614 
 
4615 
  def __repr__(self):
4616 
    L = ['%s=%r' % (key, value)
4617 
      for key, value in self.__dict__.iteritems()]
4618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4619 
 
4620 
  def __eq__(self, other):
4621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4622 
 
4623 
  def __ne__(self, other):
4624 
    return not (self == other)
13146 manish.sha 4625 
 
4626 
class getNewEmptyAwb_args:
4627 
  """
4628 
  Attributes:
4629 
   - providerId
4630 
   - type
4631 
   - orderQuantity
4632 
  """
4633 
 
4634 
  thrift_spec = (
4635 
    None, # 0
4636 
    (1, TType.I64, 'providerId', None, None, ), # 1
4637 
    (2, TType.I32, 'type', None, None, ), # 2
4638 
    (3, TType.I64, 'orderQuantity', None, None, ), # 3
4639 
  )
4640 
 
4641 
  def __init__(self, providerId=None, type=None, orderQuantity=None,):
4642 
    self.providerId = providerId
4643 
    self.type = type
4644 
    self.orderQuantity = orderQuantity
4645 
 
4646 
  def read(self, iprot):
4647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4649 
      return
4650 
    iprot.readStructBegin()
4651 
    while True:
4652 
      (fname, ftype, fid) = iprot.readFieldBegin()
4653 
      if ftype == TType.STOP:
4654 
        break
4655 
      if fid == 1:
4656 
        if ftype == TType.I64:
4657 
          self.providerId = iprot.readI64();
4658 
        else:
4659 
          iprot.skip(ftype)
4660 
      elif fid == 2:
4661 
        if ftype == TType.I32:
4662 
          self.type = iprot.readI32();
4663 
        else:
4664 
          iprot.skip(ftype)
4665 
      elif fid == 3:
4666 
        if ftype == TType.I64:
4667 
          self.orderQuantity = iprot.readI64();
4668 
        else:
4669 
          iprot.skip(ftype)
4670 
      else:
4671 
        iprot.skip(ftype)
4672 
      iprot.readFieldEnd()
4673 
    iprot.readStructEnd()
4674 
 
4675 
  def write(self, oprot):
4676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4678 
      return
4679 
    oprot.writeStructBegin('getNewEmptyAwb_args')
4680 
    if self.providerId is not None:
4681 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4682 
      oprot.writeI64(self.providerId)
4683 
      oprot.writeFieldEnd()
4684 
    if self.type is not None:
4685 
      oprot.writeFieldBegin('type', TType.I32, 2)
4686 
      oprot.writeI32(self.type)
4687 
      oprot.writeFieldEnd()
4688 
    if self.orderQuantity is not None:
4689 
      oprot.writeFieldBegin('orderQuantity', TType.I64, 3)
4690 
      oprot.writeI64(self.orderQuantity)
4691 
      oprot.writeFieldEnd()
4692 
    oprot.writeFieldStop()
4693 
    oprot.writeStructEnd()
4694 
 
4695 
  def validate(self):
4696 
    return
4697 
 
4698 
 
4699 
  def __repr__(self):
4700 
    L = ['%s=%r' % (key, value)
4701 
      for key, value in self.__dict__.iteritems()]
4702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4703 
 
4704 
  def __eq__(self, other):
4705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4706 
 
4707 
  def __ne__(self, other):
4708 
    return not (self == other)
4709 
 
4710 
class getNewEmptyAwb_result:
4711 
  """
4712 
  Attributes:
4713 
   - success
4714 
   - se
4715 
  """
4716 
 
4717 
  thrift_spec = (
4718 
    (0, TType.STRING, 'success', None, None, ), # 0
4719 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
4720 
  )
4721 
 
4722 
  def __init__(self, success=None, se=None,):
4723 
    self.success = success
4724 
    self.se = se
4725 
 
4726 
  def read(self, iprot):
4727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4729 
      return
4730 
    iprot.readStructBegin()
4731 
    while True:
4732 
      (fname, ftype, fid) = iprot.readFieldBegin()
4733 
      if ftype == TType.STOP:
4734 
        break
4735 
      if fid == 0:
4736 
        if ftype == TType.STRING:
4737 
          self.success = iprot.readString();
4738 
        else:
4739 
          iprot.skip(ftype)
4740 
      elif fid == 1:
4741 
        if ftype == TType.STRUCT:
4742 
          self.se = LogisticsServiceException()
4743 
          self.se.read(iprot)
4744 
        else:
4745 
          iprot.skip(ftype)
4746 
      else:
4747 
        iprot.skip(ftype)
4748 
      iprot.readFieldEnd()
4749 
    iprot.readStructEnd()
4750 
 
4751 
  def write(self, oprot):
4752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4754 
      return
4755 
    oprot.writeStructBegin('getNewEmptyAwb_result')
4756 
    if self.success is not None:
4757 
      oprot.writeFieldBegin('success', TType.STRING, 0)
4758 
      oprot.writeString(self.success)
4759 
      oprot.writeFieldEnd()
4760 
    if self.se is not None:
4761 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
4762 
      self.se.write(oprot)
4763 
      oprot.writeFieldEnd()
4764 
    oprot.writeFieldStop()
4765 
    oprot.writeStructEnd()
4766 
 
4767 
  def validate(self):
4768 
    return
4769 
 
4770 
 
4771 
  def __repr__(self):
4772 
    L = ['%s=%r' % (key, value)
4773 
      for key, value in self.__dict__.iteritems()]
4774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4775 
 
4776 
  def __eq__(self, other):
4777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4778 
 
4779 
  def __ne__(self, other):
4780 
    return not (self == other)
4781 
 
4782 
class getProviderLimitDetailsForPincode_args:
4783 
  """
4784 
  Attributes:
4785 
   - providerId
4786 
   - pincode
4787 
  """
4788 
 
4789 
  thrift_spec = (
4790 
    None, # 0
4791 
    (1, TType.I64, 'providerId', None, None, ), # 1
4792 
    (2, TType.STRING, 'pincode', None, None, ), # 2
4793 
  )
4794 
 
4795 
  def __init__(self, providerId=None, pincode=None,):
4796 
    self.providerId = providerId
4797 
    self.pincode = pincode
4798 
 
4799 
  def read(self, iprot):
4800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4802 
      return
4803 
    iprot.readStructBegin()
4804 
    while True:
4805 
      (fname, ftype, fid) = iprot.readFieldBegin()
4806 
      if ftype == TType.STOP:
4807 
        break
4808 
      if fid == 1:
4809 
        if ftype == TType.I64:
4810 
          self.providerId = iprot.readI64();
4811 
        else:
4812 
          iprot.skip(ftype)
4813 
      elif fid == 2:
4814 
        if ftype == TType.STRING:
4815 
          self.pincode = iprot.readString();
4816 
        else:
4817 
          iprot.skip(ftype)
4818 
      else:
4819 
        iprot.skip(ftype)
4820 
      iprot.readFieldEnd()
4821 
    iprot.readStructEnd()
4822 
 
4823 
  def write(self, oprot):
4824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4826 
      return
4827 
    oprot.writeStructBegin('getProviderLimitDetailsForPincode_args')
4828 
    if self.providerId is not None:
4829 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4830 
      oprot.writeI64(self.providerId)
4831 
      oprot.writeFieldEnd()
4832 
    if self.pincode is not None:
4833 
      oprot.writeFieldBegin('pincode', TType.STRING, 2)
4834 
      oprot.writeString(self.pincode)
4835 
      oprot.writeFieldEnd()
4836 
    oprot.writeFieldStop()
4837 
    oprot.writeStructEnd()
4838 
 
4839 
  def validate(self):
4840 
    return
4841 
 
4842 
 
4843 
  def __repr__(self):
4844 
    L = ['%s=%r' % (key, value)
4845 
      for key, value in self.__dict__.iteritems()]
4846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4847 
 
4848 
  def __eq__(self, other):
4849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4850 
 
4851 
  def __ne__(self, other):
4852 
    return not (self == other)
4853 
 
4854 
class getProviderLimitDetailsForPincode_result:
4855 
  """
4856 
  Attributes:
4857 
   - success
4858 
   - se
4859 
  """
4860 
 
4861 
  thrift_spec = (
4862 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
4863 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
4864 
  )
4865 
 
4866 
  def __init__(self, success=None, se=None,):
4867 
    self.success = success
4868 
    self.se = se
4869 
 
4870 
  def read(self, iprot):
4871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4873 
      return
4874 
    iprot.readStructBegin()
4875 
    while True:
4876 
      (fname, ftype, fid) = iprot.readFieldBegin()
4877 
      if ftype == TType.STOP:
4878 
        break
4879 
      if fid == 0:
4880 
        if ftype == TType.MAP:
4881 
          self.success = {}
4882 
          (_ktype57, _vtype58, _size56 ) = iprot.readMapBegin()
4883 
          for _i60 in xrange(_size56):
4884 
            _key61 = iprot.readString();
4885 
            _val62 = iprot.readString();
4886 
            self.success[_key61] = _val62
4887 
          iprot.readMapEnd()
4888 
        else:
4889 
          iprot.skip(ftype)
4890 
      elif fid == 1:
4891 
        if ftype == TType.STRUCT:
4892 
          self.se = LogisticsServiceException()
4893 
          self.se.read(iprot)
4894 
        else:
4895 
          iprot.skip(ftype)
4896 
      else:
4897 
        iprot.skip(ftype)
4898 
      iprot.readFieldEnd()
4899 
    iprot.readStructEnd()
4900 
 
4901 
  def write(self, oprot):
4902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4904 
      return
4905 
    oprot.writeStructBegin('getProviderLimitDetailsForPincode_result')
4906 
    if self.success is not None:
4907 
      oprot.writeFieldBegin('success', TType.MAP, 0)
4908 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
4909 
      for kiter63,viter64 in self.success.items():
4910 
        oprot.writeString(kiter63)
4911 
        oprot.writeString(viter64)
4912 
      oprot.writeMapEnd()
4913 
      oprot.writeFieldEnd()
4914 
    if self.se is not None:
4915 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
4916 
      self.se.write(oprot)
4917 
      oprot.writeFieldEnd()
4918 
    oprot.writeFieldStop()
4919 
    oprot.writeStructEnd()
4920 
 
4921 
  def validate(self):
4922 
    return
4923 
 
4924 
 
4925 
  def __repr__(self):
4926 
    L = ['%s=%r' % (key, value)
4927 
      for key, value in self.__dict__.iteritems()]
4928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4929 
 
4930 
  def __eq__(self, other):
4931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4932 
 
4933 
  def __ne__(self, other):
4934 
    return not (self == other)
19413 amit.gupta 4935 
 
4936 
class getLocationInfoMap_args:
4937 
  """
4938 
  Attributes:
4939 
   - destPincode
4940 
   - price
4941 
  """
4942 
 
4943 
  thrift_spec = (
4944 
    None, # 0
4945 
    (1, TType.STRING, 'destPincode', None, None, ), # 1
4946 
    (2, TType.LIST, 'price', (TType.I64,None), None, ), # 2
4947 
  )
4948 
 
4949 
  def __init__(self, destPincode=None, price=None,):
4950 
    self.destPincode = destPincode
4951 
    self.price = price
4952 
 
4953 
  def read(self, iprot):
4954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4956 
      return
4957 
    iprot.readStructBegin()
4958 
    while True:
4959 
      (fname, ftype, fid) = iprot.readFieldBegin()
4960 
      if ftype == TType.STOP:
4961 
        break
4962 
      if fid == 1:
4963 
        if ftype == TType.STRING:
4964 
          self.destPincode = iprot.readString();
4965 
        else:
4966 
          iprot.skip(ftype)
4967 
      elif fid == 2:
4968 
        if ftype == TType.LIST:
4969 
          self.price = []
4970 
          (_etype68, _size65) = iprot.readListBegin()
4971 
          for _i69 in xrange(_size65):
4972 
            _elem70 = iprot.readI64();
4973 
            self.price.append(_elem70)
4974 
          iprot.readListEnd()
4975 
        else:
4976 
          iprot.skip(ftype)
4977 
      else:
4978 
        iprot.skip(ftype)
4979 
      iprot.readFieldEnd()
4980 
    iprot.readStructEnd()
4981 
 
4982 
  def write(self, oprot):
4983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4985 
      return
4986 
    oprot.writeStructBegin('getLocationInfoMap_args')
4987 
    if self.destPincode is not None:
4988 
      oprot.writeFieldBegin('destPincode', TType.STRING, 1)
4989 
      oprot.writeString(self.destPincode)
4990 
      oprot.writeFieldEnd()
4991 
    if self.price is not None:
4992 
      oprot.writeFieldBegin('price', TType.LIST, 2)
4993 
      oprot.writeListBegin(TType.I64, len(self.price))
4994 
      for iter71 in self.price:
4995 
        oprot.writeI64(iter71)
4996 
      oprot.writeListEnd()
4997 
      oprot.writeFieldEnd()
4998 
    oprot.writeFieldStop()
4999 
    oprot.writeStructEnd()
5000 
 
5001 
  def validate(self):
5002 
    return
5003 
 
5004 
 
5005 
  def __repr__(self):
5006 
    L = ['%s=%r' % (key, value)
5007 
      for key, value in self.__dict__.iteritems()]
5008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5009 
 
5010 
  def __eq__(self, other):
5011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5012 
 
5013 
  def __ne__(self, other):
5014 
    return not (self == other)
5015 
 
5016 
class getLocationInfoMap_result:
5017 
  """
5018 
  Attributes:
5019 
   - success
5020 
  """
5021 
 
5022 
  thrift_spec = (
5023 
    (0, TType.MAP, 'success', (TType.I64,None,TType.MAP,(TType.I64,None,TType.STRUCT,(LocationInfo, LocationInfo.thrift_spec))), None, ), # 0
5024 
  )
5025 
 
5026 
  def __init__(self, success=None,):
5027 
    self.success = success
5028 
 
5029 
  def read(self, iprot):
5030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5032 
      return
5033 
    iprot.readStructBegin()
5034 
    while True:
5035 
      (fname, ftype, fid) = iprot.readFieldBegin()
5036 
      if ftype == TType.STOP:
5037 
        break
5038 
      if fid == 0:
5039 
        if ftype == TType.MAP:
5040 
          self.success = {}
5041 
          (_ktype73, _vtype74, _size72 ) = iprot.readMapBegin()
5042 
          for _i76 in xrange(_size72):
5043 
            _key77 = iprot.readI64();
5044 
            _val78 = {}
5045 
            (_ktype80, _vtype81, _size79 ) = iprot.readMapBegin()
5046 
            for _i83 in xrange(_size79):
5047 
              _key84 = iprot.readI64();
5048 
              _val85 = LocationInfo()
5049 
              _val85.read(iprot)
5050 
              _val78[_key84] = _val85
5051 
            iprot.readMapEnd()
5052 
            self.success[_key77] = _val78
5053 
          iprot.readMapEnd()
5054 
        else:
5055 
          iprot.skip(ftype)
5056 
      else:
5057 
        iprot.skip(ftype)
5058 
      iprot.readFieldEnd()
5059 
    iprot.readStructEnd()
5060 
 
5061 
  def write(self, oprot):
5062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5064 
      return
5065 
    oprot.writeStructBegin('getLocationInfoMap_result')
5066 
    if self.success is not None:
5067 
      oprot.writeFieldBegin('success', TType.MAP, 0)
5068 
      oprot.writeMapBegin(TType.I64, TType.MAP, len(self.success))
5069 
      for kiter86,viter87 in self.success.items():
5070 
        oprot.writeI64(kiter86)
5071 
        oprot.writeMapBegin(TType.I64, TType.STRUCT, len(viter87))
5072 
        for kiter88,viter89 in viter87.items():
5073 
          oprot.writeI64(kiter88)
5074 
          viter89.write(oprot)
5075 
        oprot.writeMapEnd()
5076 
      oprot.writeMapEnd()
5077 
      oprot.writeFieldEnd()
5078 
    oprot.writeFieldStop()
5079 
    oprot.writeStructEnd()
5080 
 
5081 
  def validate(self):
5082 
    return
5083 
 
5084 
 
5085 
  def __repr__(self):
5086 
    L = ['%s=%r' % (key, value)
5087 
      for key, value in self.__dict__.iteritems()]
5088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5089 
 
5090 
  def __eq__(self, other):
5091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5092 
 
5093 
  def __ne__(self, other):
5094 
    return not (self == other)
19474 manish.sha 5095 
 
5096 
class getCostingAndDeliveryEstimateForPincode_args:
5097 
  """
5098 
  Attributes:
5099 
   - pincode
5100 
   - transactionAmount
5101 
   - isCod
5102 
   - weight
5103 
   - billingWarehouseId
5104 
   - isCompleteTxn
5105 
  """
5106 
 
5107 
  thrift_spec = (
5108 
    None, # 0
5109 
    (1, TType.STRING, 'pincode', None, None, ), # 1
5110 
    (2, TType.DOUBLE, 'transactionAmount', None, None, ), # 2
5111 
    (3, TType.BOOL, 'isCod', None, None, ), # 3
5112 
    (4, TType.DOUBLE, 'weight', None, None, ), # 4
5113 
    (5, TType.I64, 'billingWarehouseId', None, None, ), # 5
5114 
    (6, TType.BOOL, 'isCompleteTxn', None, None, ), # 6
5115 
  )
5116 
 
5117 
  def __init__(self, pincode=None, transactionAmount=None, isCod=None, weight=None, billingWarehouseId=None, isCompleteTxn=None,):
5118 
    self.pincode = pincode
5119 
    self.transactionAmount = transactionAmount
5120 
    self.isCod = isCod
5121 
    self.weight = weight
5122 
    self.billingWarehouseId = billingWarehouseId
5123 
    self.isCompleteTxn = isCompleteTxn
5124 
 
5125 
  def read(self, iprot):
5126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5128 
      return
5129 
    iprot.readStructBegin()
5130 
    while True:
5131 
      (fname, ftype, fid) = iprot.readFieldBegin()
5132 
      if ftype == TType.STOP:
5133 
        break
5134 
      if fid == 1:
5135 
        if ftype == TType.STRING:
5136 
          self.pincode = iprot.readString();
5137 
        else:
5138 
          iprot.skip(ftype)
5139 
      elif fid == 2:
5140 
        if ftype == TType.DOUBLE:
5141 
          self.transactionAmount = iprot.readDouble();
5142 
        else:
5143 
          iprot.skip(ftype)
5144 
      elif fid == 3:
5145 
        if ftype == TType.BOOL:
5146 
          self.isCod = iprot.readBool();
5147 
        else:
5148 
          iprot.skip(ftype)
5149 
      elif fid == 4:
5150 
        if ftype == TType.DOUBLE:
5151 
          self.weight = iprot.readDouble();
5152 
        else:
5153 
          iprot.skip(ftype)
5154 
      elif fid == 5:
5155 
        if ftype == TType.I64:
5156 
          self.billingWarehouseId = iprot.readI64();
5157 
        else:
5158 
          iprot.skip(ftype)
5159 
      elif fid == 6:
5160 
        if ftype == TType.BOOL:
5161 
          self.isCompleteTxn = iprot.readBool();
5162 
        else:
5163 
          iprot.skip(ftype)
5164 
      else:
5165 
        iprot.skip(ftype)
5166 
      iprot.readFieldEnd()
5167 
    iprot.readStructEnd()
5168 
 
5169 
  def write(self, oprot):
5170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5172 
      return
5173 
    oprot.writeStructBegin('getCostingAndDeliveryEstimateForPincode_args')
5174 
    if self.pincode is not None:
5175 
      oprot.writeFieldBegin('pincode', TType.STRING, 1)
5176 
      oprot.writeString(self.pincode)
5177 
      oprot.writeFieldEnd()
5178 
    if self.transactionAmount is not None:
5179 
      oprot.writeFieldBegin('transactionAmount', TType.DOUBLE, 2)
5180 
      oprot.writeDouble(self.transactionAmount)
5181 
      oprot.writeFieldEnd()
5182 
    if self.isCod is not None:
5183 
      oprot.writeFieldBegin('isCod', TType.BOOL, 3)
5184 
      oprot.writeBool(self.isCod)
5185 
      oprot.writeFieldEnd()
5186 
    if self.weight is not None:
5187 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 4)
5188 
      oprot.writeDouble(self.weight)
5189 
      oprot.writeFieldEnd()
5190 
    if self.billingWarehouseId is not None:
5191 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 5)
5192 
      oprot.writeI64(self.billingWarehouseId)
5193 
      oprot.writeFieldEnd()
5194 
    if self.isCompleteTxn is not None:
5195 
      oprot.writeFieldBegin('isCompleteTxn', TType.BOOL, 6)
5196 
      oprot.writeBool(self.isCompleteTxn)
5197 
      oprot.writeFieldEnd()
5198 
    oprot.writeFieldStop()
5199 
    oprot.writeStructEnd()
5200 
 
5201 
  def validate(self):
5202 
    return
5203 
 
5204 
 
5205 
  def __repr__(self):
5206 
    L = ['%s=%r' % (key, value)
5207 
      for key, value in self.__dict__.iteritems()]
5208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5209 
 
5210 
  def __eq__(self, other):
5211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5212 
 
5213 
  def __ne__(self, other):
5214 
    return not (self == other)
5215 
 
5216 
class getCostingAndDeliveryEstimateForPincode_result:
5217 
  """
5218 
  Attributes:
5219 
   - success
5220 
   - se
5221 
  """
5222 
 
5223 
  thrift_spec = (
5224 
    (0, TType.STRUCT, 'success', (DeliveryEstimateAndCosting, DeliveryEstimateAndCosting.thrift_spec), None, ), # 0
5225 
    (1, TType.STRUCT, 'se', (LogisticsServiceException, LogisticsServiceException.thrift_spec), None, ), # 1
5226 
  )
5227 
 
5228 
  def __init__(self, success=None, se=None,):
5229 
    self.success = success
5230 
    self.se = se
5231 
 
5232 
  def read(self, iprot):
5233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5235 
      return
5236 
    iprot.readStructBegin()
5237 
    while True:
5238 
      (fname, ftype, fid) = iprot.readFieldBegin()
5239 
      if ftype == TType.STOP:
5240 
        break
5241 
      if fid == 0:
5242 
        if ftype == TType.STRUCT:
5243 
          self.success = DeliveryEstimateAndCosting()
5244 
          self.success.read(iprot)
5245 
        else:
5246 
          iprot.skip(ftype)
5247 
      elif fid == 1:
5248 
        if ftype == TType.STRUCT:
5249 
          self.se = LogisticsServiceException()
5250 
          self.se.read(iprot)
5251 
        else:
5252 
          iprot.skip(ftype)
5253 
      else:
5254 
        iprot.skip(ftype)
5255 
      iprot.readFieldEnd()
5256 
    iprot.readStructEnd()
5257 
 
5258 
  def write(self, oprot):
5259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5261 
      return
5262 
    oprot.writeStructBegin('getCostingAndDeliveryEstimateForPincode_result')
5263 
    if self.success is not None:
5264 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5265 
      self.success.write(oprot)
5266 
      oprot.writeFieldEnd()
5267 
    if self.se is not None:
5268 
      oprot.writeFieldBegin('se', TType.STRUCT, 1)
5269 
      self.se.write(oprot)
5270 
      oprot.writeFieldEnd()
5271 
    oprot.writeFieldStop()
5272 
    oprot.writeStructEnd()
5273 
 
5274 
  def validate(self):
5275 
    return
5276 
 
5277 
 
5278 
  def __repr__(self):
5279 
    L = ['%s=%r' % (key, value)
5280 
      for key, value in self.__dict__.iteritems()]
5281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5282 
 
5283 
  def __eq__(self, other):
5284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5285 
 
5286 
  def __ne__(self, other):
5287 
    return not (self == other)