Subversion Repositories SmartDukaan

Rev

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