Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
765 rajveer 19 
  def closeSession(self, ):
20 
    """
21 
    For closing the open session in sqlalchemy
22 
    """
23 
    pass
24 
 
94 ashish 25 
  def createTransaction(self, transaction):
26 
    """
27 
    Parameters:
28 
     - transaction
29 
    """
30 
    pass
31 
 
32 
  def getTransaction(self, id):
33 
    """
34 
    Parameters:
35 
     - id
36 
    """
37 
    pass
38 
 
39 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
40 
    """
41 
    Parameters:
42 
     - customerId
43 
     - from_date
44 
     - to_date
45 
     - status
46 
    """
47 
    pass
48 
 
132 ashish 49 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
50 
    """
51 
    Parameters:
52 
     - shoppingCartId
53 
    """
54 
    pass
55 
 
94 ashish 56 
  def getTransactionStatus(self, transactionId):
57 
    """
58 
    Parameters:
59 
     - transactionId
60 
    """
61 
    pass
62 
 
63 
  def changeTransactionStatus(self, transactionId, status, description):
64 
    """
65 
    Parameters:
66 
     - transactionId
67 
     - status
68 
     - description
69 
    """
70 
    pass
71 
 
1398 varun.gupt 72 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 73 
    """
74 
    Parameters:
75 
     - transactionId
76 
    """
77 
    pass
78 
 
483 rajveer 79 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 80 
    """
81 
    Parameters:
483 rajveer 82 
     - status
83 
     - from_date
84 
     - to_date
85 
     - warehouse_id
94 ashish 86 
    """
87 
    pass
88 
 
999 varun.gupt 89 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
90 
    """
1132 chandransh 91 
    Returns orders within a range of their billing dates
92 
 
999 varun.gupt 93 
    Parameters:
94 
     - status
95 
     - start_billing_date
96 
     - end_billing_date
97 
     - warehouse_id
98 
    """
99 
    pass
100 
 
1382 varun.gupt 101 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
102 
    """
103 
    Returns order ids for orders which can be returned
104 
 
105 
    Parameters:
106 
     - customer_id
107 
     - limit
108 
    """
109 
    pass
110 
 
111 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
112 
    """
113 
    Returns order ids for orders which can be cancelled
114 
 
115 
    Parameters:
116 
     - customer_id
117 
     - limit
118 
    """
119 
    pass
120 
 
483 rajveer 121 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 122 
    """
123 
    Parameters:
483 rajveer 124 
     - orderId
125 
     - status
126 
     - description
94 ashish 127 
    """
128 
    pass
129 
 
1149 chandransh 130 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 131 
    """
1149 chandransh 132 
    Add billing details such as the bill number and the biller to the Order.
133 
 
494 rajveer 134 
    Parameters:
135 
     - orderId
136 
     - invoice_number
137 
     - billed_by
138 
    """
139 
    pass
140 
 
1149 chandransh 141 
  def addJacketNumber(self, orderId, jacketNumber):
142 
    """
2446 chandransh 143 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
144 
    Also marks the order as billed and sets the billing timestamp.
145 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 146 
 
147 
    Parameters:
148 
     - orderId
149 
     - jacketNumber
150 
    """
151 
    pass
152 
 
921 rajveer 153 
  def acceptOrder(self, orderId):
154 
    """
155 
    Parameters:
156 
     - orderId
157 
    """
158 
    pass
159 
 
160 
  def billOrder(self, orderId):
161 
    """
162 
    Parameters:
163 
     - orderId
164 
    """
165 
    pass
166 
 
1528 ankur.sing 167 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 168 
    """
1528 ankur.sing 169 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
170 
    only user who owns the transaction can view its order details.
171 
 
94 ashish 172 
    Parameters:
173 
     - transactionId
1528 ankur.sing 174 
     - customerId
94 ashish 175 
    """
176 
    pass
177 
 
483 rajveer 178 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 179 
    """
180 
    Parameters:
483 rajveer 181 
     - customerId
182 
     - from_date
183 
     - to_date
184 
     - status
94 ashish 185 
    """
186 
    pass
187 
 
483 rajveer 188 
  def createOrder(self, order):
94 ashish 189 
    """
190 
    Parameters:
483 rajveer 191 
     - order
94 ashish 192 
    """
193 
    pass
194 
 
483 rajveer 195 
  def getOrder(self, id):
94 ashish 196 
    """
197 
    Parameters:
483 rajveer 198 
     - id
94 ashish 199 
    """
200 
    pass
201 
 
483 rajveer 202 
  def getLineItemsForOrder(self, orderId):
94 ashish 203 
    """
204 
    Parameters:
483 rajveer 205 
     - orderId
94 ashish 206 
    """
207 
    pass
208 
 
1528 ankur.sing 209 
  def getOrderForCustomer(self, orderId, customerId):
210 
    """
211 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
212 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
213 
 
214 
    Parameters:
215 
     - orderId
216 
     - customerId
217 
    """
218 
    pass
219 
 
1220 chandransh 220 
  def batchOrders(self, warehouseId):
221 
    """
222 
    Create a batch of all the pending orders for the given warehouse.
223 
    The returned list is orderd by created_timestamp.
224 
    If there are no pending orders, an empty list is returned.
225 
 
226 
    Parameters:
227 
     - warehouseId
228 
    """
229 
    pass
230 
 
1208 chandransh 231 
  def markOrderAsOutOfStock(self, orderId):
232 
    """
233 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
234 
 
235 
    Parameters:
236 
     - orderId
237 
    """
238 
    pass
239 
 
759 chandransh 240 
  def markOrdersAsManifested(self, warehouseId, providerId):
241 
    """
242 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
243 
 
244 
    Parameters:
245 
     - warehouseId
246 
     - providerId
247 
    """
248 
    pass
249 
 
1113 chandransh 250 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
251 
    """
252 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
253 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
254 
    Raises an exception if we encounter report for an AWB number that we did not ship.
255 
 
256 
    Parameters:
257 
     - providerId
258 
     - pickupDetails
259 
    """
260 
    pass
261 
 
1132 chandransh 262 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
263 
    """
264 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
265 
    the name of the receiver.
266 
    Raises an exception if we encounter report for an AWB number that we did not ship.
267 
 
268 
    Parameters:
269 
     - providerId
270 
     - deliveredOrders
271 
    """
272 
    pass
273 
 
1135 chandransh 274 
  def markOrdersAsFailed(self, providerId, returnedOrders):
275 
    """
276 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
277 
    Raises an exception if we encounter report for an AWB number that we did not ship.
278 
 
279 
    Parameters:
280 
     - providerId
281 
     - returnedOrders
282 
    """
283 
    pass
284 
 
1246 chandransh 285 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
286 
    """
287 
    Update the status description of orders whose AWB numbers are keys of the Map.
288 
 
289 
    Parameters:
290 
     - providerId
291 
     - undeliveredOrders
292 
    """
293 
    pass
294 
 
1408 ankur.sing 295 
  def getUndeliveredOrders(self, providerId, warehouseId):
296 
    """
297 
    Returns the list of orders whose delivery time has passed but have not been
298 
    delivered yet for the given provider and warehouse. To get a complete list of
299 
    undelivered orders, pass them as -1.
300 
    Returns an empty list if no such orders exist.
301 
 
302 
    Parameters:
303 
     - providerId
304 
     - warehouseId
305 
    """
306 
    pass
307 
 
483 rajveer 308 
  def getAlerts(self, orderId, valid):
94 ashish 309 
    """
310 
    Parameters:
483 rajveer 311 
     - orderId
304 ashish 312 
     - valid
313 
    """
314 
    pass
94 ashish 315 
 
483 rajveer 316 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 317 
    """
318 
    Parameters:
483 rajveer 319 
     - orderId
304 ashish 320 
     - unset
321 
     - type
322 
     - comment
323 
    """
324 
    pass
325 
 
1596 ankur.sing 326 
  def getValidOrderCount(self, ):
327 
    """
328 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
329 
    """
330 
    pass
304 ashish 331 
 
1627 ankur.sing 332 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
333 
    """
334 
    Returns the number of distinct customers who have done successful transactions
335 
    """
336 
    pass
1596 ankur.sing 337 
 
1731 ankur.sing 338 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 339 
    """
1731 ankur.sing 340 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
341 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 342 
    """
343 
    pass
344 
 
1886 ankur.sing 345 
  def getValidOrders(self, limit):
346 
    """
347 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
348 
    If limit is passed as 0, then all valid Orders are returned.
349 
 
350 
    Parameters:
351 
     - limit
352 
    """
353 
    pass
1627 ankur.sing 354 
 
2536 chandransh 355 
  def toggleDOAFlag(self, orderId):
356 
    """
357 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
358 
    Returns the final flag status.
359 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
360 
 
361 
    Parameters:
362 
     - orderId
363 
    """
364 
    pass
1886 ankur.sing 365 
 
2536 chandransh 366 
  def requestPickupNumber(self, orderId):
367 
    """
368 
    Sends out an email to the account manager of the original courier provider used to ship the order.
369 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
370 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
371 
    For any other status, it returns false.
372 
    Throws an exception if the order with the given id couldn't be found.
373 
 
374 
    Parameters:
375 
     - orderId
376 
    """
377 
    pass
378 
 
379 
  def authorizePickup(self, orderId, pickupNumber):
380 
    """
381 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
382 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
383 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
384 
    	3. Returns true
385 
    If the order is any other status, it returns false.
386 
    Throws an exception if the order with the given id couldn't be found.
387 
 
388 
    Parameters:
389 
     - orderId
390 
     - pickupNumber
391 
    """
392 
    pass
393 
 
394 
 
94 ashish 395 
class Client(Iface):
396 
  def __init__(self, iprot, oprot=None):
397 
    self._iprot = self._oprot = iprot
398 
    if oprot != None:
399 
      self._oprot = oprot
400 
    self._seqid = 0
401 
 
765 rajveer 402 
  def closeSession(self, ):
403 
    """
404 
    For closing the open session in sqlalchemy
405 
    """
406 
    self.send_closeSession()
407 
    self.recv_closeSession()
408 
 
409 
  def send_closeSession(self, ):
410 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
411 
    args = closeSession_args()
412 
    args.write(self._oprot)
413 
    self._oprot.writeMessageEnd()
414 
    self._oprot.trans.flush()
415 
 
416 
  def recv_closeSession(self, ):
417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
418 
    if mtype == TMessageType.EXCEPTION:
419 
      x = TApplicationException()
420 
      x.read(self._iprot)
421 
      self._iprot.readMessageEnd()
422 
      raise x
423 
    result = closeSession_result()
424 
    result.read(self._iprot)
425 
    self._iprot.readMessageEnd()
426 
    return
427 
 
94 ashish 428 
  def createTransaction(self, transaction):
429 
    """
430 
    Parameters:
431 
     - transaction
432 
    """
433 
    self.send_createTransaction(transaction)
132 ashish 434 
    return self.recv_createTransaction()
94 ashish 435 
 
436 
  def send_createTransaction(self, transaction):
437 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
438 
    args = createTransaction_args()
439 
    args.transaction = transaction
440 
    args.write(self._oprot)
441 
    self._oprot.writeMessageEnd()
442 
    self._oprot.trans.flush()
443 
 
444 
  def recv_createTransaction(self, ):
445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
446 
    if mtype == TMessageType.EXCEPTION:
447 
      x = TApplicationException()
448 
      x.read(self._iprot)
449 
      self._iprot.readMessageEnd()
450 
      raise x
451 
    result = createTransaction_result()
452 
    result.read(self._iprot)
453 
    self._iprot.readMessageEnd()
132 ashish 454 
    if result.success != None:
455 
      return result.success
94 ashish 456 
    if result.ex != None:
457 
      raise result.ex
132 ashish 458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 459 
 
460 
  def getTransaction(self, id):
461 
    """
462 
    Parameters:
463 
     - id
464 
    """
465 
    self.send_getTransaction(id)
466 
    return self.recv_getTransaction()
467 
 
468 
  def send_getTransaction(self, id):
469 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
470 
    args = getTransaction_args()
471 
    args.id = id
472 
    args.write(self._oprot)
473 
    self._oprot.writeMessageEnd()
474 
    self._oprot.trans.flush()
475 
 
476 
  def recv_getTransaction(self, ):
477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
478 
    if mtype == TMessageType.EXCEPTION:
479 
      x = TApplicationException()
480 
      x.read(self._iprot)
481 
      self._iprot.readMessageEnd()
482 
      raise x
483 
    result = getTransaction_result()
484 
    result.read(self._iprot)
485 
    self._iprot.readMessageEnd()
486 
    if result.success != None:
487 
      return result.success
488 
    if result.ex != None:
489 
      raise result.ex
490 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
491 
 
492 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
493 
    """
494 
    Parameters:
495 
     - customerId
496 
     - from_date
497 
     - to_date
498 
     - status
499 
    """
500 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
501 
    return self.recv_getTransactionsForCustomer()
502 
 
503 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
504 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
505 
    args = getTransactionsForCustomer_args()
506 
    args.customerId = customerId
507 
    args.from_date = from_date
508 
    args.to_date = to_date
509 
    args.status = status
510 
    args.write(self._oprot)
511 
    self._oprot.writeMessageEnd()
512 
    self._oprot.trans.flush()
513 
 
514 
  def recv_getTransactionsForCustomer(self, ):
515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
516 
    if mtype == TMessageType.EXCEPTION:
517 
      x = TApplicationException()
518 
      x.read(self._iprot)
519 
      self._iprot.readMessageEnd()
520 
      raise x
521 
    result = getTransactionsForCustomer_result()
522 
    result.read(self._iprot)
523 
    self._iprot.readMessageEnd()
524 
    if result.success != None:
525 
      return result.success
526 
    if result.ex != None:
527 
      raise result.ex
528 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
529 
 
132 ashish 530 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
531 
    """
532 
    Parameters:
533 
     - shoppingCartId
534 
    """
535 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
536 
    return self.recv_getTransactionsForShoppingCartId()
537 
 
538 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
539 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
540 
    args = getTransactionsForShoppingCartId_args()
541 
    args.shoppingCartId = shoppingCartId
542 
    args.write(self._oprot)
543 
    self._oprot.writeMessageEnd()
544 
    self._oprot.trans.flush()
545 
 
546 
  def recv_getTransactionsForShoppingCartId(self, ):
547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
548 
    if mtype == TMessageType.EXCEPTION:
549 
      x = TApplicationException()
550 
      x.read(self._iprot)
551 
      self._iprot.readMessageEnd()
552 
      raise x
553 
    result = getTransactionsForShoppingCartId_result()
554 
    result.read(self._iprot)
555 
    self._iprot.readMessageEnd()
556 
    if result.success != None:
557 
      return result.success
558 
    if result.ex != None:
559 
      raise result.ex
560 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
561 
 
94 ashish 562 
  def getTransactionStatus(self, transactionId):
563 
    """
564 
    Parameters:
565 
     - transactionId
566 
    """
567 
    self.send_getTransactionStatus(transactionId)
568 
    return self.recv_getTransactionStatus()
569 
 
570 
  def send_getTransactionStatus(self, transactionId):
571 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
572 
    args = getTransactionStatus_args()
573 
    args.transactionId = transactionId
574 
    args.write(self._oprot)
575 
    self._oprot.writeMessageEnd()
576 
    self._oprot.trans.flush()
577 
 
578 
  def recv_getTransactionStatus(self, ):
579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
580 
    if mtype == TMessageType.EXCEPTION:
581 
      x = TApplicationException()
582 
      x.read(self._iprot)
583 
      self._iprot.readMessageEnd()
584 
      raise x
585 
    result = getTransactionStatus_result()
586 
    result.read(self._iprot)
587 
    self._iprot.readMessageEnd()
588 
    if result.success != None:
589 
      return result.success
590 
    if result.ex != None:
591 
      raise result.ex
592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
593 
 
594 
  def changeTransactionStatus(self, transactionId, status, description):
595 
    """
596 
    Parameters:
597 
     - transactionId
598 
     - status
599 
     - description
600 
    """
601 
    self.send_changeTransactionStatus(transactionId, status, description)
602 
    return self.recv_changeTransactionStatus()
603 
 
604 
  def send_changeTransactionStatus(self, transactionId, status, description):
605 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
606 
    args = changeTransactionStatus_args()
607 
    args.transactionId = transactionId
608 
    args.status = status
609 
    args.description = description
610 
    args.write(self._oprot)
611 
    self._oprot.writeMessageEnd()
612 
    self._oprot.trans.flush()
613 
 
614 
  def recv_changeTransactionStatus(self, ):
615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
616 
    if mtype == TMessageType.EXCEPTION:
617 
      x = TApplicationException()
618 
      x.read(self._iprot)
619 
      self._iprot.readMessageEnd()
620 
      raise x
621 
    result = changeTransactionStatus_result()
622 
    result.read(self._iprot)
623 
    self._iprot.readMessageEnd()
624 
    if result.success != None:
625 
      return result.success
626 
    if result.ex != None:
627 
      raise result.ex
628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
629 
 
1398 varun.gupt 630 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 631 
    """
632 
    Parameters:
633 
     - transactionId
634 
    """
1398 varun.gupt 635 
    self.send_enqueueTransactionInfoEmail(transactionId)
636 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 637 
 
1398 varun.gupt 638 
  def send_enqueueTransactionInfoEmail(self, transactionId):
639 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
640 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 641 
    args.transactionId = transactionId
642 
    args.write(self._oprot)
643 
    self._oprot.writeMessageEnd()
644 
    self._oprot.trans.flush()
645 
 
1398 varun.gupt 646 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
648 
    if mtype == TMessageType.EXCEPTION:
649 
      x = TApplicationException()
650 
      x.read(self._iprot)
651 
      self._iprot.readMessageEnd()
652 
      raise x
1398 varun.gupt 653 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 654 
    result.read(self._iprot)
655 
    self._iprot.readMessageEnd()
656 
    if result.success != None:
657 
      return result.success
658 
    if result.ex != None:
659 
      raise result.ex
1398 varun.gupt 660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 661 
 
483 rajveer 662 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 663 
    """
664 
    Parameters:
483 rajveer 665 
     - status
666 
     - from_date
667 
     - to_date
668 
     - warehouse_id
94 ashish 669 
    """
483 rajveer 670 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
671 
    return self.recv_getAllOrders()
94 ashish 672 
 
483 rajveer 673 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
674 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
675 
    args = getAllOrders_args()
676 
    args.status = status
677 
    args.from_date = from_date
678 
    args.to_date = to_date
679 
    args.warehouse_id = warehouse_id
94 ashish 680 
    args.write(self._oprot)
681 
    self._oprot.writeMessageEnd()
682 
    self._oprot.trans.flush()
683 
 
483 rajveer 684 
  def recv_getAllOrders(self, ):
94 ashish 685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
686 
    if mtype == TMessageType.EXCEPTION:
687 
      x = TApplicationException()
688 
      x.read(self._iprot)
689 
      self._iprot.readMessageEnd()
690 
      raise x
483 rajveer 691 
    result = getAllOrders_result()
94 ashish 692 
    result.read(self._iprot)
693 
    self._iprot.readMessageEnd()
694 
    if result.success != None:
695 
      return result.success
696 
    if result.ex != None:
697 
      raise result.ex
483 rajveer 698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 699 
 
999 varun.gupt 700 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
701 
    """
1132 chandransh 702 
    Returns orders within a range of their billing dates
703 
 
999 varun.gupt 704 
    Parameters:
705 
     - status
706 
     - start_billing_date
707 
     - end_billing_date
708 
     - warehouse_id
709 
    """
710 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
711 
    return self.recv_getOrdersByBillingDate()
712 
 
713 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
714 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
715 
    args = getOrdersByBillingDate_args()
716 
    args.status = status
717 
    args.start_billing_date = start_billing_date
718 
    args.end_billing_date = end_billing_date
719 
    args.warehouse_id = warehouse_id
720 
    args.write(self._oprot)
721 
    self._oprot.writeMessageEnd()
722 
    self._oprot.trans.flush()
723 
 
724 
  def recv_getOrdersByBillingDate(self, ):
725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
726 
    if mtype == TMessageType.EXCEPTION:
727 
      x = TApplicationException()
728 
      x.read(self._iprot)
729 
      self._iprot.readMessageEnd()
730 
      raise x
731 
    result = getOrdersByBillingDate_result()
732 
    result.read(self._iprot)
733 
    self._iprot.readMessageEnd()
734 
    if result.success != None:
735 
      return result.success
736 
    if result.ex != None:
737 
      raise result.ex
738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
739 
 
1382 varun.gupt 740 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
741 
    """
742 
    Returns order ids for orders which can be returned
743 
 
744 
    Parameters:
745 
     - customer_id
746 
     - limit
747 
    """
748 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
749 
    return self.recv_getReturnableOrdersForCustomer()
750 
 
751 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
752 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
753 
    args = getReturnableOrdersForCustomer_args()
754 
    args.customer_id = customer_id
755 
    args.limit = limit
756 
    args.write(self._oprot)
757 
    self._oprot.writeMessageEnd()
758 
    self._oprot.trans.flush()
759 
 
760 
  def recv_getReturnableOrdersForCustomer(self, ):
761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
762 
    if mtype == TMessageType.EXCEPTION:
763 
      x = TApplicationException()
764 
      x.read(self._iprot)
765 
      self._iprot.readMessageEnd()
766 
      raise x
767 
    result = getReturnableOrdersForCustomer_result()
768 
    result.read(self._iprot)
769 
    self._iprot.readMessageEnd()
770 
    if result.success != None:
771 
      return result.success
772 
    if result.ex != None:
773 
      raise result.ex
774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
775 
 
776 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
777 
    """
778 
    Returns order ids for orders which can be cancelled
779 
 
780 
    Parameters:
781 
     - customer_id
782 
     - limit
783 
    """
784 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
785 
    return self.recv_getCancellableOrdersForCustomer()
786 
 
787 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
788 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
789 
    args = getCancellableOrdersForCustomer_args()
790 
    args.customer_id = customer_id
791 
    args.limit = limit
792 
    args.write(self._oprot)
793 
    self._oprot.writeMessageEnd()
794 
    self._oprot.trans.flush()
795 
 
796 
  def recv_getCancellableOrdersForCustomer(self, ):
797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
798 
    if mtype == TMessageType.EXCEPTION:
799 
      x = TApplicationException()
800 
      x.read(self._iprot)
801 
      self._iprot.readMessageEnd()
802 
      raise x
803 
    result = getCancellableOrdersForCustomer_result()
804 
    result.read(self._iprot)
805 
    self._iprot.readMessageEnd()
806 
    if result.success != None:
807 
      return result.success
808 
    if result.ex != None:
809 
      raise result.ex
810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
811 
 
483 rajveer 812 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 813 
    """
814 
    Parameters:
483 rajveer 815 
     - orderId
816 
     - status
817 
     - description
94 ashish 818 
    """
483 rajveer 819 
    self.send_changeOrderStatus(orderId, status, description)
820 
    return self.recv_changeOrderStatus()
94 ashish 821 
 
483 rajveer 822 
  def send_changeOrderStatus(self, orderId, status, description):
823 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
824 
    args = changeOrderStatus_args()
825 
    args.orderId = orderId
826 
    args.status = status
827 
    args.description = description
94 ashish 828 
    args.write(self._oprot)
829 
    self._oprot.writeMessageEnd()
830 
    self._oprot.trans.flush()
831 
 
483 rajveer 832 
  def recv_changeOrderStatus(self, ):
94 ashish 833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
834 
    if mtype == TMessageType.EXCEPTION:
835 
      x = TApplicationException()
836 
      x.read(self._iprot)
837 
      self._iprot.readMessageEnd()
838 
      raise x
483 rajveer 839 
    result = changeOrderStatus_result()
94 ashish 840 
    result.read(self._iprot)
841 
    self._iprot.readMessageEnd()
842 
    if result.success != None:
843 
      return result.success
844 
    if result.ex != None:
845 
      raise result.ex
483 rajveer 846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 847 
 
1149 chandransh 848 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 849 
    """
1149 chandransh 850 
    Add billing details such as the bill number and the biller to the Order.
851 
 
494 rajveer 852 
    Parameters:
853 
     - orderId
854 
     - invoice_number
855 
     - billed_by
856 
    """
1149 chandransh 857 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
494 rajveer 858 
    return self.recv_addBillingDetails()
859 
 
1149 chandransh 860 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 861 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
862 
    args = addBillingDetails_args()
863 
    args.orderId = orderId
864 
    args.invoice_number = invoice_number
865 
    args.billed_by = billed_by
866 
    args.write(self._oprot)
867 
    self._oprot.writeMessageEnd()
868 
    self._oprot.trans.flush()
869 
 
870 
  def recv_addBillingDetails(self, ):
871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
872 
    if mtype == TMessageType.EXCEPTION:
873 
      x = TApplicationException()
874 
      x.read(self._iprot)
875 
      self._iprot.readMessageEnd()
876 
      raise x
877 
    result = addBillingDetails_result()
878 
    result.read(self._iprot)
879 
    self._iprot.readMessageEnd()
880 
    if result.success != None:
881 
      return result.success
882 
    if result.ex != None:
883 
      raise result.ex
884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
885 
 
1149 chandransh 886 
  def addJacketNumber(self, orderId, jacketNumber):
887 
    """
2446 chandransh 888 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
889 
    Also marks the order as billed and sets the billing timestamp.
890 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 891 
 
892 
    Parameters:
893 
     - orderId
894 
     - jacketNumber
895 
    """
896 
    self.send_addJacketNumber(orderId, jacketNumber)
897 
    return self.recv_addJacketNumber()
898 
 
899 
  def send_addJacketNumber(self, orderId, jacketNumber):
900 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
901 
    args = addJacketNumber_args()
902 
    args.orderId = orderId
903 
    args.jacketNumber = jacketNumber
904 
    args.write(self._oprot)
905 
    self._oprot.writeMessageEnd()
906 
    self._oprot.trans.flush()
907 
 
908 
  def recv_addJacketNumber(self, ):
909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
910 
    if mtype == TMessageType.EXCEPTION:
911 
      x = TApplicationException()
912 
      x.read(self._iprot)
913 
      self._iprot.readMessageEnd()
914 
      raise x
915 
    result = addJacketNumber_result()
916 
    result.read(self._iprot)
917 
    self._iprot.readMessageEnd()
918 
    if result.success != None:
919 
      return result.success
920 
    if result.ex != None:
921 
      raise result.ex
922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
923 
 
921 rajveer 924 
  def acceptOrder(self, orderId):
925 
    """
926 
    Parameters:
927 
     - orderId
928 
    """
929 
    self.send_acceptOrder(orderId)
930 
    return self.recv_acceptOrder()
931 
 
932 
  def send_acceptOrder(self, orderId):
933 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
934 
    args = acceptOrder_args()
935 
    args.orderId = orderId
936 
    args.write(self._oprot)
937 
    self._oprot.writeMessageEnd()
938 
    self._oprot.trans.flush()
939 
 
940 
  def recv_acceptOrder(self, ):
941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
942 
    if mtype == TMessageType.EXCEPTION:
943 
      x = TApplicationException()
944 
      x.read(self._iprot)
945 
      self._iprot.readMessageEnd()
946 
      raise x
947 
    result = acceptOrder_result()
948 
    result.read(self._iprot)
949 
    self._iprot.readMessageEnd()
950 
    if result.success != None:
951 
      return result.success
952 
    if result.ex != None:
953 
      raise result.ex
954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
955 
 
956 
  def billOrder(self, orderId):
957 
    """
958 
    Parameters:
959 
     - orderId
960 
    """
961 
    self.send_billOrder(orderId)
962 
    return self.recv_billOrder()
963 
 
964 
  def send_billOrder(self, orderId):
965 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
966 
    args = billOrder_args()
967 
    args.orderId = orderId
968 
    args.write(self._oprot)
969 
    self._oprot.writeMessageEnd()
970 
    self._oprot.trans.flush()
971 
 
972 
  def recv_billOrder(self, ):
973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
974 
    if mtype == TMessageType.EXCEPTION:
975 
      x = TApplicationException()
976 
      x.read(self._iprot)
977 
      self._iprot.readMessageEnd()
978 
      raise x
979 
    result = billOrder_result()
980 
    result.read(self._iprot)
981 
    self._iprot.readMessageEnd()
982 
    if result.success != None:
983 
      return result.success
984 
    if result.ex != None:
985 
      raise result.ex
986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
987 
 
1528 ankur.sing 988 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 989 
    """
1528 ankur.sing 990 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
991 
    only user who owns the transaction can view its order details.
992 
 
94 ashish 993 
    Parameters:
994 
     - transactionId
1528 ankur.sing 995 
     - customerId
94 ashish 996 
    """
1528 ankur.sing 997 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 998 
    return self.recv_getOrdersForTransaction()
94 ashish 999 
 
1528 ankur.sing 1000 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1001 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1002 
    args = getOrdersForTransaction_args()
94 ashish 1003 
    args.transactionId = transactionId
1528 ankur.sing 1004 
    args.customerId = customerId
94 ashish 1005 
    args.write(self._oprot)
1006 
    self._oprot.writeMessageEnd()
1007 
    self._oprot.trans.flush()
1008 
 
483 rajveer 1009 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1011 
    if mtype == TMessageType.EXCEPTION:
1012 
      x = TApplicationException()
1013 
      x.read(self._iprot)
1014 
      self._iprot.readMessageEnd()
1015 
      raise x
483 rajveer 1016 
    result = getOrdersForTransaction_result()
94 ashish 1017 
    result.read(self._iprot)
1018 
    self._iprot.readMessageEnd()
1019 
    if result.success != None:
1020 
      return result.success
1021 
    if result.ex != None:
1022 
      raise result.ex
483 rajveer 1023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1024 
 
483 rajveer 1025 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 1026 
    """
1027 
    Parameters:
483 rajveer 1028 
     - customerId
1029 
     - from_date
1030 
     - to_date
1031 
     - status
94 ashish 1032 
    """
483 rajveer 1033 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, status)
1034 
    return self.recv_getOrdersForCustomer()
94 ashish 1035 
 
483 rajveer 1036 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, status):
1037 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1038 
    args = getOrdersForCustomer_args()
1039 
    args.customerId = customerId
1040 
    args.from_date = from_date
1041 
    args.to_date = to_date
1042 
    args.status = status
94 ashish 1043 
    args.write(self._oprot)
1044 
    self._oprot.writeMessageEnd()
1045 
    self._oprot.trans.flush()
1046 
 
483 rajveer 1047 
  def recv_getOrdersForCustomer(self, ):
94 ashish 1048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1049 
    if mtype == TMessageType.EXCEPTION:
1050 
      x = TApplicationException()
1051 
      x.read(self._iprot)
1052 
      self._iprot.readMessageEnd()
1053 
      raise x
483 rajveer 1054 
    result = getOrdersForCustomer_result()
94 ashish 1055 
    result.read(self._iprot)
1056 
    self._iprot.readMessageEnd()
1057 
    if result.success != None:
1058 
      return result.success
1059 
    if result.ex != None:
1060 
      raise result.ex
483 rajveer 1061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 1062 
 
483 rajveer 1063 
  def createOrder(self, order):
94 ashish 1064 
    """
1065 
    Parameters:
483 rajveer 1066 
     - order
94 ashish 1067 
    """
483 rajveer 1068 
    self.send_createOrder(order)
1069 
    return self.recv_createOrder()
94 ashish 1070 
 
483 rajveer 1071 
  def send_createOrder(self, order):
1072 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1073 
    args = createOrder_args()
1074 
    args.order = order
94 ashish 1075 
    args.write(self._oprot)
1076 
    self._oprot.writeMessageEnd()
1077 
    self._oprot.trans.flush()
1078 
 
483 rajveer 1079 
  def recv_createOrder(self, ):
94 ashish 1080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1081 
    if mtype == TMessageType.EXCEPTION:
1082 
      x = TApplicationException()
1083 
      x.read(self._iprot)
1084 
      self._iprot.readMessageEnd()
1085 
      raise x
483 rajveer 1086 
    result = createOrder_result()
94 ashish 1087 
    result.read(self._iprot)
1088 
    self._iprot.readMessageEnd()
1089 
    if result.success != None:
1090 
      return result.success
1091 
    if result.ex != None:
1092 
      raise result.ex
483 rajveer 1093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1094 
 
483 rajveer 1095 
  def getOrder(self, id):
94 ashish 1096 
    """
1097 
    Parameters:
483 rajveer 1098 
     - id
94 ashish 1099 
    """
483 rajveer 1100 
    self.send_getOrder(id)
1101 
    return self.recv_getOrder()
94 ashish 1102 
 
483 rajveer 1103 
  def send_getOrder(self, id):
1104 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1105 
    args = getOrder_args()
1106 
    args.id = id
94 ashish 1107 
    args.write(self._oprot)
1108 
    self._oprot.writeMessageEnd()
1109 
    self._oprot.trans.flush()
1110 
 
483 rajveer 1111 
  def recv_getOrder(self, ):
94 ashish 1112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1113 
    if mtype == TMessageType.EXCEPTION:
1114 
      x = TApplicationException()
1115 
      x.read(self._iprot)
1116 
      self._iprot.readMessageEnd()
1117 
      raise x
483 rajveer 1118 
    result = getOrder_result()
94 ashish 1119 
    result.read(self._iprot)
1120 
    self._iprot.readMessageEnd()
1121 
    if result.success != None:
1122 
      return result.success
1123 
    if result.ex != None:
1124 
      raise result.ex
483 rajveer 1125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1126 
 
483 rajveer 1127 
  def getLineItemsForOrder(self, orderId):
94 ashish 1128 
    """
1129 
    Parameters:
483 rajveer 1130 
     - orderId
94 ashish 1131 
    """
483 rajveer 1132 
    self.send_getLineItemsForOrder(orderId)
1133 
    return self.recv_getLineItemsForOrder()
94 ashish 1134 
 
483 rajveer 1135 
  def send_getLineItemsForOrder(self, orderId):
1136 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1137 
    args = getLineItemsForOrder_args()
1138 
    args.orderId = orderId
94 ashish 1139 
    args.write(self._oprot)
1140 
    self._oprot.writeMessageEnd()
1141 
    self._oprot.trans.flush()
1142 
 
483 rajveer 1143 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1145 
    if mtype == TMessageType.EXCEPTION:
1146 
      x = TApplicationException()
1147 
      x.read(self._iprot)
1148 
      self._iprot.readMessageEnd()
1149 
      raise x
483 rajveer 1150 
    result = getLineItemsForOrder_result()
94 ashish 1151 
    result.read(self._iprot)
1152 
    self._iprot.readMessageEnd()
1153 
    if result.success != None:
1154 
      return result.success
1155 
    if result.ex != None:
1156 
      raise result.ex
483 rajveer 1157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1158 
 
1528 ankur.sing 1159 
  def getOrderForCustomer(self, orderId, customerId):
1160 
    """
1161 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1162 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
1163 
 
1164 
    Parameters:
1165 
     - orderId
1166 
     - customerId
1167 
    """
1168 
    self.send_getOrderForCustomer(orderId, customerId)
1169 
    return self.recv_getOrderForCustomer()
1170 
 
1171 
  def send_getOrderForCustomer(self, orderId, customerId):
1172 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1173 
    args = getOrderForCustomer_args()
1174 
    args.orderId = orderId
1175 
    args.customerId = customerId
1176 
    args.write(self._oprot)
1177 
    self._oprot.writeMessageEnd()
1178 
    self._oprot.trans.flush()
1179 
 
1180 
  def recv_getOrderForCustomer(self, ):
1181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1182 
    if mtype == TMessageType.EXCEPTION:
1183 
      x = TApplicationException()
1184 
      x.read(self._iprot)
1185 
      self._iprot.readMessageEnd()
1186 
      raise x
1187 
    result = getOrderForCustomer_result()
1188 
    result.read(self._iprot)
1189 
    self._iprot.readMessageEnd()
1190 
    if result.success != None:
1191 
      return result.success
1192 
    if result.ex != None:
1193 
      raise result.ex
1194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1195 
 
1220 chandransh 1196 
  def batchOrders(self, warehouseId):
1197 
    """
1198 
    Create a batch of all the pending orders for the given warehouse.
1199 
    The returned list is orderd by created_timestamp.
1200 
    If there are no pending orders, an empty list is returned.
1201 
 
1202 
    Parameters:
1203 
     - warehouseId
1204 
    """
1205 
    self.send_batchOrders(warehouseId)
1206 
    return self.recv_batchOrders()
1207 
 
1208 
  def send_batchOrders(self, warehouseId):
1209 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1210 
    args = batchOrders_args()
1211 
    args.warehouseId = warehouseId
1212 
    args.write(self._oprot)
1213 
    self._oprot.writeMessageEnd()
1214 
    self._oprot.trans.flush()
1215 
 
1216 
  def recv_batchOrders(self, ):
1217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1218 
    if mtype == TMessageType.EXCEPTION:
1219 
      x = TApplicationException()
1220 
      x.read(self._iprot)
1221 
      self._iprot.readMessageEnd()
1222 
      raise x
1223 
    result = batchOrders_result()
1224 
    result.read(self._iprot)
1225 
    self._iprot.readMessageEnd()
1226 
    if result.success != None:
1227 
      return result.success
1228 
    if result.ex != None:
1229 
      raise result.ex
1230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1231 
 
1208 chandransh 1232 
  def markOrderAsOutOfStock(self, orderId):
1233 
    """
1234 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
1235 
 
1236 
    Parameters:
1237 
     - orderId
1238 
    """
1239 
    self.send_markOrderAsOutOfStock(orderId)
1240 
    return self.recv_markOrderAsOutOfStock()
1241 
 
1242 
  def send_markOrderAsOutOfStock(self, orderId):
1243 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1244 
    args = markOrderAsOutOfStock_args()
1245 
    args.orderId = orderId
1246 
    args.write(self._oprot)
1247 
    self._oprot.writeMessageEnd()
1248 
    self._oprot.trans.flush()
1249 
 
1250 
  def recv_markOrderAsOutOfStock(self, ):
1251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1252 
    if mtype == TMessageType.EXCEPTION:
1253 
      x = TApplicationException()
1254 
      x.read(self._iprot)
1255 
      self._iprot.readMessageEnd()
1256 
      raise x
1257 
    result = markOrderAsOutOfStock_result()
1258 
    result.read(self._iprot)
1259 
    self._iprot.readMessageEnd()
1260 
    if result.success != None:
1261 
      return result.success
1262 
    if result.ex != None:
1263 
      raise result.ex
1264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1265 
 
759 chandransh 1266 
  def markOrdersAsManifested(self, warehouseId, providerId):
1267 
    """
1268 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
1269 
 
1270 
    Parameters:
1271 
     - warehouseId
1272 
     - providerId
1273 
    """
1274 
    self.send_markOrdersAsManifested(warehouseId, providerId)
1275 
    return self.recv_markOrdersAsManifested()
1276 
 
1277 
  def send_markOrdersAsManifested(self, warehouseId, providerId):
1278 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1279 
    args = markOrdersAsManifested_args()
1280 
    args.warehouseId = warehouseId
1281 
    args.providerId = providerId
1282 
    args.write(self._oprot)
1283 
    self._oprot.writeMessageEnd()
1284 
    self._oprot.trans.flush()
1285 
 
1286 
  def recv_markOrdersAsManifested(self, ):
1287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1288 
    if mtype == TMessageType.EXCEPTION:
1289 
      x = TApplicationException()
1290 
      x.read(self._iprot)
1291 
      self._iprot.readMessageEnd()
1292 
      raise x
1293 
    result = markOrdersAsManifested_result()
1294 
    result.read(self._iprot)
1295 
    self._iprot.readMessageEnd()
1296 
    if result.success != None:
1297 
      return result.success
1298 
    if result.ex != None:
1299 
      raise result.ex
1300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1301 
 
1113 chandransh 1302 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
1303 
    """
1304 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1305 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1306 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1307 
 
1308 
    Parameters:
1309 
     - providerId
1310 
     - pickupDetails
1311 
    """
1312 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1313 
    return self.recv_markOrdersAsPickedUp()
1314 
 
1315 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1316 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1317 
    args = markOrdersAsPickedUp_args()
1318 
    args.providerId = providerId
1319 
    args.pickupDetails = pickupDetails
1320 
    args.write(self._oprot)
1321 
    self._oprot.writeMessageEnd()
1322 
    self._oprot.trans.flush()
1323 
 
1324 
  def recv_markOrdersAsPickedUp(self, ):
1325 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1326 
    if mtype == TMessageType.EXCEPTION:
1327 
      x = TApplicationException()
1328 
      x.read(self._iprot)
1329 
      self._iprot.readMessageEnd()
1330 
      raise x
1331 
    result = markOrdersAsPickedUp_result()
1332 
    result.read(self._iprot)
1333 
    self._iprot.readMessageEnd()
1334 
    if result.success != None:
1335 
      return result.success
1336 
    if result.ex != None:
1337 
      raise result.ex
1338 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
1339 
 
1132 chandransh 1340 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
1341 
    """
1342 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1343 
    the name of the receiver.
1344 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1345 
 
1346 
    Parameters:
1347 
     - providerId
1348 
     - deliveredOrders
1349 
    """
1350 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1351 
    self.recv_markOrdersAsDelivered()
1352 
 
1353 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1354 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1355 
    args = markOrdersAsDelivered_args()
1356 
    args.providerId = providerId
1357 
    args.deliveredOrders = deliveredOrders
1358 
    args.write(self._oprot)
1359 
    self._oprot.writeMessageEnd()
1360 
    self._oprot.trans.flush()
1361 
 
1362 
  def recv_markOrdersAsDelivered(self, ):
1363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1364 
    if mtype == TMessageType.EXCEPTION:
1365 
      x = TApplicationException()
1366 
      x.read(self._iprot)
1367 
      self._iprot.readMessageEnd()
1368 
      raise x
1369 
    result = markOrdersAsDelivered_result()
1370 
    result.read(self._iprot)
1371 
    self._iprot.readMessageEnd()
1372 
    if result.ex != None:
1373 
      raise result.ex
1374 
    return
1375 
 
1135 chandransh 1376 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1377 
    """
1378 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1379 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1380 
 
1381 
    Parameters:
1382 
     - providerId
1383 
     - returnedOrders
1384 
    """
1385 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1386 
    self.recv_markOrdersAsFailed()
1387 
 
1388 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1389 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1390 
    args = markOrdersAsFailed_args()
1391 
    args.providerId = providerId
1392 
    args.returnedOrders = returnedOrders
1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_markOrdersAsFailed(self, ):
1398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1399 
    if mtype == TMessageType.EXCEPTION:
1400 
      x = TApplicationException()
1401 
      x.read(self._iprot)
1402 
      self._iprot.readMessageEnd()
1403 
      raise x
1404 
    result = markOrdersAsFailed_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
1407 
    if result.ex != None:
1408 
      raise result.ex
1409 
    return
1410 
 
1246 chandransh 1411 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1412 
    """
1413 
    Update the status description of orders whose AWB numbers are keys of the Map.
1414 
 
1415 
    Parameters:
1416 
     - providerId
1417 
     - undeliveredOrders
1418 
    """
1419 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
1420 
    self.recv_updateNonDeliveryReason()
1421 
 
1422 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
1423 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
1424 
    args = updateNonDeliveryReason_args()
1425 
    args.providerId = providerId
1426 
    args.undeliveredOrders = undeliveredOrders
1427 
    args.write(self._oprot)
1428 
    self._oprot.writeMessageEnd()
1429 
    self._oprot.trans.flush()
1430 
 
1431 
  def recv_updateNonDeliveryReason(self, ):
1432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1433 
    if mtype == TMessageType.EXCEPTION:
1434 
      x = TApplicationException()
1435 
      x.read(self._iprot)
1436 
      self._iprot.readMessageEnd()
1437 
      raise x
1438 
    result = updateNonDeliveryReason_result()
1439 
    result.read(self._iprot)
1440 
    self._iprot.readMessageEnd()
1441 
    if result.ex != None:
1442 
      raise result.ex
1443 
    return
1444 
 
1408 ankur.sing 1445 
  def getUndeliveredOrders(self, providerId, warehouseId):
1446 
    """
1447 
    Returns the list of orders whose delivery time has passed but have not been
1448 
    delivered yet for the given provider and warehouse. To get a complete list of
1449 
    undelivered orders, pass them as -1.
1450 
    Returns an empty list if no such orders exist.
1451 
 
1452 
    Parameters:
1453 
     - providerId
1454 
     - warehouseId
1455 
    """
1456 
    self.send_getUndeliveredOrders(providerId, warehouseId)
1457 
    return self.recv_getUndeliveredOrders()
1458 
 
1459 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
1460 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
1461 
    args = getUndeliveredOrders_args()
1462 
    args.providerId = providerId
1463 
    args.warehouseId = warehouseId
1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
1468 
  def recv_getUndeliveredOrders(self, ):
1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
1475 
    result = getUndeliveredOrders_result()
1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
1478 
    if result.success != None:
1479 
      return result.success
1480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1481 
 
483 rajveer 1482 
  def getAlerts(self, orderId, valid):
94 ashish 1483 
    """
1484 
    Parameters:
483 rajveer 1485 
     - orderId
304 ashish 1486 
     - valid
1487 
    """
483 rajveer 1488 
    self.send_getAlerts(orderId, valid)
304 ashish 1489 
    return self.recv_getAlerts()
94 ashish 1490 
 
483 rajveer 1491 
  def send_getAlerts(self, orderId, valid):
304 ashish 1492 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1493 
    args = getAlerts_args()
483 rajveer 1494 
    args.orderId = orderId
304 ashish 1495 
    args.valid = valid
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_getAlerts(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = getAlerts_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
1510 
    if result.success != None:
1511 
      return result.success
1512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1513 
 
483 rajveer 1514 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 1515 
    """
1516 
    Parameters:
483 rajveer 1517 
     - orderId
304 ashish 1518 
     - unset
1519 
     - type
1520 
     - comment
1521 
    """
483 rajveer 1522 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 1523 
    self.recv_setAlert()
1524 
 
483 rajveer 1525 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 1526 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1527 
    args = setAlert_args()
483 rajveer 1528 
    args.orderId = orderId
304 ashish 1529 
    args.unset = unset
1530 
    args.type = type
1531 
    args.comment = comment
1532 
    args.write(self._oprot)
1533 
    self._oprot.writeMessageEnd()
1534 
    self._oprot.trans.flush()
1535 
 
1536 
  def recv_setAlert(self, ):
1537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1538 
    if mtype == TMessageType.EXCEPTION:
1539 
      x = TApplicationException()
1540 
      x.read(self._iprot)
1541 
      self._iprot.readMessageEnd()
1542 
      raise x
1543 
    result = setAlert_result()
1544 
    result.read(self._iprot)
1545 
    self._iprot.readMessageEnd()
1546 
    return
1547 
 
1596 ankur.sing 1548 
  def getValidOrderCount(self, ):
1549 
    """
1550 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1551 
    """
1552 
    self.send_getValidOrderCount()
1553 
    return self.recv_getValidOrderCount()
304 ashish 1554 
 
1596 ankur.sing 1555 
  def send_getValidOrderCount(self, ):
1556 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1557 
    args = getValidOrderCount_args()
1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_getValidOrderCount(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = getValidOrderCount_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
1572 
    if result.success != None:
1573 
      return result.success
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1575 
 
1627 ankur.sing 1576 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1577 
    """
1578 
    Returns the number of distinct customers who have done successful transactions
1579 
    """
1580 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1581 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1596 ankur.sing 1582 
 
1627 ankur.sing 1583 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1584 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1585 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1586 
    args.write(self._oprot)
1587 
    self._oprot.writeMessageEnd()
1588 
    self._oprot.trans.flush()
1589 
 
1590 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
1591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1592 
    if mtype == TMessageType.EXCEPTION:
1593 
      x = TApplicationException()
1594 
      x.read(self._iprot)
1595 
      self._iprot.readMessageEnd()
1596 
      raise x
1597 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
1598 
    result.read(self._iprot)
1599 
    self._iprot.readMessageEnd()
1600 
    if result.success != None:
1601 
      return result.success
1602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1603 
 
1731 ankur.sing 1604 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 1605 
    """
1731 ankur.sing 1606 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1607 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 1608 
    """
1731 ankur.sing 1609 
    self.send_getValidOrdersAmountRange()
1610 
    return self.recv_getValidOrdersAmountRange()
1627 ankur.sing 1611 
 
1731 ankur.sing 1612 
  def send_getValidOrdersAmountRange(self, ):
1613 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1614 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 1615 
    args.write(self._oprot)
1616 
    self._oprot.writeMessageEnd()
1617 
    self._oprot.trans.flush()
1618 
 
1731 ankur.sing 1619 
  def recv_getValidOrdersAmountRange(self, ):
1627 ankur.sing 1620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1621 
    if mtype == TMessageType.EXCEPTION:
1622 
      x = TApplicationException()
1623 
      x.read(self._iprot)
1624 
      self._iprot.readMessageEnd()
1625 
      raise x
1731 ankur.sing 1626 
    result = getValidOrdersAmountRange_result()
1627 ankur.sing 1627 
    result.read(self._iprot)
1628 
    self._iprot.readMessageEnd()
1629 
    if result.success != None:
1630 
      return result.success
1731 ankur.sing 1631 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1627 ankur.sing 1632 
 
1886 ankur.sing 1633 
  def getValidOrders(self, limit):
1634 
    """
1635 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1636 
    If limit is passed as 0, then all valid Orders are returned.
1637 
 
1638 
    Parameters:
1639 
     - limit
1640 
    """
1641 
    self.send_getValidOrders(limit)
1642 
    return self.recv_getValidOrders()
1627 ankur.sing 1643 
 
1886 ankur.sing 1644 
  def send_getValidOrders(self, limit):
1645 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1646 
    args = getValidOrders_args()
1647 
    args.limit = limit
1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
1652 
  def recv_getValidOrders(self, ):
1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
1659 
    result = getValidOrders_result()
1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
1662 
    if result.success != None:
1663 
      return result.success
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1665 
 
2536 chandransh 1666 
  def toggleDOAFlag(self, orderId):
1667 
    """
1668 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
1669 
    Returns the final flag status.
1670 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
1671 
 
1672 
    Parameters:
1673 
     - orderId
1674 
    """
1675 
    self.send_toggleDOAFlag(orderId)
1676 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 1677 
 
2536 chandransh 1678 
  def send_toggleDOAFlag(self, orderId):
1679 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
1680 
    args = toggleDOAFlag_args()
1681 
    args.orderId = orderId
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_toggleDOAFlag(self, ):
1687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1688 
    if mtype == TMessageType.EXCEPTION:
1689 
      x = TApplicationException()
1690 
      x.read(self._iprot)
1691 
      self._iprot.readMessageEnd()
1692 
      raise x
1693 
    result = toggleDOAFlag_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
1696 
    if result.success != None:
1697 
      return result.success
1698 
    if result.ex != None:
1699 
      raise result.ex
1700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
1701 
 
1702 
  def requestPickupNumber(self, orderId):
1703 
    """
1704 
    Sends out an email to the account manager of the original courier provider used to ship the order.
1705 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
1706 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
1707 
    For any other status, it returns false.
1708 
    Throws an exception if the order with the given id couldn't be found.
1709 
 
1710 
    Parameters:
1711 
     - orderId
1712 
    """
1713 
    self.send_requestPickupNumber(orderId)
1714 
    return self.recv_requestPickupNumber()
1715 
 
1716 
  def send_requestPickupNumber(self, orderId):
1717 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
1718 
    args = requestPickupNumber_args()
1719 
    args.orderId = orderId
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_requestPickupNumber(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = requestPickupNumber_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
1734 
    if result.success != None:
1735 
      return result.success
1736 
    if result.ex != None:
1737 
      raise result.ex
1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
1739 
 
1740 
  def authorizePickup(self, orderId, pickupNumber):
1741 
    """
1742 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
1743 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
1744 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
1745 
    	3. Returns true
1746 
    If the order is any other status, it returns false.
1747 
    Throws an exception if the order with the given id couldn't be found.
1748 
 
1749 
    Parameters:
1750 
     - orderId
1751 
     - pickupNumber
1752 
    """
1753 
    self.send_authorizePickup(orderId, pickupNumber)
1754 
    return self.recv_authorizePickup()
1755 
 
1756 
  def send_authorizePickup(self, orderId, pickupNumber):
1757 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
1758 
    args = authorizePickup_args()
1759 
    args.orderId = orderId
1760 
    args.pickupNumber = pickupNumber
1761 
    args.write(self._oprot)
1762 
    self._oprot.writeMessageEnd()
1763 
    self._oprot.trans.flush()
1764 
 
1765 
  def recv_authorizePickup(self, ):
1766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1767 
    if mtype == TMessageType.EXCEPTION:
1768 
      x = TApplicationException()
1769 
      x.read(self._iprot)
1770 
      self._iprot.readMessageEnd()
1771 
      raise x
1772 
    result = authorizePickup_result()
1773 
    result.read(self._iprot)
1774 
    self._iprot.readMessageEnd()
1775 
    if result.success != None:
1776 
      return result.success
1777 
    if result.ex != None:
1778 
      raise result.ex
1779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
1780 
 
1781 
 
94 ashish 1782 
class Processor(Iface, TProcessor):
1783 
  def __init__(self, handler):
1784 
    self._handler = handler
1785 
    self._processMap = {}
765 rajveer 1786 
    self._processMap["closeSession"] = Processor.process_closeSession
94 ashish 1787 
    self._processMap["createTransaction"] = Processor.process_createTransaction
1788 
    self._processMap["getTransaction"] = Processor.process_getTransaction
1789 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 1790 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 1791 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
1792 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 1793 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 1794 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 1795 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
1382 varun.gupt 1796 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
1797 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 1798 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 1799 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
1149 chandransh 1800 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
921 rajveer 1801 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
1802 
    self._processMap["billOrder"] = Processor.process_billOrder
483 rajveer 1803 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
1804 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
1805 
    self._processMap["createOrder"] = Processor.process_createOrder
1806 
    self._processMap["getOrder"] = Processor.process_getOrder
1807 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 1808 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
1220 chandransh 1809 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 1810 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
759 chandransh 1811 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 1812 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 1813 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 1814 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 1815 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 1816 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
304 ashish 1817 
    self._processMap["getAlerts"] = Processor.process_getAlerts
1818 
    self._processMap["setAlert"] = Processor.process_setAlert
1596 ankur.sing 1819 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
1627 ankur.sing 1820 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
1731 ankur.sing 1821 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
1886 ankur.sing 1822 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
2536 chandransh 1823 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
1824 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
1825 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
94 ashish 1826 
 
1827 
  def process(self, iprot, oprot):
1828 
    (name, type, seqid) = iprot.readMessageBegin()
1829 
    if name not in self._processMap:
1830 
      iprot.skip(TType.STRUCT)
1831 
      iprot.readMessageEnd()
1832 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
1833 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
1834 
      x.write(oprot)
1835 
      oprot.writeMessageEnd()
1836 
      oprot.trans.flush()
1837 
      return
1838 
    else:
1839 
      self._processMap[name](self, seqid, iprot, oprot)
1840 
    return True
1841 
 
765 rajveer 1842 
  def process_closeSession(self, seqid, iprot, oprot):
1843 
    args = closeSession_args()
1844 
    args.read(iprot)
1845 
    iprot.readMessageEnd()
1846 
    result = closeSession_result()
1847 
    self._handler.closeSession()
1848 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
1849 
    result.write(oprot)
1850 
    oprot.writeMessageEnd()
1851 
    oprot.trans.flush()
1852 
 
94 ashish 1853 
  def process_createTransaction(self, seqid, iprot, oprot):
1854 
    args = createTransaction_args()
1855 
    args.read(iprot)
1856 
    iprot.readMessageEnd()
1857 
    result = createTransaction_result()
1858 
    try:
132 ashish 1859 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 1860 
    except TransactionServiceException, ex:
1861 
      result.ex = ex
1862 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
1863 
    result.write(oprot)
1864 
    oprot.writeMessageEnd()
1865 
    oprot.trans.flush()
1866 
 
1867 
  def process_getTransaction(self, seqid, iprot, oprot):
1868 
    args = getTransaction_args()
1869 
    args.read(iprot)
1870 
    iprot.readMessageEnd()
1871 
    result = getTransaction_result()
1872 
    try:
1873 
      result.success = self._handler.getTransaction(args.id)
1874 
    except TransactionServiceException, ex:
1875 
      result.ex = ex
1876 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
1877 
    result.write(oprot)
1878 
    oprot.writeMessageEnd()
1879 
    oprot.trans.flush()
1880 
 
1881 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
1882 
    args = getTransactionsForCustomer_args()
1883 
    args.read(iprot)
1884 
    iprot.readMessageEnd()
1885 
    result = getTransactionsForCustomer_result()
1886 
    try:
1887 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
1888 
    except TransactionServiceException, ex:
1889 
      result.ex = ex
1890 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
1891 
    result.write(oprot)
1892 
    oprot.writeMessageEnd()
1893 
    oprot.trans.flush()
1894 
 
132 ashish 1895 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
1896 
    args = getTransactionsForShoppingCartId_args()
1897 
    args.read(iprot)
1898 
    iprot.readMessageEnd()
1899 
    result = getTransactionsForShoppingCartId_result()
1900 
    try:
1901 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
1902 
    except TransactionServiceException, ex:
1903 
      result.ex = ex
1904 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
1905 
    result.write(oprot)
1906 
    oprot.writeMessageEnd()
1907 
    oprot.trans.flush()
1908 
 
94 ashish 1909 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
1910 
    args = getTransactionStatus_args()
1911 
    args.read(iprot)
1912 
    iprot.readMessageEnd()
1913 
    result = getTransactionStatus_result()
1914 
    try:
1915 
      result.success = self._handler.getTransactionStatus(args.transactionId)
1916 
    except TransactionServiceException, ex:
1917 
      result.ex = ex
1918 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
1919 
    result.write(oprot)
1920 
    oprot.writeMessageEnd()
1921 
    oprot.trans.flush()
1922 
 
1923 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
1924 
    args = changeTransactionStatus_args()
1925 
    args.read(iprot)
1926 
    iprot.readMessageEnd()
1927 
    result = changeTransactionStatus_result()
1928 
    try:
1929 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
1930 
    except TransactionServiceException, ex:
1931 
      result.ex = ex
1932 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
1933 
    result.write(oprot)
1934 
    oprot.writeMessageEnd()
1935 
    oprot.trans.flush()
1936 
 
1398 varun.gupt 1937 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
1938 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1939 
    args.read(iprot)
1940 
    iprot.readMessageEnd()
1398 varun.gupt 1941 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1942 
    try:
1398 varun.gupt 1943 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 1944 
    except TransactionServiceException, ex:
1945 
      result.ex = ex
1398 varun.gupt 1946 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 1947 
    result.write(oprot)
1948 
    oprot.writeMessageEnd()
1949 
    oprot.trans.flush()
1950 
 
483 rajveer 1951 
  def process_getAllOrders(self, seqid, iprot, oprot):
1952 
    args = getAllOrders_args()
94 ashish 1953 
    args.read(iprot)
1954 
    iprot.readMessageEnd()
483 rajveer 1955 
    result = getAllOrders_result()
94 ashish 1956 
    try:
483 rajveer 1957 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 1958 
    except TransactionServiceException, ex:
1959 
      result.ex = ex
483 rajveer 1960 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 1961 
    result.write(oprot)
1962 
    oprot.writeMessageEnd()
1963 
    oprot.trans.flush()
1964 
 
999 varun.gupt 1965 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
1966 
    args = getOrdersByBillingDate_args()
1967 
    args.read(iprot)
1968 
    iprot.readMessageEnd()
1969 
    result = getOrdersByBillingDate_result()
1970 
    try:
1971 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
1972 
    except TransactionServiceException, ex:
1973 
      result.ex = ex
1974 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
1975 
    result.write(oprot)
1976 
    oprot.writeMessageEnd()
1977 
    oprot.trans.flush()
1978 
 
1382 varun.gupt 1979 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
1980 
    args = getReturnableOrdersForCustomer_args()
1981 
    args.read(iprot)
1982 
    iprot.readMessageEnd()
1983 
    result = getReturnableOrdersForCustomer_result()
1984 
    try:
1985 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
1986 
    except TransactionServiceException, ex:
1987 
      result.ex = ex
1988 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
1989 
    result.write(oprot)
1990 
    oprot.writeMessageEnd()
1991 
    oprot.trans.flush()
1992 
 
1993 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
1994 
    args = getCancellableOrdersForCustomer_args()
1995 
    args.read(iprot)
1996 
    iprot.readMessageEnd()
1997 
    result = getCancellableOrdersForCustomer_result()
1998 
    try:
1999 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
2000 
    except TransactionServiceException, ex:
2001 
      result.ex = ex
2002 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
2003 
    result.write(oprot)
2004 
    oprot.writeMessageEnd()
2005 
    oprot.trans.flush()
2006 
 
483 rajveer 2007 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
2008 
    args = changeOrderStatus_args()
94 ashish 2009 
    args.read(iprot)
2010 
    iprot.readMessageEnd()
483 rajveer 2011 
    result = changeOrderStatus_result()
94 ashish 2012 
    try:
483 rajveer 2013 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 2014 
    except TransactionServiceException, ex:
2015 
      result.ex = ex
483 rajveer 2016 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 2017 
    result.write(oprot)
2018 
    oprot.writeMessageEnd()
2019 
    oprot.trans.flush()
2020 
 
494 rajveer 2021 
  def process_addBillingDetails(self, seqid, iprot, oprot):
2022 
    args = addBillingDetails_args()
2023 
    args.read(iprot)
2024 
    iprot.readMessageEnd()
2025 
    result = addBillingDetails_result()
2026 
    try:
1149 chandransh 2027 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
494 rajveer 2028 
    except TransactionServiceException, ex:
2029 
      result.ex = ex
2030 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
2031 
    result.write(oprot)
2032 
    oprot.writeMessageEnd()
2033 
    oprot.trans.flush()
2034 
 
1149 chandransh 2035 
  def process_addJacketNumber(self, seqid, iprot, oprot):
2036 
    args = addJacketNumber_args()
2037 
    args.read(iprot)
2038 
    iprot.readMessageEnd()
2039 
    result = addJacketNumber_result()
2040 
    try:
2041 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber)
2042 
    except TransactionServiceException, ex:
2043 
      result.ex = ex
2044 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
2045 
    result.write(oprot)
2046 
    oprot.writeMessageEnd()
2047 
    oprot.trans.flush()
2048 
 
921 rajveer 2049 
  def process_acceptOrder(self, seqid, iprot, oprot):
2050 
    args = acceptOrder_args()
2051 
    args.read(iprot)
2052 
    iprot.readMessageEnd()
2053 
    result = acceptOrder_result()
2054 
    try:
2055 
      result.success = self._handler.acceptOrder(args.orderId)
2056 
    except TransactionServiceException, ex:
2057 
      result.ex = ex
2058 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
2059 
    result.write(oprot)
2060 
    oprot.writeMessageEnd()
2061 
    oprot.trans.flush()
2062 
 
2063 
  def process_billOrder(self, seqid, iprot, oprot):
2064 
    args = billOrder_args()
2065 
    args.read(iprot)
2066 
    iprot.readMessageEnd()
2067 
    result = billOrder_result()
2068 
    try:
2069 
      result.success = self._handler.billOrder(args.orderId)
2070 
    except TransactionServiceException, ex:
2071 
      result.ex = ex
2072 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
2073 
    result.write(oprot)
2074 
    oprot.writeMessageEnd()
2075 
    oprot.trans.flush()
2076 
 
483 rajveer 2077 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
2078 
    args = getOrdersForTransaction_args()
94 ashish 2079 
    args.read(iprot)
2080 
    iprot.readMessageEnd()
483 rajveer 2081 
    result = getOrdersForTransaction_result()
94 ashish 2082 
    try:
1528 ankur.sing 2083 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 2084 
    except TransactionServiceException, ex:
2085 
      result.ex = ex
483 rajveer 2086 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 2087 
    result.write(oprot)
2088 
    oprot.writeMessageEnd()
2089 
    oprot.trans.flush()
2090 
 
483 rajveer 2091 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
2092 
    args = getOrdersForCustomer_args()
94 ashish 2093 
    args.read(iprot)
2094 
    iprot.readMessageEnd()
483 rajveer 2095 
    result = getOrdersForCustomer_result()
94 ashish 2096 
    try:
483 rajveer 2097 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status)
94 ashish 2098 
    except TransactionServiceException, ex:
2099 
      result.ex = ex
483 rajveer 2100 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 2101 
    result.write(oprot)
2102 
    oprot.writeMessageEnd()
2103 
    oprot.trans.flush()
2104 
 
483 rajveer 2105 
  def process_createOrder(self, seqid, iprot, oprot):
2106 
    args = createOrder_args()
94 ashish 2107 
    args.read(iprot)
2108 
    iprot.readMessageEnd()
483 rajveer 2109 
    result = createOrder_result()
94 ashish 2110 
    try:
483 rajveer 2111 
      result.success = self._handler.createOrder(args.order)
94 ashish 2112 
    except TransactionServiceException, ex:
2113 
      result.ex = ex
483 rajveer 2114 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 2115 
    result.write(oprot)
2116 
    oprot.writeMessageEnd()
2117 
    oprot.trans.flush()
2118 
 
483 rajveer 2119 
  def process_getOrder(self, seqid, iprot, oprot):
2120 
    args = getOrder_args()
94 ashish 2121 
    args.read(iprot)
2122 
    iprot.readMessageEnd()
483 rajveer 2123 
    result = getOrder_result()
94 ashish 2124 
    try:
483 rajveer 2125 
      result.success = self._handler.getOrder(args.id)
94 ashish 2126 
    except TransactionServiceException, ex:
2127 
      result.ex = ex
483 rajveer 2128 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 2129 
    result.write(oprot)
2130 
    oprot.writeMessageEnd()
2131 
    oprot.trans.flush()
2132 
 
483 rajveer 2133 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
2134 
    args = getLineItemsForOrder_args()
94 ashish 2135 
    args.read(iprot)
2136 
    iprot.readMessageEnd()
483 rajveer 2137 
    result = getLineItemsForOrder_result()
94 ashish 2138 
    try:
483 rajveer 2139 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 2140 
    except TransactionServiceException, ex:
2141 
      result.ex = ex
483 rajveer 2142 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 2143 
    result.write(oprot)
2144 
    oprot.writeMessageEnd()
2145 
    oprot.trans.flush()
2146 
 
1528 ankur.sing 2147 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
2148 
    args = getOrderForCustomer_args()
2149 
    args.read(iprot)
2150 
    iprot.readMessageEnd()
2151 
    result = getOrderForCustomer_result()
2152 
    try:
2153 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
2154 
    except TransactionServiceException, ex:
2155 
      result.ex = ex
2156 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
2157 
    result.write(oprot)
2158 
    oprot.writeMessageEnd()
2159 
    oprot.trans.flush()
2160 
 
1220 chandransh 2161 
  def process_batchOrders(self, seqid, iprot, oprot):
2162 
    args = batchOrders_args()
2163 
    args.read(iprot)
2164 
    iprot.readMessageEnd()
2165 
    result = batchOrders_result()
2166 
    try:
2167 
      result.success = self._handler.batchOrders(args.warehouseId)
2168 
    except TransactionServiceException, ex:
2169 
      result.ex = ex
2170 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
2171 
    result.write(oprot)
2172 
    oprot.writeMessageEnd()
2173 
    oprot.trans.flush()
2174 
 
1208 chandransh 2175 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
2176 
    args = markOrderAsOutOfStock_args()
2177 
    args.read(iprot)
2178 
    iprot.readMessageEnd()
2179 
    result = markOrderAsOutOfStock_result()
2180 
    try:
2181 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
2182 
    except TransactionServiceException, ex:
2183 
      result.ex = ex
2184 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
2185 
    result.write(oprot)
2186 
    oprot.writeMessageEnd()
2187 
    oprot.trans.flush()
2188 
 
759 chandransh 2189 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
2190 
    args = markOrdersAsManifested_args()
2191 
    args.read(iprot)
2192 
    iprot.readMessageEnd()
2193 
    result = markOrdersAsManifested_result()
2194 
    try:
2195 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
2196 
    except TransactionServiceException, ex:
2197 
      result.ex = ex
2198 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
2199 
    result.write(oprot)
2200 
    oprot.writeMessageEnd()
2201 
    oprot.trans.flush()
2202 
 
1113 chandransh 2203 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
2204 
    args = markOrdersAsPickedUp_args()
2205 
    args.read(iprot)
2206 
    iprot.readMessageEnd()
2207 
    result = markOrdersAsPickedUp_result()
2208 
    try:
2209 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
2210 
    except TransactionServiceException, ex:
2211 
      result.ex = ex
2212 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
2213 
    result.write(oprot)
2214 
    oprot.writeMessageEnd()
2215 
    oprot.trans.flush()
2216 
 
1132 chandransh 2217 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
2218 
    args = markOrdersAsDelivered_args()
2219 
    args.read(iprot)
2220 
    iprot.readMessageEnd()
2221 
    result = markOrdersAsDelivered_result()
2222 
    try:
2223 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
2224 
    except TransactionServiceException, ex:
2225 
      result.ex = ex
2226 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
2227 
    result.write(oprot)
2228 
    oprot.writeMessageEnd()
2229 
    oprot.trans.flush()
2230 
 
1135 chandransh 2231 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
2232 
    args = markOrdersAsFailed_args()
2233 
    args.read(iprot)
2234 
    iprot.readMessageEnd()
2235 
    result = markOrdersAsFailed_result()
2236 
    try:
2237 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
2238 
    except TransactionServiceException, ex:
2239 
      result.ex = ex
2240 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
2241 
    result.write(oprot)
2242 
    oprot.writeMessageEnd()
2243 
    oprot.trans.flush()
2244 
 
1246 chandransh 2245 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
2246 
    args = updateNonDeliveryReason_args()
2247 
    args.read(iprot)
2248 
    iprot.readMessageEnd()
2249 
    result = updateNonDeliveryReason_result()
2250 
    try:
2251 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
2252 
    except TransactionServiceException, ex:
2253 
      result.ex = ex
2254 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
2255 
    result.write(oprot)
2256 
    oprot.writeMessageEnd()
2257 
    oprot.trans.flush()
2258 
 
1408 ankur.sing 2259 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
2260 
    args = getUndeliveredOrders_args()
2261 
    args.read(iprot)
2262 
    iprot.readMessageEnd()
2263 
    result = getUndeliveredOrders_result()
2264 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
2265 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
2266 
    result.write(oprot)
2267 
    oprot.writeMessageEnd()
2268 
    oprot.trans.flush()
2269 
 
304 ashish 2270 
  def process_getAlerts(self, seqid, iprot, oprot):
2271 
    args = getAlerts_args()
2272 
    args.read(iprot)
2273 
    iprot.readMessageEnd()
2274 
    result = getAlerts_result()
483 rajveer 2275 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 2276 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
2277 
    result.write(oprot)
2278 
    oprot.writeMessageEnd()
2279 
    oprot.trans.flush()
94 ashish 2280 
 
304 ashish 2281 
  def process_setAlert(self, seqid, iprot, oprot):
2282 
    args = setAlert_args()
2283 
    args.read(iprot)
2284 
    iprot.readMessageEnd()
2285 
    result = setAlert_result()
483 rajveer 2286 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 2287 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
2288 
    result.write(oprot)
2289 
    oprot.writeMessageEnd()
2290 
    oprot.trans.flush()
2291 
 
1596 ankur.sing 2292 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
2293 
    args = getValidOrderCount_args()
2294 
    args.read(iprot)
2295 
    iprot.readMessageEnd()
2296 
    result = getValidOrderCount_result()
2297 
    result.success = self._handler.getValidOrderCount()
2298 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
2299 
    result.write(oprot)
2300 
    oprot.writeMessageEnd()
2301 
    oprot.trans.flush()
304 ashish 2302 
 
1627 ankur.sing 2303 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
2304 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2305 
    args.read(iprot)
2306 
    iprot.readMessageEnd()
2307 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2308 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
2309 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
2310 
    result.write(oprot)
2311 
    oprot.writeMessageEnd()
2312 
    oprot.trans.flush()
1596 ankur.sing 2313 
 
1731 ankur.sing 2314 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
2315 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 2316 
    args.read(iprot)
2317 
    iprot.readMessageEnd()
1731 ankur.sing 2318 
    result = getValidOrdersAmountRange_result()
2319 
    result.success = self._handler.getValidOrdersAmountRange()
2320 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
1627 ankur.sing 2321 
    result.write(oprot)
2322 
    oprot.writeMessageEnd()
2323 
    oprot.trans.flush()
2324 
 
1886 ankur.sing 2325 
  def process_getValidOrders(self, seqid, iprot, oprot):
2326 
    args = getValidOrders_args()
2327 
    args.read(iprot)
2328 
    iprot.readMessageEnd()
2329 
    result = getValidOrders_result()
2330 
    result.success = self._handler.getValidOrders(args.limit)
2331 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
2332 
    result.write(oprot)
2333 
    oprot.writeMessageEnd()
2334 
    oprot.trans.flush()
1627 ankur.sing 2335 
 
2536 chandransh 2336 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
2337 
    args = toggleDOAFlag_args()
2338 
    args.read(iprot)
2339 
    iprot.readMessageEnd()
2340 
    result = toggleDOAFlag_result()
2341 
    try:
2342 
      result.success = self._handler.toggleDOAFlag(args.orderId)
2343 
    except TransactionServiceException, ex:
2344 
      result.ex = ex
2345 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
2346 
    result.write(oprot)
2347 
    oprot.writeMessageEnd()
2348 
    oprot.trans.flush()
1886 ankur.sing 2349 
 
2536 chandransh 2350 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
2351 
    args = requestPickupNumber_args()
2352 
    args.read(iprot)
2353 
    iprot.readMessageEnd()
2354 
    result = requestPickupNumber_result()
2355 
    try:
2356 
      result.success = self._handler.requestPickupNumber(args.orderId)
2357 
    except TransactionServiceException, ex:
2358 
      result.ex = ex
2359 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
2360 
    result.write(oprot)
2361 
    oprot.writeMessageEnd()
2362 
    oprot.trans.flush()
2363 
 
2364 
  def process_authorizePickup(self, seqid, iprot, oprot):
2365 
    args = authorizePickup_args()
2366 
    args.read(iprot)
2367 
    iprot.readMessageEnd()
2368 
    result = authorizePickup_result()
2369 
    try:
2370 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
2371 
    except TransactionServiceException, ex:
2372 
      result.ex = ex
2373 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
2374 
    result.write(oprot)
2375 
    oprot.writeMessageEnd()
2376 
    oprot.trans.flush()
2377 
 
2378 
 
94 ashish 2379 
# HELPER FUNCTIONS AND STRUCTURES
2380 
 
765 rajveer 2381 
class closeSession_args:
2382 
 
2383 
  thrift_spec = (
2384 
  )
2385 
 
2386 
  def read(self, iprot):
2387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2389 
      return
2390 
    iprot.readStructBegin()
2391 
    while True:
2392 
      (fname, ftype, fid) = iprot.readFieldBegin()
2393 
      if ftype == TType.STOP:
2394 
        break
2395 
      else:
2396 
        iprot.skip(ftype)
2397 
      iprot.readFieldEnd()
2398 
    iprot.readStructEnd()
2399 
 
2400 
  def write(self, oprot):
2401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2403 
      return
2404 
    oprot.writeStructBegin('closeSession_args')
2405 
    oprot.writeFieldStop()
2406 
    oprot.writeStructEnd()
2407 
 
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 closeSession_result:
2420 
 
2421 
  thrift_spec = (
2422 
  )
2423 
 
2424 
  def read(self, iprot):
2425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2427 
      return
2428 
    iprot.readStructBegin()
2429 
    while True:
2430 
      (fname, ftype, fid) = iprot.readFieldBegin()
2431 
      if ftype == TType.STOP:
2432 
        break
2433 
      else:
2434 
        iprot.skip(ftype)
2435 
      iprot.readFieldEnd()
2436 
    iprot.readStructEnd()
2437 
 
2438 
  def write(self, oprot):
2439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2441 
      return
2442 
    oprot.writeStructBegin('closeSession_result')
2443 
    oprot.writeFieldStop()
2444 
    oprot.writeStructEnd()
2445 
 
2446 
  def __repr__(self):
2447 
    L = ['%s=%r' % (key, value)
2448 
      for key, value in self.__dict__.iteritems()]
2449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2450 
 
2451 
  def __eq__(self, other):
2452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2453 
 
2454 
  def __ne__(self, other):
2455 
    return not (self == other)
2456 
 
94 ashish 2457 
class createTransaction_args:
2458 
  """
2459 
  Attributes:
2460 
   - transaction
2461 
  """
2462 
 
2463 
  thrift_spec = (
2464 
    None, # 0
2465 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
2466 
  )
2467 
 
2468 
  def __init__(self, transaction=None,):
2469 
    self.transaction = transaction
2470 
 
2471 
  def read(self, iprot):
2472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2474 
      return
2475 
    iprot.readStructBegin()
2476 
    while True:
2477 
      (fname, ftype, fid) = iprot.readFieldBegin()
2478 
      if ftype == TType.STOP:
2479 
        break
2480 
      if fid == 1:
2481 
        if ftype == TType.STRUCT:
2482 
          self.transaction = Transaction()
2483 
          self.transaction.read(iprot)
2484 
        else:
2485 
          iprot.skip(ftype)
2486 
      else:
2487 
        iprot.skip(ftype)
2488 
      iprot.readFieldEnd()
2489 
    iprot.readStructEnd()
2490 
 
2491 
  def write(self, oprot):
2492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2494 
      return
2495 
    oprot.writeStructBegin('createTransaction_args')
2496 
    if self.transaction != None:
2497 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
2498 
      self.transaction.write(oprot)
2499 
      oprot.writeFieldEnd()
2500 
    oprot.writeFieldStop()
2501 
    oprot.writeStructEnd()
2502 
 
2503 
  def __repr__(self):
2504 
    L = ['%s=%r' % (key, value)
2505 
      for key, value in self.__dict__.iteritems()]
2506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2507 
 
2508 
  def __eq__(self, other):
2509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2510 
 
2511 
  def __ne__(self, other):
2512 
    return not (self == other)
2513 
 
2514 
class createTransaction_result:
2515 
  """
2516 
  Attributes:
132 ashish 2517 
   - success
94 ashish 2518 
   - ex
2519 
  """
2520 
 
2521 
  thrift_spec = (
132 ashish 2522 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 2523 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2524 
  )
2525 
 
132 ashish 2526 
  def __init__(self, success=None, ex=None,):
2527 
    self.success = success
94 ashish 2528 
    self.ex = ex
2529 
 
2530 
  def read(self, iprot):
2531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2533 
      return
2534 
    iprot.readStructBegin()
2535 
    while True:
2536 
      (fname, ftype, fid) = iprot.readFieldBegin()
2537 
      if ftype == TType.STOP:
2538 
        break
132 ashish 2539 
      if fid == 0:
2540 
        if ftype == TType.I64:
2541 
          self.success = iprot.readI64();
2542 
        else:
2543 
          iprot.skip(ftype)
2544 
      elif fid == 1:
94 ashish 2545 
        if ftype == TType.STRUCT:
2546 
          self.ex = TransactionServiceException()
2547 
          self.ex.read(iprot)
2548 
        else:
2549 
          iprot.skip(ftype)
2550 
      else:
2551 
        iprot.skip(ftype)
2552 
      iprot.readFieldEnd()
2553 
    iprot.readStructEnd()
2554 
 
2555 
  def write(self, oprot):
2556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2558 
      return
2559 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 2560 
    if self.success != None:
2561 
      oprot.writeFieldBegin('success', TType.I64, 0)
2562 
      oprot.writeI64(self.success)
2563 
      oprot.writeFieldEnd()
94 ashish 2564 
    if self.ex != None:
2565 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2566 
      self.ex.write(oprot)
2567 
      oprot.writeFieldEnd()
2568 
    oprot.writeFieldStop()
2569 
    oprot.writeStructEnd()
2570 
 
2571 
  def __repr__(self):
2572 
    L = ['%s=%r' % (key, value)
2573 
      for key, value in self.__dict__.iteritems()]
2574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2575 
 
2576 
  def __eq__(self, other):
2577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2578 
 
2579 
  def __ne__(self, other):
2580 
    return not (self == other)
2581 
 
2582 
class getTransaction_args:
2583 
  """
2584 
  Attributes:
2585 
   - id
2586 
  """
2587 
 
2588 
  thrift_spec = (
2589 
    None, # 0
2590 
    (1, TType.I64, 'id', None, None, ), # 1
2591 
  )
2592 
 
2593 
  def __init__(self, id=None,):
2594 
    self.id = id
2595 
 
2596 
  def read(self, iprot):
2597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2599 
      return
2600 
    iprot.readStructBegin()
2601 
    while True:
2602 
      (fname, ftype, fid) = iprot.readFieldBegin()
2603 
      if ftype == TType.STOP:
2604 
        break
2605 
      if fid == 1:
2606 
        if ftype == TType.I64:
2607 
          self.id = iprot.readI64();
2608 
        else:
2609 
          iprot.skip(ftype)
2610 
      else:
2611 
        iprot.skip(ftype)
2612 
      iprot.readFieldEnd()
2613 
    iprot.readStructEnd()
2614 
 
2615 
  def write(self, oprot):
2616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2618 
      return
2619 
    oprot.writeStructBegin('getTransaction_args')
2620 
    if self.id != None:
2621 
      oprot.writeFieldBegin('id', TType.I64, 1)
2622 
      oprot.writeI64(self.id)
2623 
      oprot.writeFieldEnd()
2624 
    oprot.writeFieldStop()
2625 
    oprot.writeStructEnd()
2626 
 
2627 
  def __repr__(self):
2628 
    L = ['%s=%r' % (key, value)
2629 
      for key, value in self.__dict__.iteritems()]
2630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2631 
 
2632 
  def __eq__(self, other):
2633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2634 
 
2635 
  def __ne__(self, other):
2636 
    return not (self == other)
2637 
 
2638 
class getTransaction_result:
2639 
  """
2640 
  Attributes:
2641 
   - success
2642 
   - ex
2643 
  """
2644 
 
2645 
  thrift_spec = (
2646 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
2647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2648 
  )
2649 
 
2650 
  def __init__(self, success=None, ex=None,):
2651 
    self.success = success
2652 
    self.ex = ex
2653 
 
2654 
  def read(self, iprot):
2655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2657 
      return
2658 
    iprot.readStructBegin()
2659 
    while True:
2660 
      (fname, ftype, fid) = iprot.readFieldBegin()
2661 
      if ftype == TType.STOP:
2662 
        break
2663 
      if fid == 0:
2664 
        if ftype == TType.STRUCT:
2665 
          self.success = Transaction()
2666 
          self.success.read(iprot)
2667 
        else:
2668 
          iprot.skip(ftype)
2669 
      elif fid == 1:
2670 
        if ftype == TType.STRUCT:
2671 
          self.ex = TransactionServiceException()
2672 
          self.ex.read(iprot)
2673 
        else:
2674 
          iprot.skip(ftype)
2675 
      else:
2676 
        iprot.skip(ftype)
2677 
      iprot.readFieldEnd()
2678 
    iprot.readStructEnd()
2679 
 
2680 
  def write(self, oprot):
2681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2683 
      return
2684 
    oprot.writeStructBegin('getTransaction_result')
2685 
    if self.success != None:
2686 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
2687 
      self.success.write(oprot)
2688 
      oprot.writeFieldEnd()
2689 
    if self.ex != None:
2690 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2691 
      self.ex.write(oprot)
2692 
      oprot.writeFieldEnd()
2693 
    oprot.writeFieldStop()
2694 
    oprot.writeStructEnd()
2695 
 
2696 
  def __repr__(self):
2697 
    L = ['%s=%r' % (key, value)
2698 
      for key, value in self.__dict__.iteritems()]
2699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2700 
 
2701 
  def __eq__(self, other):
2702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2703 
 
2704 
  def __ne__(self, other):
2705 
    return not (self == other)
2706 
 
2707 
class getTransactionsForCustomer_args:
2708 
  """
2709 
  Attributes:
2710 
   - customerId
2711 
   - from_date
2712 
   - to_date
2713 
   - status
2714 
  """
2715 
 
2716 
  thrift_spec = (
2717 
    None, # 0
2718 
    (1, TType.I64, 'customerId', None, None, ), # 1
2719 
    (2, TType.I64, 'from_date', None, None, ), # 2
2720 
    (3, TType.I64, 'to_date', None, None, ), # 3
2721 
    (4, TType.I32, 'status', None, None, ), # 4
2722 
  )
2723 
 
2724 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
2725 
    self.customerId = customerId
2726 
    self.from_date = from_date
2727 
    self.to_date = to_date
2728 
    self.status = status
2729 
 
2730 
  def read(self, iprot):
2731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2733 
      return
2734 
    iprot.readStructBegin()
2735 
    while True:
2736 
      (fname, ftype, fid) = iprot.readFieldBegin()
2737 
      if ftype == TType.STOP:
2738 
        break
2739 
      if fid == 1:
2740 
        if ftype == TType.I64:
2741 
          self.customerId = iprot.readI64();
2742 
        else:
2743 
          iprot.skip(ftype)
2744 
      elif fid == 2:
2745 
        if ftype == TType.I64:
2746 
          self.from_date = iprot.readI64();
2747 
        else:
2748 
          iprot.skip(ftype)
2749 
      elif fid == 3:
2750 
        if ftype == TType.I64:
2751 
          self.to_date = iprot.readI64();
2752 
        else:
2753 
          iprot.skip(ftype)
2754 
      elif fid == 4:
2755 
        if ftype == TType.I32:
2756 
          self.status = iprot.readI32();
2757 
        else:
2758 
          iprot.skip(ftype)
2759 
      else:
2760 
        iprot.skip(ftype)
2761 
      iprot.readFieldEnd()
2762 
    iprot.readStructEnd()
2763 
 
2764 
  def write(self, oprot):
2765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2767 
      return
2768 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
2769 
    if self.customerId != None:
2770 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
2771 
      oprot.writeI64(self.customerId)
2772 
      oprot.writeFieldEnd()
2773 
    if self.from_date != None:
2774 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
2775 
      oprot.writeI64(self.from_date)
2776 
      oprot.writeFieldEnd()
2777 
    if self.to_date != None:
2778 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
2779 
      oprot.writeI64(self.to_date)
2780 
      oprot.writeFieldEnd()
2781 
    if self.status != None:
2782 
      oprot.writeFieldBegin('status', TType.I32, 4)
2783 
      oprot.writeI32(self.status)
2784 
      oprot.writeFieldEnd()
2785 
    oprot.writeFieldStop()
2786 
    oprot.writeStructEnd()
2787 
 
2788 
  def __repr__(self):
2789 
    L = ['%s=%r' % (key, value)
2790 
      for key, value in self.__dict__.iteritems()]
2791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2792 
 
2793 
  def __eq__(self, other):
2794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2795 
 
2796 
  def __ne__(self, other):
2797 
    return not (self == other)
2798 
 
2799 
class getTransactionsForCustomer_result:
2800 
  """
2801 
  Attributes:
2802 
   - success
2803 
   - ex
2804 
  """
2805 
 
2806 
  thrift_spec = (
2807 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
2808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2809 
  )
2810 
 
2811 
  def __init__(self, success=None, ex=None,):
2812 
    self.success = success
2813 
    self.ex = ex
2814 
 
2815 
  def read(self, iprot):
2816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2818 
      return
2819 
    iprot.readStructBegin()
2820 
    while True:
2821 
      (fname, ftype, fid) = iprot.readFieldBegin()
2822 
      if ftype == TType.STOP:
2823 
        break
2824 
      if fid == 0:
2825 
        if ftype == TType.LIST:
2826 
          self.success = []
685 chandransh 2827 
          (_etype17, _size14) = iprot.readListBegin()
2828 
          for _i18 in xrange(_size14):
2829 
            _elem19 = Transaction()
2830 
            _elem19.read(iprot)
2831 
            self.success.append(_elem19)
94 ashish 2832 
          iprot.readListEnd()
2833 
        else:
2834 
          iprot.skip(ftype)
2835 
      elif fid == 1:
2836 
        if ftype == TType.STRUCT:
2837 
          self.ex = TransactionServiceException()
2838 
          self.ex.read(iprot)
2839 
        else:
2840 
          iprot.skip(ftype)
2841 
      else:
2842 
        iprot.skip(ftype)
2843 
      iprot.readFieldEnd()
2844 
    iprot.readStructEnd()
2845 
 
2846 
  def write(self, oprot):
2847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2849 
      return
2850 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
2851 
    if self.success != None:
2852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 2854 
      for iter20 in self.success:
2855 
        iter20.write(oprot)
94 ashish 2856 
      oprot.writeListEnd()
2857 
      oprot.writeFieldEnd()
2858 
    if self.ex != None:
2859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2860 
      self.ex.write(oprot)
2861 
      oprot.writeFieldEnd()
2862 
    oprot.writeFieldStop()
2863 
    oprot.writeStructEnd()
2864 
 
2865 
  def __repr__(self):
2866 
    L = ['%s=%r' % (key, value)
2867 
      for key, value in self.__dict__.iteritems()]
2868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2869 
 
2870 
  def __eq__(self, other):
2871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2872 
 
2873 
  def __ne__(self, other):
2874 
    return not (self == other)
2875 
 
132 ashish 2876 
class getTransactionsForShoppingCartId_args:
2877 
  """
2878 
  Attributes:
2879 
   - shoppingCartId
2880 
  """
2881 
 
2882 
  thrift_spec = (
2883 
    None, # 0
2884 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
2885 
  )
2886 
 
2887 
  def __init__(self, shoppingCartId=None,):
2888 
    self.shoppingCartId = shoppingCartId
2889 
 
2890 
  def read(self, iprot):
2891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2893 
      return
2894 
    iprot.readStructBegin()
2895 
    while True:
2896 
      (fname, ftype, fid) = iprot.readFieldBegin()
2897 
      if ftype == TType.STOP:
2898 
        break
2899 
      if fid == 1:
2900 
        if ftype == TType.I64:
2901 
          self.shoppingCartId = iprot.readI64();
2902 
        else:
2903 
          iprot.skip(ftype)
2904 
      else:
2905 
        iprot.skip(ftype)
2906 
      iprot.readFieldEnd()
2907 
    iprot.readStructEnd()
2908 
 
2909 
  def write(self, oprot):
2910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2912 
      return
2913 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
2914 
    if self.shoppingCartId != None:
2915 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
2916 
      oprot.writeI64(self.shoppingCartId)
2917 
      oprot.writeFieldEnd()
2918 
    oprot.writeFieldStop()
2919 
    oprot.writeStructEnd()
2920 
 
2921 
  def __repr__(self):
2922 
    L = ['%s=%r' % (key, value)
2923 
      for key, value in self.__dict__.iteritems()]
2924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2925 
 
2926 
  def __eq__(self, other):
2927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2928 
 
2929 
  def __ne__(self, other):
2930 
    return not (self == other)
2931 
 
2932 
class getTransactionsForShoppingCartId_result:
2933 
  """
2934 
  Attributes:
2935 
   - success
2936 
   - ex
2937 
  """
2938 
 
2939 
  thrift_spec = (
2940 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
2941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2942 
  )
2943 
 
2944 
  def __init__(self, success=None, ex=None,):
2945 
    self.success = success
2946 
    self.ex = ex
2947 
 
2948 
  def read(self, iprot):
2949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2951 
      return
2952 
    iprot.readStructBegin()
2953 
    while True:
2954 
      (fname, ftype, fid) = iprot.readFieldBegin()
2955 
      if ftype == TType.STOP:
2956 
        break
2957 
      if fid == 0:
2958 
        if ftype == TType.LIST:
2959 
          self.success = []
685 chandransh 2960 
          (_etype24, _size21) = iprot.readListBegin()
2961 
          for _i25 in xrange(_size21):
2962 
            _elem26 = Transaction()
2963 
            _elem26.read(iprot)
2964 
            self.success.append(_elem26)
132 ashish 2965 
          iprot.readListEnd()
2966 
        else:
2967 
          iprot.skip(ftype)
2968 
      elif fid == 1:
2969 
        if ftype == TType.STRUCT:
2970 
          self.ex = TransactionServiceException()
2971 
          self.ex.read(iprot)
2972 
        else:
2973 
          iprot.skip(ftype)
2974 
      else:
2975 
        iprot.skip(ftype)
2976 
      iprot.readFieldEnd()
2977 
    iprot.readStructEnd()
2978 
 
2979 
  def write(self, oprot):
2980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2982 
      return
2983 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
2984 
    if self.success != None:
2985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 2987 
      for iter27 in self.success:
2988 
        iter27.write(oprot)
132 ashish 2989 
      oprot.writeListEnd()
2990 
      oprot.writeFieldEnd()
2991 
    if self.ex != None:
2992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
2993 
      self.ex.write(oprot)
2994 
      oprot.writeFieldEnd()
2995 
    oprot.writeFieldStop()
2996 
    oprot.writeStructEnd()
2997 
 
2998 
  def __repr__(self):
2999 
    L = ['%s=%r' % (key, value)
3000 
      for key, value in self.__dict__.iteritems()]
3001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3002 
 
3003 
  def __eq__(self, other):
3004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3005 
 
3006 
  def __ne__(self, other):
3007 
    return not (self == other)
3008 
 
94 ashish 3009 
class getTransactionStatus_args:
3010 
  """
3011 
  Attributes:
3012 
   - transactionId
3013 
  """
3014 
 
3015 
  thrift_spec = (
3016 
    None, # 0
3017 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3018 
  )
3019 
 
3020 
  def __init__(self, transactionId=None,):
3021 
    self.transactionId = transactionId
3022 
 
3023 
  def read(self, iprot):
3024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3026 
      return
3027 
    iprot.readStructBegin()
3028 
    while True:
3029 
      (fname, ftype, fid) = iprot.readFieldBegin()
3030 
      if ftype == TType.STOP:
3031 
        break
3032 
      if fid == 1:
3033 
        if ftype == TType.I64:
3034 
          self.transactionId = iprot.readI64();
3035 
        else:
3036 
          iprot.skip(ftype)
3037 
      else:
3038 
        iprot.skip(ftype)
3039 
      iprot.readFieldEnd()
3040 
    iprot.readStructEnd()
3041 
 
3042 
  def write(self, oprot):
3043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3045 
      return
3046 
    oprot.writeStructBegin('getTransactionStatus_args')
3047 
    if self.transactionId != None:
3048 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3049 
      oprot.writeI64(self.transactionId)
3050 
      oprot.writeFieldEnd()
3051 
    oprot.writeFieldStop()
3052 
    oprot.writeStructEnd()
3053 
 
3054 
  def __repr__(self):
3055 
    L = ['%s=%r' % (key, value)
3056 
      for key, value in self.__dict__.iteritems()]
3057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3058 
 
3059 
  def __eq__(self, other):
3060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3061 
 
3062 
  def __ne__(self, other):
3063 
    return not (self == other)
3064 
 
3065 
class getTransactionStatus_result:
3066 
  """
3067 
  Attributes:
3068 
   - success
3069 
   - ex
3070 
  """
3071 
 
3072 
  thrift_spec = (
3073 
    (0, TType.I32, 'success', None, None, ), # 0
3074 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3075 
  )
3076 
 
3077 
  def __init__(self, success=None, ex=None,):
3078 
    self.success = success
3079 
    self.ex = ex
3080 
 
3081 
  def read(self, iprot):
3082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3084 
      return
3085 
    iprot.readStructBegin()
3086 
    while True:
3087 
      (fname, ftype, fid) = iprot.readFieldBegin()
3088 
      if ftype == TType.STOP:
3089 
        break
3090 
      if fid == 0:
3091 
        if ftype == TType.I32:
3092 
          self.success = iprot.readI32();
3093 
        else:
3094 
          iprot.skip(ftype)
3095 
      elif fid == 1:
3096 
        if ftype == TType.STRUCT:
3097 
          self.ex = TransactionServiceException()
3098 
          self.ex.read(iprot)
3099 
        else:
3100 
          iprot.skip(ftype)
3101 
      else:
3102 
        iprot.skip(ftype)
3103 
      iprot.readFieldEnd()
3104 
    iprot.readStructEnd()
3105 
 
3106 
  def write(self, oprot):
3107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3109 
      return
3110 
    oprot.writeStructBegin('getTransactionStatus_result')
3111 
    if self.success != None:
3112 
      oprot.writeFieldBegin('success', TType.I32, 0)
3113 
      oprot.writeI32(self.success)
3114 
      oprot.writeFieldEnd()
3115 
    if self.ex != None:
3116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3117 
      self.ex.write(oprot)
3118 
      oprot.writeFieldEnd()
3119 
    oprot.writeFieldStop()
3120 
    oprot.writeStructEnd()
3121 
 
3122 
  def __repr__(self):
3123 
    L = ['%s=%r' % (key, value)
3124 
      for key, value in self.__dict__.iteritems()]
3125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3126 
 
3127 
  def __eq__(self, other):
3128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3129 
 
3130 
  def __ne__(self, other):
3131 
    return not (self == other)
3132 
 
3133 
class changeTransactionStatus_args:
3134 
  """
3135 
  Attributes:
3136 
   - transactionId
3137 
   - status
3138 
   - description
3139 
  """
3140 
 
3141 
  thrift_spec = (
3142 
    None, # 0
3143 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3144 
    (2, TType.I32, 'status', None, None, ), # 2
3145 
    (3, TType.STRING, 'description', None, None, ), # 3
3146 
  )
3147 
 
3148 
  def __init__(self, transactionId=None, status=None, description=None,):
3149 
    self.transactionId = transactionId
3150 
    self.status = status
3151 
    self.description = description
3152 
 
3153 
  def read(self, iprot):
3154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3156 
      return
3157 
    iprot.readStructBegin()
3158 
    while True:
3159 
      (fname, ftype, fid) = iprot.readFieldBegin()
3160 
      if ftype == TType.STOP:
3161 
        break
3162 
      if fid == 1:
3163 
        if ftype == TType.I64:
3164 
          self.transactionId = iprot.readI64();
3165 
        else:
3166 
          iprot.skip(ftype)
3167 
      elif fid == 2:
3168 
        if ftype == TType.I32:
3169 
          self.status = iprot.readI32();
3170 
        else:
3171 
          iprot.skip(ftype)
3172 
      elif fid == 3:
3173 
        if ftype == TType.STRING:
3174 
          self.description = iprot.readString();
3175 
        else:
3176 
          iprot.skip(ftype)
3177 
      else:
3178 
        iprot.skip(ftype)
3179 
      iprot.readFieldEnd()
3180 
    iprot.readStructEnd()
3181 
 
3182 
  def write(self, oprot):
3183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3185 
      return
3186 
    oprot.writeStructBegin('changeTransactionStatus_args')
3187 
    if self.transactionId != None:
3188 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3189 
      oprot.writeI64(self.transactionId)
3190 
      oprot.writeFieldEnd()
3191 
    if self.status != None:
3192 
      oprot.writeFieldBegin('status', TType.I32, 2)
3193 
      oprot.writeI32(self.status)
3194 
      oprot.writeFieldEnd()
3195 
    if self.description != None:
3196 
      oprot.writeFieldBegin('description', TType.STRING, 3)
3197 
      oprot.writeString(self.description)
3198 
      oprot.writeFieldEnd()
3199 
    oprot.writeFieldStop()
3200 
    oprot.writeStructEnd()
3201 
 
3202 
  def __repr__(self):
3203 
    L = ['%s=%r' % (key, value)
3204 
      for key, value in self.__dict__.iteritems()]
3205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3206 
 
3207 
  def __eq__(self, other):
3208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3209 
 
3210 
  def __ne__(self, other):
3211 
    return not (self == other)
3212 
 
3213 
class changeTransactionStatus_result:
3214 
  """
3215 
  Attributes:
3216 
   - success
3217 
   - ex
3218 
  """
3219 
 
3220 
  thrift_spec = (
3221 
    (0, TType.BOOL, 'success', None, None, ), # 0
3222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3223 
  )
3224 
 
3225 
  def __init__(self, success=None, ex=None,):
3226 
    self.success = success
3227 
    self.ex = ex
3228 
 
3229 
  def read(self, iprot):
3230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3232 
      return
3233 
    iprot.readStructBegin()
3234 
    while True:
3235 
      (fname, ftype, fid) = iprot.readFieldBegin()
3236 
      if ftype == TType.STOP:
3237 
        break
3238 
      if fid == 0:
3239 
        if ftype == TType.BOOL:
3240 
          self.success = iprot.readBool();
3241 
        else:
3242 
          iprot.skip(ftype)
3243 
      elif fid == 1:
3244 
        if ftype == TType.STRUCT:
3245 
          self.ex = TransactionServiceException()
3246 
          self.ex.read(iprot)
3247 
        else:
3248 
          iprot.skip(ftype)
3249 
      else:
3250 
        iprot.skip(ftype)
3251 
      iprot.readFieldEnd()
3252 
    iprot.readStructEnd()
3253 
 
3254 
  def write(self, oprot):
3255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3257 
      return
3258 
    oprot.writeStructBegin('changeTransactionStatus_result')
3259 
    if self.success != None:
3260 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3261 
      oprot.writeBool(self.success)
3262 
      oprot.writeFieldEnd()
3263 
    if self.ex != None:
3264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3265 
      self.ex.write(oprot)
3266 
      oprot.writeFieldEnd()
3267 
    oprot.writeFieldStop()
3268 
    oprot.writeStructEnd()
3269 
 
3270 
  def __repr__(self):
3271 
    L = ['%s=%r' % (key, value)
3272 
      for key, value in self.__dict__.iteritems()]
3273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3274 
 
3275 
  def __eq__(self, other):
3276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3277 
 
3278 
  def __ne__(self, other):
3279 
    return not (self == other)
3280 
 
1398 varun.gupt 3281 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 3282 
  """
3283 
  Attributes:
3284 
   - transactionId
3285 
  """
3286 
 
3287 
  thrift_spec = (
3288 
    None, # 0
3289 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3290 
  )
3291 
 
3292 
  def __init__(self, transactionId=None,):
3293 
    self.transactionId = transactionId
3294 
 
3295 
  def read(self, iprot):
3296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3298 
      return
3299 
    iprot.readStructBegin()
3300 
    while True:
3301 
      (fname, ftype, fid) = iprot.readFieldBegin()
3302 
      if ftype == TType.STOP:
3303 
        break
3304 
      if fid == 1:
3305 
        if ftype == TType.I64:
3306 
          self.transactionId = iprot.readI64();
3307 
        else:
3308 
          iprot.skip(ftype)
3309 
      else:
3310 
        iprot.skip(ftype)
3311 
      iprot.readFieldEnd()
3312 
    iprot.readStructEnd()
3313 
 
3314 
  def write(self, oprot):
3315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3317 
      return
1398 varun.gupt 3318 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
1382 varun.gupt 3319 
    if self.transactionId != None:
3320 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3321 
      oprot.writeI64(self.transactionId)
3322 
      oprot.writeFieldEnd()
3323 
    oprot.writeFieldStop()
3324 
    oprot.writeStructEnd()
3325 
 
3326 
  def __repr__(self):
3327 
    L = ['%s=%r' % (key, value)
3328 
      for key, value in self.__dict__.iteritems()]
3329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3330 
 
3331 
  def __eq__(self, other):
3332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3333 
 
3334 
  def __ne__(self, other):
3335 
    return not (self == other)
3336 
 
1398 varun.gupt 3337 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 3338 
  """
3339 
  Attributes:
3340 
   - success
3341 
   - ex
3342 
  """
3343 
 
3344 
  thrift_spec = (
3345 
    (0, TType.BOOL, 'success', None, None, ), # 0
3346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3347 
  )
3348 
 
3349 
  def __init__(self, success=None, ex=None,):
3350 
    self.success = success
3351 
    self.ex = ex
3352 
 
3353 
  def read(self, iprot):
3354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3356 
      return
3357 
    iprot.readStructBegin()
3358 
    while True:
3359 
      (fname, ftype, fid) = iprot.readFieldBegin()
3360 
      if ftype == TType.STOP:
3361 
        break
3362 
      if fid == 0:
3363 
        if ftype == TType.BOOL:
3364 
          self.success = iprot.readBool();
3365 
        else:
3366 
          iprot.skip(ftype)
3367 
      elif fid == 1:
3368 
        if ftype == TType.STRUCT:
3369 
          self.ex = TransactionServiceException()
3370 
          self.ex.read(iprot)
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
1398 varun.gupt 3382 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
1382 varun.gupt 3383 
    if self.success != None:
3384 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3385 
      oprot.writeBool(self.success)
3386 
      oprot.writeFieldEnd()
3387 
    if self.ex != None:
3388 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3389 
      self.ex.write(oprot)
3390 
      oprot.writeFieldEnd()
3391 
    oprot.writeFieldStop()
3392 
    oprot.writeStructEnd()
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 
 
483 rajveer 3405 
class getAllOrders_args:
94 ashish 3406 
  """
3407 
  Attributes:
483 rajveer 3408 
   - status
3409 
   - from_date
3410 
   - to_date
3411 
   - warehouse_id
94 ashish 3412 
  """
3413 
 
3414 
  thrift_spec = (
3415 
    None, # 0
483 rajveer 3416 
    (1, TType.I32, 'status', None, None, ), # 1
3417 
    (2, TType.I64, 'from_date', None, None, ), # 2
3418 
    (3, TType.I64, 'to_date', None, None, ), # 3
3419 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 3420 
  )
3421 
 
483 rajveer 3422 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
3423 
    self.status = status
3424 
    self.from_date = from_date
3425 
    self.to_date = to_date
3426 
    self.warehouse_id = warehouse_id
94 ashish 3427 
 
3428 
  def read(self, iprot):
3429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3431 
      return
3432 
    iprot.readStructBegin()
3433 
    while True:
3434 
      (fname, ftype, fid) = iprot.readFieldBegin()
3435 
      if ftype == TType.STOP:
3436 
        break
3437 
      if fid == 1:
483 rajveer 3438 
        if ftype == TType.I32:
3439 
          self.status = iprot.readI32();
94 ashish 3440 
        else:
3441 
          iprot.skip(ftype)
483 rajveer 3442 
      elif fid == 2:
3443 
        if ftype == TType.I64:
3444 
          self.from_date = iprot.readI64();
94 ashish 3445 
        else:
3446 
          iprot.skip(ftype)
483 rajveer 3447 
      elif fid == 3:
3448 
        if ftype == TType.I64:
3449 
          self.to_date = iprot.readI64();
94 ashish 3450 
        else:
3451 
          iprot.skip(ftype)
483 rajveer 3452 
      elif fid == 4:
94 ashish 3453 
        if ftype == TType.I64:
483 rajveer 3454 
          self.warehouse_id = iprot.readI64();
94 ashish 3455 
        else:
3456 
          iprot.skip(ftype)
3457 
      else:
3458 
        iprot.skip(ftype)
3459 
      iprot.readFieldEnd()
3460 
    iprot.readStructEnd()
3461 
 
3462 
  def write(self, oprot):
3463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3465 
      return
483 rajveer 3466 
    oprot.writeStructBegin('getAllOrders_args')
3467 
    if self.status != None:
3468 
      oprot.writeFieldBegin('status', TType.I32, 1)
3469 
      oprot.writeI32(self.status)
94 ashish 3470 
      oprot.writeFieldEnd()
483 rajveer 3471 
    if self.from_date != None:
3472 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3473 
      oprot.writeI64(self.from_date)
94 ashish 3474 
      oprot.writeFieldEnd()
483 rajveer 3475 
    if self.to_date != None:
3476 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3477 
      oprot.writeI64(self.to_date)
94 ashish 3478 
      oprot.writeFieldEnd()
483 rajveer 3479 
    if self.warehouse_id != None:
3480 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
3481 
      oprot.writeI64(self.warehouse_id)
94 ashish 3482 
      oprot.writeFieldEnd()
3483 
    oprot.writeFieldStop()
3484 
    oprot.writeStructEnd()
3485 
 
3486 
  def __repr__(self):
3487 
    L = ['%s=%r' % (key, value)
3488 
      for key, value in self.__dict__.iteritems()]
3489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3490 
 
3491 
  def __eq__(self, other):
3492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3493 
 
3494 
  def __ne__(self, other):
3495 
    return not (self == other)
3496 
 
483 rajveer 3497 
class getAllOrders_result:
94 ashish 3498 
  """
3499 
  Attributes:
3500 
   - success
3501 
   - ex
3502 
  """
3503 
 
3504 
  thrift_spec = (
483 rajveer 3505 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 3506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3507 
  )
3508 
 
3509 
  def __init__(self, success=None, ex=None,):
3510 
    self.success = success
3511 
    self.ex = ex
3512 
 
3513 
  def read(self, iprot):
3514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3516 
      return
3517 
    iprot.readStructBegin()
3518 
    while True:
3519 
      (fname, ftype, fid) = iprot.readFieldBegin()
3520 
      if ftype == TType.STOP:
3521 
        break
3522 
      if fid == 0:
483 rajveer 3523 
        if ftype == TType.LIST:
3524 
          self.success = []
685 chandransh 3525 
          (_etype31, _size28) = iprot.readListBegin()
3526 
          for _i32 in xrange(_size28):
3527 
            _elem33 = Order()
3528 
            _elem33.read(iprot)
3529 
            self.success.append(_elem33)
483 rajveer 3530 
          iprot.readListEnd()
94 ashish 3531 
        else:
3532 
          iprot.skip(ftype)
3533 
      elif fid == 1:
3534 
        if ftype == TType.STRUCT:
3535 
          self.ex = TransactionServiceException()
3536 
          self.ex.read(iprot)
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
483 rajveer 3548 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 3549 
    if self.success != None:
483 rajveer 3550 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3551 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3552 
      for iter34 in self.success:
3553 
        iter34.write(oprot)
483 rajveer 3554 
      oprot.writeListEnd()
94 ashish 3555 
      oprot.writeFieldEnd()
3556 
    if self.ex != None:
3557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3558 
      self.ex.write(oprot)
3559 
      oprot.writeFieldEnd()
3560 
    oprot.writeFieldStop()
3561 
    oprot.writeStructEnd()
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 
 
999 varun.gupt 3574 
class getOrdersByBillingDate_args:
3575 
  """
3576 
  Attributes:
3577 
   - status
3578 
   - start_billing_date
3579 
   - end_billing_date
3580 
   - warehouse_id
3581 
  """
3582 
 
3583 
  thrift_spec = (
3584 
    None, # 0
3585 
    (1, TType.I32, 'status', None, None, ), # 1
3586 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
3587 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
3588 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
3589 
  )
3590 
 
3591 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
3592 
    self.status = status
3593 
    self.start_billing_date = start_billing_date
3594 
    self.end_billing_date = end_billing_date
3595 
    self.warehouse_id = warehouse_id
3596 
 
3597 
  def read(self, iprot):
3598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3600 
      return
3601 
    iprot.readStructBegin()
3602 
    while True:
3603 
      (fname, ftype, fid) = iprot.readFieldBegin()
3604 
      if ftype == TType.STOP:
3605 
        break
3606 
      if fid == 1:
3607 
        if ftype == TType.I32:
3608 
          self.status = iprot.readI32();
3609 
        else:
3610 
          iprot.skip(ftype)
3611 
      elif fid == 2:
3612 
        if ftype == TType.I64:
3613 
          self.start_billing_date = iprot.readI64();
3614 
        else:
3615 
          iprot.skip(ftype)
3616 
      elif fid == 3:
3617 
        if ftype == TType.I64:
3618 
          self.end_billing_date = iprot.readI64();
3619 
        else:
3620 
          iprot.skip(ftype)
3621 
      elif fid == 4:
3622 
        if ftype == TType.I64:
3623 
          self.warehouse_id = iprot.readI64();
3624 
        else:
3625 
          iprot.skip(ftype)
3626 
      else:
3627 
        iprot.skip(ftype)
3628 
      iprot.readFieldEnd()
3629 
    iprot.readStructEnd()
3630 
 
3631 
  def write(self, oprot):
3632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3634 
      return
3635 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3636 
    if self.status != None:
3637 
      oprot.writeFieldBegin('status', TType.I32, 1)
3638 
      oprot.writeI32(self.status)
3639 
      oprot.writeFieldEnd()
3640 
    if self.start_billing_date != None:
3641 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
3642 
      oprot.writeI64(self.start_billing_date)
3643 
      oprot.writeFieldEnd()
3644 
    if self.end_billing_date != None:
3645 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
3646 
      oprot.writeI64(self.end_billing_date)
3647 
      oprot.writeFieldEnd()
3648 
    if self.warehouse_id != None:
3649 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
3650 
      oprot.writeI64(self.warehouse_id)
3651 
      oprot.writeFieldEnd()
3652 
    oprot.writeFieldStop()
3653 
    oprot.writeStructEnd()
3654 
 
3655 
  def __repr__(self):
3656 
    L = ['%s=%r' % (key, value)
3657 
      for key, value in self.__dict__.iteritems()]
3658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3659 
 
3660 
  def __eq__(self, other):
3661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3662 
 
3663 
  def __ne__(self, other):
3664 
    return not (self == other)
3665 
 
3666 
class getOrdersByBillingDate_result:
3667 
  """
3668 
  Attributes:
3669 
   - success
3670 
   - ex
3671 
  """
3672 
 
3673 
  thrift_spec = (
3674 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
3675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3676 
  )
3677 
 
3678 
  def __init__(self, success=None, ex=None,):
3679 
    self.success = success
3680 
    self.ex = ex
3681 
 
3682 
  def read(self, iprot):
3683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3685 
      return
3686 
    iprot.readStructBegin()
3687 
    while True:
3688 
      (fname, ftype, fid) = iprot.readFieldBegin()
3689 
      if ftype == TType.STOP:
3690 
        break
3691 
      if fid == 0:
3692 
        if ftype == TType.LIST:
3693 
          self.success = []
3694 
          (_etype38, _size35) = iprot.readListBegin()
3695 
          for _i39 in xrange(_size35):
3696 
            _elem40 = Order()
3697 
            _elem40.read(iprot)
3698 
            self.success.append(_elem40)
3699 
          iprot.readListEnd()
3700 
        else:
3701 
          iprot.skip(ftype)
3702 
      elif fid == 1:
3703 
        if ftype == TType.STRUCT:
3704 
          self.ex = TransactionServiceException()
3705 
          self.ex.read(iprot)
3706 
        else:
3707 
          iprot.skip(ftype)
3708 
      else:
3709 
        iprot.skip(ftype)
3710 
      iprot.readFieldEnd()
3711 
    iprot.readStructEnd()
3712 
 
3713 
  def write(self, oprot):
3714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3716 
      return
3717 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3718 
    if self.success != None:
3719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3721 
      for iter41 in self.success:
3722 
        iter41.write(oprot)
3723 
      oprot.writeListEnd()
3724 
      oprot.writeFieldEnd()
3725 
    if self.ex != None:
3726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3727 
      self.ex.write(oprot)
3728 
      oprot.writeFieldEnd()
3729 
    oprot.writeFieldStop()
3730 
    oprot.writeStructEnd()
3731 
 
3732 
  def __repr__(self):
3733 
    L = ['%s=%r' % (key, value)
3734 
      for key, value in self.__dict__.iteritems()]
3735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3736 
 
3737 
  def __eq__(self, other):
3738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3739 
 
3740 
  def __ne__(self, other):
3741 
    return not (self == other)
3742 
 
1382 varun.gupt 3743 
class getReturnableOrdersForCustomer_args:
3744 
  """
3745 
  Attributes:
3746 
   - customer_id
3747 
   - limit
3748 
  """
3749 
 
3750 
  thrift_spec = (
3751 
    None, # 0
3752 
    (1, TType.I64, 'customer_id', None, None, ), # 1
3753 
    (2, TType.I64, 'limit', None, None, ), # 2
3754 
  )
3755 
 
3756 
  def __init__(self, customer_id=None, limit=None,):
3757 
    self.customer_id = customer_id
3758 
    self.limit = limit
3759 
 
3760 
  def read(self, iprot):
3761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3763 
      return
3764 
    iprot.readStructBegin()
3765 
    while True:
3766 
      (fname, ftype, fid) = iprot.readFieldBegin()
3767 
      if ftype == TType.STOP:
3768 
        break
3769 
      if fid == 1:
3770 
        if ftype == TType.I64:
3771 
          self.customer_id = iprot.readI64();
3772 
        else:
3773 
          iprot.skip(ftype)
3774 
      elif fid == 2:
3775 
        if ftype == TType.I64:
3776 
          self.limit = iprot.readI64();
3777 
        else:
3778 
          iprot.skip(ftype)
3779 
      else:
3780 
        iprot.skip(ftype)
3781 
      iprot.readFieldEnd()
3782 
    iprot.readStructEnd()
3783 
 
3784 
  def write(self, oprot):
3785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3787 
      return
3788 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3789 
    if self.customer_id != None:
3790 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
3791 
      oprot.writeI64(self.customer_id)
3792 
      oprot.writeFieldEnd()
3793 
    if self.limit != None:
3794 
      oprot.writeFieldBegin('limit', TType.I64, 2)
3795 
      oprot.writeI64(self.limit)
3796 
      oprot.writeFieldEnd()
3797 
    oprot.writeFieldStop()
3798 
    oprot.writeStructEnd()
3799 
 
3800 
  def __repr__(self):
3801 
    L = ['%s=%r' % (key, value)
3802 
      for key, value in self.__dict__.iteritems()]
3803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3804 
 
3805 
  def __eq__(self, other):
3806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3807 
 
3808 
  def __ne__(self, other):
3809 
    return not (self == other)
3810 
 
3811 
class getReturnableOrdersForCustomer_result:
3812 
  """
3813 
  Attributes:
3814 
   - success
3815 
   - ex
3816 
  """
3817 
 
3818 
  thrift_spec = (
3819 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
3820 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3821 
  )
3822 
 
3823 
  def __init__(self, success=None, ex=None,):
3824 
    self.success = success
3825 
    self.ex = ex
3826 
 
3827 
  def read(self, iprot):
3828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3830 
      return
3831 
    iprot.readStructBegin()
3832 
    while True:
3833 
      (fname, ftype, fid) = iprot.readFieldBegin()
3834 
      if ftype == TType.STOP:
3835 
        break
3836 
      if fid == 0:
3837 
        if ftype == TType.LIST:
3838 
          self.success = []
3839 
          (_etype45, _size42) = iprot.readListBegin()
3840 
          for _i46 in xrange(_size42):
3841 
            _elem47 = iprot.readI64();
3842 
            self.success.append(_elem47)
3843 
          iprot.readListEnd()
3844 
        else:
3845 
          iprot.skip(ftype)
3846 
      elif fid == 1:
3847 
        if ftype == TType.STRUCT:
3848 
          self.ex = TransactionServiceException()
3849 
          self.ex.read(iprot)
3850 
        else:
3851 
          iprot.skip(ftype)
3852 
      else:
3853 
        iprot.skip(ftype)
3854 
      iprot.readFieldEnd()
3855 
    iprot.readStructEnd()
3856 
 
3857 
  def write(self, oprot):
3858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3860 
      return
3861 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3862 
    if self.success != None:
3863 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3864 
      oprot.writeListBegin(TType.I64, len(self.success))
3865 
      for iter48 in self.success:
3866 
        oprot.writeI64(iter48)
3867 
      oprot.writeListEnd()
3868 
      oprot.writeFieldEnd()
3869 
    if self.ex != None:
3870 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3871 
      self.ex.write(oprot)
3872 
      oprot.writeFieldEnd()
3873 
    oprot.writeFieldStop()
3874 
    oprot.writeStructEnd()
3875 
 
3876 
  def __repr__(self):
3877 
    L = ['%s=%r' % (key, value)
3878 
      for key, value in self.__dict__.iteritems()]
3879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3880 
 
3881 
  def __eq__(self, other):
3882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3883 
 
3884 
  def __ne__(self, other):
3885 
    return not (self == other)
3886 
 
3887 
class getCancellableOrdersForCustomer_args:
3888 
  """
3889 
  Attributes:
3890 
   - customer_id
3891 
   - limit
3892 
  """
3893 
 
3894 
  thrift_spec = (
3895 
    None, # 0
3896 
    (1, TType.I64, 'customer_id', None, None, ), # 1
3897 
    (2, TType.I64, 'limit', None, None, ), # 2
3898 
  )
3899 
 
3900 
  def __init__(self, customer_id=None, limit=None,):
3901 
    self.customer_id = customer_id
3902 
    self.limit = limit
3903 
 
3904 
  def read(self, iprot):
3905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3907 
      return
3908 
    iprot.readStructBegin()
3909 
    while True:
3910 
      (fname, ftype, fid) = iprot.readFieldBegin()
3911 
      if ftype == TType.STOP:
3912 
        break
3913 
      if fid == 1:
3914 
        if ftype == TType.I64:
3915 
          self.customer_id = iprot.readI64();
3916 
        else:
3917 
          iprot.skip(ftype)
3918 
      elif fid == 2:
3919 
        if ftype == TType.I64:
3920 
          self.limit = iprot.readI64();
3921 
        else:
3922 
          iprot.skip(ftype)
3923 
      else:
3924 
        iprot.skip(ftype)
3925 
      iprot.readFieldEnd()
3926 
    iprot.readStructEnd()
3927 
 
3928 
  def write(self, oprot):
3929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3931 
      return
3932 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3933 
    if self.customer_id != None:
3934 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
3935 
      oprot.writeI64(self.customer_id)
3936 
      oprot.writeFieldEnd()
3937 
    if self.limit != None:
3938 
      oprot.writeFieldBegin('limit', TType.I64, 2)
3939 
      oprot.writeI64(self.limit)
3940 
      oprot.writeFieldEnd()
3941 
    oprot.writeFieldStop()
3942 
    oprot.writeStructEnd()
3943 
 
3944 
  def __repr__(self):
3945 
    L = ['%s=%r' % (key, value)
3946 
      for key, value in self.__dict__.iteritems()]
3947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3948 
 
3949 
  def __eq__(self, other):
3950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3951 
 
3952 
  def __ne__(self, other):
3953 
    return not (self == other)
3954 
 
3955 
class getCancellableOrdersForCustomer_result:
3956 
  """
3957 
  Attributes:
3958 
   - success
3959 
   - ex
3960 
  """
3961 
 
3962 
  thrift_spec = (
3963 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
3964 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3965 
  )
3966 
 
3967 
  def __init__(self, success=None, ex=None,):
3968 
    self.success = success
3969 
    self.ex = ex
3970 
 
3971 
  def read(self, iprot):
3972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3974 
      return
3975 
    iprot.readStructBegin()
3976 
    while True:
3977 
      (fname, ftype, fid) = iprot.readFieldBegin()
3978 
      if ftype == TType.STOP:
3979 
        break
3980 
      if fid == 0:
3981 
        if ftype == TType.LIST:
3982 
          self.success = []
3983 
          (_etype52, _size49) = iprot.readListBegin()
3984 
          for _i53 in xrange(_size49):
3985 
            _elem54 = iprot.readI64();
3986 
            self.success.append(_elem54)
3987 
          iprot.readListEnd()
3988 
        else:
3989 
          iprot.skip(ftype)
3990 
      elif fid == 1:
3991 
        if ftype == TType.STRUCT:
3992 
          self.ex = TransactionServiceException()
3993 
          self.ex.read(iprot)
3994 
        else:
3995 
          iprot.skip(ftype)
3996 
      else:
3997 
        iprot.skip(ftype)
3998 
      iprot.readFieldEnd()
3999 
    iprot.readStructEnd()
4000 
 
4001 
  def write(self, oprot):
4002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4004 
      return
4005 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
4006 
    if self.success != None:
4007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4008 
      oprot.writeListBegin(TType.I64, len(self.success))
4009 
      for iter55 in self.success:
4010 
        oprot.writeI64(iter55)
4011 
      oprot.writeListEnd()
4012 
      oprot.writeFieldEnd()
4013 
    if self.ex != None:
4014 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4015 
      self.ex.write(oprot)
4016 
      oprot.writeFieldEnd()
4017 
    oprot.writeFieldStop()
4018 
    oprot.writeStructEnd()
4019 
 
4020 
  def __repr__(self):
4021 
    L = ['%s=%r' % (key, value)
4022 
      for key, value in self.__dict__.iteritems()]
4023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4024 
 
4025 
  def __eq__(self, other):
4026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4027 
 
4028 
  def __ne__(self, other):
4029 
    return not (self == other)
4030 
 
483 rajveer 4031 
class changeOrderStatus_args:
94 ashish 4032 
  """
4033 
  Attributes:
483 rajveer 4034 
   - orderId
4035 
   - status
4036 
   - description
94 ashish 4037 
  """
4038 
 
4039 
  thrift_spec = (
4040 
    None, # 0
483 rajveer 4041 
    (1, TType.I64, 'orderId', None, None, ), # 1
4042 
    (2, TType.I32, 'status', None, None, ), # 2
4043 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 4044 
  )
4045 
 
483 rajveer 4046 
  def __init__(self, orderId=None, status=None, description=None,):
4047 
    self.orderId = orderId
4048 
    self.status = status
4049 
    self.description = description
94 ashish 4050 
 
4051 
  def read(self, iprot):
4052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4054 
      return
4055 
    iprot.readStructBegin()
4056 
    while True:
4057 
      (fname, ftype, fid) = iprot.readFieldBegin()
4058 
      if ftype == TType.STOP:
4059 
        break
4060 
      if fid == 1:
4061 
        if ftype == TType.I64:
483 rajveer 4062 
          self.orderId = iprot.readI64();
94 ashish 4063 
        else:
4064 
          iprot.skip(ftype)
4065 
      elif fid == 2:
483 rajveer 4066 
        if ftype == TType.I32:
4067 
          self.status = iprot.readI32();
94 ashish 4068 
        else:
4069 
          iprot.skip(ftype)
483 rajveer 4070 
      elif fid == 3:
4071 
        if ftype == TType.STRING:
4072 
          self.description = iprot.readString();
4073 
        else:
4074 
          iprot.skip(ftype)
94 ashish 4075 
      else:
4076 
        iprot.skip(ftype)
4077 
      iprot.readFieldEnd()
4078 
    iprot.readStructEnd()
4079 
 
4080 
  def write(self, oprot):
4081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4083 
      return
483 rajveer 4084 
    oprot.writeStructBegin('changeOrderStatus_args')
4085 
    if self.orderId != None:
4086 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4087 
      oprot.writeI64(self.orderId)
94 ashish 4088 
      oprot.writeFieldEnd()
483 rajveer 4089 
    if self.status != None:
4090 
      oprot.writeFieldBegin('status', TType.I32, 2)
4091 
      oprot.writeI32(self.status)
94 ashish 4092 
      oprot.writeFieldEnd()
483 rajveer 4093 
    if self.description != None:
4094 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4095 
      oprot.writeString(self.description)
4096 
      oprot.writeFieldEnd()
94 ashish 4097 
    oprot.writeFieldStop()
4098 
    oprot.writeStructEnd()
4099 
 
4100 
  def __repr__(self):
4101 
    L = ['%s=%r' % (key, value)
4102 
      for key, value in self.__dict__.iteritems()]
4103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4104 
 
4105 
  def __eq__(self, other):
4106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4107 
 
4108 
  def __ne__(self, other):
4109 
    return not (self == other)
4110 
 
483 rajveer 4111 
class changeOrderStatus_result:
94 ashish 4112 
  """
4113 
  Attributes:
4114 
   - success
4115 
   - ex
4116 
  """
4117 
 
4118 
  thrift_spec = (
4119 
    (0, TType.BOOL, 'success', None, None, ), # 0
4120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4121 
  )
4122 
 
4123 
  def __init__(self, success=None, ex=None,):
4124 
    self.success = success
4125 
    self.ex = ex
4126 
 
4127 
  def read(self, iprot):
4128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4130 
      return
4131 
    iprot.readStructBegin()
4132 
    while True:
4133 
      (fname, ftype, fid) = iprot.readFieldBegin()
4134 
      if ftype == TType.STOP:
4135 
        break
4136 
      if fid == 0:
4137 
        if ftype == TType.BOOL:
4138 
          self.success = iprot.readBool();
4139 
        else:
4140 
          iprot.skip(ftype)
4141 
      elif fid == 1:
4142 
        if ftype == TType.STRUCT:
4143 
          self.ex = TransactionServiceException()
4144 
          self.ex.read(iprot)
4145 
        else:
4146 
          iprot.skip(ftype)
4147 
      else:
4148 
        iprot.skip(ftype)
4149 
      iprot.readFieldEnd()
4150 
    iprot.readStructEnd()
4151 
 
4152 
  def write(self, oprot):
4153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4155 
      return
483 rajveer 4156 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 4157 
    if self.success != None:
4158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4159 
      oprot.writeBool(self.success)
4160 
      oprot.writeFieldEnd()
4161 
    if self.ex != None:
4162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4163 
      self.ex.write(oprot)
4164 
      oprot.writeFieldEnd()
4165 
    oprot.writeFieldStop()
4166 
    oprot.writeStructEnd()
4167 
 
4168 
  def __repr__(self):
4169 
    L = ['%s=%r' % (key, value)
4170 
      for key, value in self.__dict__.iteritems()]
4171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4172 
 
4173 
  def __eq__(self, other):
4174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4175 
 
4176 
  def __ne__(self, other):
4177 
    return not (self == other)
4178 
 
494 rajveer 4179 
class addBillingDetails_args:
4180 
  """
4181 
  Attributes:
4182 
   - orderId
4183 
   - invoice_number
4184 
   - billed_by
4185 
  """
4186 
 
4187 
  thrift_spec = (
4188 
    None, # 0
4189 
    (1, TType.I64, 'orderId', None, None, ), # 1
4190 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
1149 chandransh 4191 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
494 rajveer 4192 
  )
4193 
 
1149 chandransh 4194 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
494 rajveer 4195 
    self.orderId = orderId
4196 
    self.invoice_number = invoice_number
4197 
    self.billed_by = billed_by
4198 
 
4199 
  def read(self, iprot):
4200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4202 
      return
4203 
    iprot.readStructBegin()
4204 
    while True:
4205 
      (fname, ftype, fid) = iprot.readFieldBegin()
4206 
      if ftype == TType.STOP:
4207 
        break
4208 
      if fid == 1:
4209 
        if ftype == TType.I64:
4210 
          self.orderId = iprot.readI64();
4211 
        else:
4212 
          iprot.skip(ftype)
4213 
      elif fid == 2:
4214 
        if ftype == TType.STRING:
4215 
          self.invoice_number = iprot.readString();
4216 
        else:
4217 
          iprot.skip(ftype)
4218 
      elif fid == 3:
4219 
        if ftype == TType.STRING:
4220 
          self.billed_by = iprot.readString();
4221 
        else:
4222 
          iprot.skip(ftype)
4223 
      else:
4224 
        iprot.skip(ftype)
4225 
      iprot.readFieldEnd()
4226 
    iprot.readStructEnd()
4227 
 
4228 
  def write(self, oprot):
4229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4231 
      return
4232 
    oprot.writeStructBegin('addBillingDetails_args')
4233 
    if self.orderId != None:
4234 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4235 
      oprot.writeI64(self.orderId)
4236 
      oprot.writeFieldEnd()
4237 
    if self.invoice_number != None:
4238 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
4239 
      oprot.writeString(self.invoice_number)
4240 
      oprot.writeFieldEnd()
4241 
    if self.billed_by != None:
1149 chandransh 4242 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
494 rajveer 4243 
      oprot.writeString(self.billed_by)
4244 
      oprot.writeFieldEnd()
4245 
    oprot.writeFieldStop()
4246 
    oprot.writeStructEnd()
4247 
 
4248 
  def __repr__(self):
4249 
    L = ['%s=%r' % (key, value)
4250 
      for key, value in self.__dict__.iteritems()]
4251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4252 
 
4253 
  def __eq__(self, other):
4254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4255 
 
4256 
  def __ne__(self, other):
4257 
    return not (self == other)
4258 
 
4259 
class addBillingDetails_result:
4260 
  """
4261 
  Attributes:
4262 
   - success
4263 
   - ex
4264 
  """
4265 
 
4266 
  thrift_spec = (
4267 
    (0, TType.BOOL, 'success', None, None, ), # 0
4268 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4269 
  )
4270 
 
4271 
  def __init__(self, success=None, ex=None,):
4272 
    self.success = success
4273 
    self.ex = ex
4274 
 
4275 
  def read(self, iprot):
4276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4278 
      return
4279 
    iprot.readStructBegin()
4280 
    while True:
4281 
      (fname, ftype, fid) = iprot.readFieldBegin()
4282 
      if ftype == TType.STOP:
4283 
        break
4284 
      if fid == 0:
4285 
        if ftype == TType.BOOL:
4286 
          self.success = iprot.readBool();
4287 
        else:
4288 
          iprot.skip(ftype)
4289 
      elif fid == 1:
4290 
        if ftype == TType.STRUCT:
4291 
          self.ex = TransactionServiceException()
4292 
          self.ex.read(iprot)
4293 
        else:
4294 
          iprot.skip(ftype)
4295 
      else:
4296 
        iprot.skip(ftype)
4297 
      iprot.readFieldEnd()
4298 
    iprot.readStructEnd()
4299 
 
4300 
  def write(self, oprot):
4301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4303 
      return
4304 
    oprot.writeStructBegin('addBillingDetails_result')
4305 
    if self.success != None:
4306 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4307 
      oprot.writeBool(self.success)
4308 
      oprot.writeFieldEnd()
4309 
    if self.ex != None:
4310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4311 
      self.ex.write(oprot)
4312 
      oprot.writeFieldEnd()
4313 
    oprot.writeFieldStop()
4314 
    oprot.writeStructEnd()
4315 
 
4316 
  def __repr__(self):
4317 
    L = ['%s=%r' % (key, value)
4318 
      for key, value in self.__dict__.iteritems()]
4319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4320 
 
4321 
  def __eq__(self, other):
4322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4323 
 
4324 
  def __ne__(self, other):
4325 
    return not (self == other)
4326 
 
1149 chandransh 4327 
class addJacketNumber_args:
4328 
  """
4329 
  Attributes:
4330 
   - orderId
4331 
   - jacketNumber
4332 
  """
4333 
 
4334 
  thrift_spec = (
4335 
    None, # 0
4336 
    (1, TType.I64, 'orderId', None, None, ), # 1
4337 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
4338 
  )
4339 
 
4340 
  def __init__(self, orderId=None, jacketNumber=None,):
4341 
    self.orderId = orderId
4342 
    self.jacketNumber = jacketNumber
4343 
 
4344 
  def read(self, iprot):
4345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4347 
      return
4348 
    iprot.readStructBegin()
4349 
    while True:
4350 
      (fname, ftype, fid) = iprot.readFieldBegin()
4351 
      if ftype == TType.STOP:
4352 
        break
4353 
      if fid == 1:
4354 
        if ftype == TType.I64:
4355 
          self.orderId = iprot.readI64();
4356 
        else:
4357 
          iprot.skip(ftype)
4358 
      elif fid == 2:
4359 
        if ftype == TType.I64:
4360 
          self.jacketNumber = iprot.readI64();
4361 
        else:
4362 
          iprot.skip(ftype)
4363 
      else:
4364 
        iprot.skip(ftype)
4365 
      iprot.readFieldEnd()
4366 
    iprot.readStructEnd()
4367 
 
4368 
  def write(self, oprot):
4369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4371 
      return
4372 
    oprot.writeStructBegin('addJacketNumber_args')
4373 
    if self.orderId != None:
4374 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4375 
      oprot.writeI64(self.orderId)
4376 
      oprot.writeFieldEnd()
4377 
    if self.jacketNumber != None:
4378 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
4379 
      oprot.writeI64(self.jacketNumber)
4380 
      oprot.writeFieldEnd()
4381 
    oprot.writeFieldStop()
4382 
    oprot.writeStructEnd()
4383 
 
4384 
  def __repr__(self):
4385 
    L = ['%s=%r' % (key, value)
4386 
      for key, value in self.__dict__.iteritems()]
4387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4388 
 
4389 
  def __eq__(self, other):
4390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4391 
 
4392 
  def __ne__(self, other):
4393 
    return not (self == other)
4394 
 
4395 
class addJacketNumber_result:
4396 
  """
4397 
  Attributes:
4398 
   - success
4399 
   - ex
4400 
  """
4401 
 
4402 
  thrift_spec = (
4403 
    (0, TType.BOOL, 'success', None, None, ), # 0
4404 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4405 
  )
4406 
 
4407 
  def __init__(self, success=None, ex=None,):
4408 
    self.success = success
4409 
    self.ex = ex
4410 
 
4411 
  def read(self, iprot):
4412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4414 
      return
4415 
    iprot.readStructBegin()
4416 
    while True:
4417 
      (fname, ftype, fid) = iprot.readFieldBegin()
4418 
      if ftype == TType.STOP:
4419 
        break
4420 
      if fid == 0:
4421 
        if ftype == TType.BOOL:
4422 
          self.success = iprot.readBool();
4423 
        else:
4424 
          iprot.skip(ftype)
4425 
      elif fid == 1:
4426 
        if ftype == TType.STRUCT:
4427 
          self.ex = TransactionServiceException()
4428 
          self.ex.read(iprot)
4429 
        else:
4430 
          iprot.skip(ftype)
4431 
      else:
4432 
        iprot.skip(ftype)
4433 
      iprot.readFieldEnd()
4434 
    iprot.readStructEnd()
4435 
 
4436 
  def write(self, oprot):
4437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4439 
      return
4440 
    oprot.writeStructBegin('addJacketNumber_result')
4441 
    if self.success != None:
4442 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4443 
      oprot.writeBool(self.success)
4444 
      oprot.writeFieldEnd()
4445 
    if self.ex != None:
4446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4447 
      self.ex.write(oprot)
4448 
      oprot.writeFieldEnd()
4449 
    oprot.writeFieldStop()
4450 
    oprot.writeStructEnd()
4451 
 
4452 
  def __repr__(self):
4453 
    L = ['%s=%r' % (key, value)
4454 
      for key, value in self.__dict__.iteritems()]
4455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4456 
 
4457 
  def __eq__(self, other):
4458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4459 
 
4460 
  def __ne__(self, other):
4461 
    return not (self == other)
4462 
 
921 rajveer 4463 
class acceptOrder_args:
4464 
  """
4465 
  Attributes:
4466 
   - orderId
4467 
  """
4468 
 
4469 
  thrift_spec = (
4470 
    None, # 0
4471 
    (1, TType.I64, 'orderId', None, None, ), # 1
4472 
  )
4473 
 
4474 
  def __init__(self, orderId=None,):
4475 
    self.orderId = orderId
4476 
 
4477 
  def read(self, iprot):
4478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4480 
      return
4481 
    iprot.readStructBegin()
4482 
    while True:
4483 
      (fname, ftype, fid) = iprot.readFieldBegin()
4484 
      if ftype == TType.STOP:
4485 
        break
4486 
      if fid == 1:
4487 
        if ftype == TType.I64:
4488 
          self.orderId = iprot.readI64();
4489 
        else:
4490 
          iprot.skip(ftype)
4491 
      else:
4492 
        iprot.skip(ftype)
4493 
      iprot.readFieldEnd()
4494 
    iprot.readStructEnd()
4495 
 
4496 
  def write(self, oprot):
4497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4499 
      return
4500 
    oprot.writeStructBegin('acceptOrder_args')
4501 
    if self.orderId != None:
4502 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4503 
      oprot.writeI64(self.orderId)
4504 
      oprot.writeFieldEnd()
4505 
    oprot.writeFieldStop()
4506 
    oprot.writeStructEnd()
4507 
 
4508 
  def __repr__(self):
4509 
    L = ['%s=%r' % (key, value)
4510 
      for key, value in self.__dict__.iteritems()]
4511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4512 
 
4513 
  def __eq__(self, other):
4514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4515 
 
4516 
  def __ne__(self, other):
4517 
    return not (self == other)
4518 
 
4519 
class acceptOrder_result:
4520 
  """
4521 
  Attributes:
4522 
   - success
4523 
   - ex
4524 
  """
4525 
 
4526 
  thrift_spec = (
4527 
    (0, TType.BOOL, 'success', None, None, ), # 0
4528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4529 
  )
4530 
 
4531 
  def __init__(self, success=None, ex=None,):
4532 
    self.success = success
4533 
    self.ex = ex
4534 
 
4535 
  def read(self, iprot):
4536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4538 
      return
4539 
    iprot.readStructBegin()
4540 
    while True:
4541 
      (fname, ftype, fid) = iprot.readFieldBegin()
4542 
      if ftype == TType.STOP:
4543 
        break
4544 
      if fid == 0:
4545 
        if ftype == TType.BOOL:
4546 
          self.success = iprot.readBool();
4547 
        else:
4548 
          iprot.skip(ftype)
4549 
      elif fid == 1:
4550 
        if ftype == TType.STRUCT:
4551 
          self.ex = TransactionServiceException()
4552 
          self.ex.read(iprot)
4553 
        else:
4554 
          iprot.skip(ftype)
4555 
      else:
4556 
        iprot.skip(ftype)
4557 
      iprot.readFieldEnd()
4558 
    iprot.readStructEnd()
4559 
 
4560 
  def write(self, oprot):
4561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4563 
      return
4564 
    oprot.writeStructBegin('acceptOrder_result')
4565 
    if self.success != None:
4566 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4567 
      oprot.writeBool(self.success)
4568 
      oprot.writeFieldEnd()
4569 
    if self.ex != None:
4570 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4571 
      self.ex.write(oprot)
4572 
      oprot.writeFieldEnd()
4573 
    oprot.writeFieldStop()
4574 
    oprot.writeStructEnd()
4575 
 
4576 
  def __repr__(self):
4577 
    L = ['%s=%r' % (key, value)
4578 
      for key, value in self.__dict__.iteritems()]
4579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4580 
 
4581 
  def __eq__(self, other):
4582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4583 
 
4584 
  def __ne__(self, other):
4585 
    return not (self == other)
4586 
 
4587 
class billOrder_args:
4588 
  """
4589 
  Attributes:
4590 
   - orderId
4591 
  """
4592 
 
4593 
  thrift_spec = (
4594 
    None, # 0
4595 
    (1, TType.I64, 'orderId', None, None, ), # 1
4596 
  )
4597 
 
4598 
  def __init__(self, orderId=None,):
4599 
    self.orderId = orderId
4600 
 
4601 
  def read(self, iprot):
4602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4604 
      return
4605 
    iprot.readStructBegin()
4606 
    while True:
4607 
      (fname, ftype, fid) = iprot.readFieldBegin()
4608 
      if ftype == TType.STOP:
4609 
        break
4610 
      if fid == 1:
4611 
        if ftype == TType.I64:
4612 
          self.orderId = iprot.readI64();
4613 
        else:
4614 
          iprot.skip(ftype)
4615 
      else:
4616 
        iprot.skip(ftype)
4617 
      iprot.readFieldEnd()
4618 
    iprot.readStructEnd()
4619 
 
4620 
  def write(self, oprot):
4621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4623 
      return
4624 
    oprot.writeStructBegin('billOrder_args')
4625 
    if self.orderId != None:
4626 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4627 
      oprot.writeI64(self.orderId)
4628 
      oprot.writeFieldEnd()
4629 
    oprot.writeFieldStop()
4630 
    oprot.writeStructEnd()
4631 
 
4632 
  def __repr__(self):
4633 
    L = ['%s=%r' % (key, value)
4634 
      for key, value in self.__dict__.iteritems()]
4635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4636 
 
4637 
  def __eq__(self, other):
4638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4639 
 
4640 
  def __ne__(self, other):
4641 
    return not (self == other)
4642 
 
4643 
class billOrder_result:
4644 
  """
4645 
  Attributes:
4646 
   - success
4647 
   - ex
4648 
  """
4649 
 
4650 
  thrift_spec = (
4651 
    (0, TType.BOOL, 'success', None, None, ), # 0
4652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4653 
  )
4654 
 
4655 
  def __init__(self, success=None, ex=None,):
4656 
    self.success = success
4657 
    self.ex = ex
4658 
 
4659 
  def read(self, iprot):
4660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4662 
      return
4663 
    iprot.readStructBegin()
4664 
    while True:
4665 
      (fname, ftype, fid) = iprot.readFieldBegin()
4666 
      if ftype == TType.STOP:
4667 
        break
4668 
      if fid == 0:
4669 
        if ftype == TType.BOOL:
4670 
          self.success = iprot.readBool();
4671 
        else:
4672 
          iprot.skip(ftype)
4673 
      elif fid == 1:
4674 
        if ftype == TType.STRUCT:
4675 
          self.ex = TransactionServiceException()
4676 
          self.ex.read(iprot)
4677 
        else:
4678 
          iprot.skip(ftype)
4679 
      else:
4680 
        iprot.skip(ftype)
4681 
      iprot.readFieldEnd()
4682 
    iprot.readStructEnd()
4683 
 
4684 
  def write(self, oprot):
4685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4687 
      return
4688 
    oprot.writeStructBegin('billOrder_result')
4689 
    if self.success != None:
4690 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4691 
      oprot.writeBool(self.success)
4692 
      oprot.writeFieldEnd()
4693 
    if self.ex != None:
4694 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4695 
      self.ex.write(oprot)
4696 
      oprot.writeFieldEnd()
4697 
    oprot.writeFieldStop()
4698 
    oprot.writeStructEnd()
4699 
 
4700 
  def __repr__(self):
4701 
    L = ['%s=%r' % (key, value)
4702 
      for key, value in self.__dict__.iteritems()]
4703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4704 
 
4705 
  def __eq__(self, other):
4706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4707 
 
4708 
  def __ne__(self, other):
4709 
    return not (self == other)
4710 
 
483 rajveer 4711 
class getOrdersForTransaction_args:
94 ashish 4712 
  """
4713 
  Attributes:
4714 
   - transactionId
1528 ankur.sing 4715 
   - customerId
94 ashish 4716 
  """
4717 
 
4718 
  thrift_spec = (
4719 
    None, # 0
4720 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1528 ankur.sing 4721 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 4722 
  )
4723 
 
1528 ankur.sing 4724 
  def __init__(self, transactionId=None, customerId=None,):
94 ashish 4725 
    self.transactionId = transactionId
1528 ankur.sing 4726 
    self.customerId = customerId
94 ashish 4727 
 
4728 
  def read(self, iprot):
4729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4731 
      return
4732 
    iprot.readStructBegin()
4733 
    while True:
4734 
      (fname, ftype, fid) = iprot.readFieldBegin()
4735 
      if ftype == TType.STOP:
4736 
        break
4737 
      if fid == 1:
4738 
        if ftype == TType.I64:
4739 
          self.transactionId = iprot.readI64();
4740 
        else:
4741 
          iprot.skip(ftype)
1528 ankur.sing 4742 
      elif fid == 2:
4743 
        if ftype == TType.I64:
4744 
          self.customerId = iprot.readI64();
4745 
        else:
4746 
          iprot.skip(ftype)
94 ashish 4747 
      else:
4748 
        iprot.skip(ftype)
4749 
      iprot.readFieldEnd()
4750 
    iprot.readStructEnd()
4751 
 
4752 
  def write(self, oprot):
4753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4755 
      return
483 rajveer 4756 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 4757 
    if self.transactionId != None:
4758 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
4759 
      oprot.writeI64(self.transactionId)
4760 
      oprot.writeFieldEnd()
1528 ankur.sing 4761 
    if self.customerId != None:
4762 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
4763 
      oprot.writeI64(self.customerId)
4764 
      oprot.writeFieldEnd()
94 ashish 4765 
    oprot.writeFieldStop()
4766 
    oprot.writeStructEnd()
4767 
 
4768 
  def __repr__(self):
4769 
    L = ['%s=%r' % (key, value)
4770 
      for key, value in self.__dict__.iteritems()]
4771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4772 
 
4773 
  def __eq__(self, other):
4774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4775 
 
4776 
  def __ne__(self, other):
4777 
    return not (self == other)
4778 
 
483 rajveer 4779 
class getOrdersForTransaction_result:
94 ashish 4780 
  """
4781 
  Attributes:
4782 
   - success
4783 
   - ex
4784 
  """
4785 
 
4786 
  thrift_spec = (
483 rajveer 4787 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 4788 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4789 
  )
4790 
 
4791 
  def __init__(self, success=None, ex=None,):
4792 
    self.success = success
4793 
    self.ex = ex
4794 
 
4795 
  def read(self, iprot):
4796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4798 
      return
4799 
    iprot.readStructBegin()
4800 
    while True:
4801 
      (fname, ftype, fid) = iprot.readFieldBegin()
4802 
      if ftype == TType.STOP:
4803 
        break
4804 
      if fid == 0:
483 rajveer 4805 
        if ftype == TType.LIST:
4806 
          self.success = []
1382 varun.gupt 4807 
          (_etype59, _size56) = iprot.readListBegin()
4808 
          for _i60 in xrange(_size56):
4809 
            _elem61 = Order()
4810 
            _elem61.read(iprot)
4811 
            self.success.append(_elem61)
483 rajveer 4812 
          iprot.readListEnd()
94 ashish 4813 
        else:
4814 
          iprot.skip(ftype)
4815 
      elif fid == 1:
4816 
        if ftype == TType.STRUCT:
4817 
          self.ex = TransactionServiceException()
4818 
          self.ex.read(iprot)
4819 
        else:
4820 
          iprot.skip(ftype)
4821 
      else:
4822 
        iprot.skip(ftype)
4823 
      iprot.readFieldEnd()
4824 
    iprot.readStructEnd()
4825 
 
4826 
  def write(self, oprot):
4827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4829 
      return
483 rajveer 4830 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 4831 
    if self.success != None:
483 rajveer 4832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 4834 
      for iter62 in self.success:
4835 
        iter62.write(oprot)
483 rajveer 4836 
      oprot.writeListEnd()
94 ashish 4837 
      oprot.writeFieldEnd()
4838 
    if self.ex != None:
4839 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4840 
      self.ex.write(oprot)
4841 
      oprot.writeFieldEnd()
4842 
    oprot.writeFieldStop()
4843 
    oprot.writeStructEnd()
4844 
 
4845 
  def __repr__(self):
4846 
    L = ['%s=%r' % (key, value)
4847 
      for key, value in self.__dict__.iteritems()]
4848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4849 
 
4850 
  def __eq__(self, other):
4851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4852 
 
4853 
  def __ne__(self, other):
4854 
    return not (self == other)
4855 
 
483 rajveer 4856 
class getOrdersForCustomer_args:
94 ashish 4857 
  """
4858 
  Attributes:
483 rajveer 4859 
   - customerId
4860 
   - from_date
4861 
   - to_date
4862 
   - status
94 ashish 4863 
  """
4864 
 
4865 
  thrift_spec = (
4866 
    None, # 0
483 rajveer 4867 
    (1, TType.I64, 'customerId', None, None, ), # 1
4868 
    (2, TType.I64, 'from_date', None, None, ), # 2
4869 
    (3, TType.I64, 'to_date', None, None, ), # 3
4870 
    (4, TType.I32, 'status', None, None, ), # 4
94 ashish 4871 
  )
4872 
 
483 rajveer 4873 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
4874 
    self.customerId = customerId
4875 
    self.from_date = from_date
4876 
    self.to_date = to_date
4877 
    self.status = status
94 ashish 4878 
 
4879 
  def read(self, iprot):
4880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4882 
      return
4883 
    iprot.readStructBegin()
4884 
    while True:
4885 
      (fname, ftype, fid) = iprot.readFieldBegin()
4886 
      if ftype == TType.STOP:
4887 
        break
4888 
      if fid == 1:
4889 
        if ftype == TType.I64:
483 rajveer 4890 
          self.customerId = iprot.readI64();
94 ashish 4891 
        else:
4892 
          iprot.skip(ftype)
4893 
      elif fid == 2:
4894 
        if ftype == TType.I64:
483 rajveer 4895 
          self.from_date = iprot.readI64();
94 ashish 4896 
        else:
4897 
          iprot.skip(ftype)
4898 
      elif fid == 3:
4899 
        if ftype == TType.I64:
483 rajveer 4900 
          self.to_date = iprot.readI64();
94 ashish 4901 
        else:
4902 
          iprot.skip(ftype)
483 rajveer 4903 
      elif fid == 4:
4904 
        if ftype == TType.I32:
4905 
          self.status = iprot.readI32();
4906 
        else:
4907 
          iprot.skip(ftype)
94 ashish 4908 
      else:
4909 
        iprot.skip(ftype)
4910 
      iprot.readFieldEnd()
4911 
    iprot.readStructEnd()
4912 
 
4913 
  def write(self, oprot):
4914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4916 
      return
483 rajveer 4917 
    oprot.writeStructBegin('getOrdersForCustomer_args')
4918 
    if self.customerId != None:
4919 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
4920 
      oprot.writeI64(self.customerId)
94 ashish 4921 
      oprot.writeFieldEnd()
483 rajveer 4922 
    if self.from_date != None:
4923 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
4924 
      oprot.writeI64(self.from_date)
94 ashish 4925 
      oprot.writeFieldEnd()
483 rajveer 4926 
    if self.to_date != None:
4927 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
4928 
      oprot.writeI64(self.to_date)
94 ashish 4929 
      oprot.writeFieldEnd()
483 rajveer 4930 
    if self.status != None:
4931 
      oprot.writeFieldBegin('status', TType.I32, 4)
4932 
      oprot.writeI32(self.status)
4933 
      oprot.writeFieldEnd()
94 ashish 4934 
    oprot.writeFieldStop()
4935 
    oprot.writeStructEnd()
4936 
 
4937 
  def __repr__(self):
4938 
    L = ['%s=%r' % (key, value)
4939 
      for key, value in self.__dict__.iteritems()]
4940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4941 
 
4942 
  def __eq__(self, other):
4943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4944 
 
4945 
  def __ne__(self, other):
4946 
    return not (self == other)
4947 
 
483 rajveer 4948 
class getOrdersForCustomer_result:
94 ashish 4949 
  """
4950 
  Attributes:
4951 
   - success
4952 
   - ex
4953 
  """
4954 
 
4955 
  thrift_spec = (
483 rajveer 4956 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 4957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4958 
  )
4959 
 
4960 
  def __init__(self, success=None, ex=None,):
4961 
    self.success = success
4962 
    self.ex = ex
4963 
 
4964 
  def read(self, iprot):
4965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4967 
      return
4968 
    iprot.readStructBegin()
4969 
    while True:
4970 
      (fname, ftype, fid) = iprot.readFieldBegin()
4971 
      if ftype == TType.STOP:
4972 
        break
4973 
      if fid == 0:
483 rajveer 4974 
        if ftype == TType.LIST:
4975 
          self.success = []
1382 varun.gupt 4976 
          (_etype66, _size63) = iprot.readListBegin()
4977 
          for _i67 in xrange(_size63):
4978 
            _elem68 = Order()
4979 
            _elem68.read(iprot)
4980 
            self.success.append(_elem68)
483 rajveer 4981 
          iprot.readListEnd()
94 ashish 4982 
        else:
4983 
          iprot.skip(ftype)
4984 
      elif fid == 1:
4985 
        if ftype == TType.STRUCT:
4986 
          self.ex = TransactionServiceException()
4987 
          self.ex.read(iprot)
4988 
        else:
4989 
          iprot.skip(ftype)
4990 
      else:
4991 
        iprot.skip(ftype)
4992 
      iprot.readFieldEnd()
4993 
    iprot.readStructEnd()
4994 
 
4995 
  def write(self, oprot):
4996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4998 
      return
483 rajveer 4999 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 5000 
    if self.success != None:
483 rajveer 5001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5003 
      for iter69 in self.success:
5004 
        iter69.write(oprot)
483 rajveer 5005 
      oprot.writeListEnd()
94 ashish 5006 
      oprot.writeFieldEnd()
5007 
    if self.ex != None:
5008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5009 
      self.ex.write(oprot)
5010 
      oprot.writeFieldEnd()
5011 
    oprot.writeFieldStop()
5012 
    oprot.writeStructEnd()
5013 
 
5014 
  def __repr__(self):
5015 
    L = ['%s=%r' % (key, value)
5016 
      for key, value in self.__dict__.iteritems()]
5017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5018 
 
5019 
  def __eq__(self, other):
5020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5021 
 
5022 
  def __ne__(self, other):
5023 
    return not (self == other)
5024 
 
483 rajveer 5025 
class createOrder_args:
94 ashish 5026 
  """
5027 
  Attributes:
483 rajveer 5028 
   - order
94 ashish 5029 
  """
5030 
 
5031 
  thrift_spec = (
5032 
    None, # 0
483 rajveer 5033 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 5034 
  )
5035 
 
483 rajveer 5036 
  def __init__(self, order=None,):
5037 
    self.order = order
94 ashish 5038 
 
5039 
  def read(self, iprot):
5040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5042 
      return
5043 
    iprot.readStructBegin()
5044 
    while True:
5045 
      (fname, ftype, fid) = iprot.readFieldBegin()
5046 
      if ftype == TType.STOP:
5047 
        break
5048 
      if fid == 1:
483 rajveer 5049 
        if ftype == TType.STRUCT:
5050 
          self.order = Order()
5051 
          self.order.read(iprot)
94 ashish 5052 
        else:
5053 
          iprot.skip(ftype)
5054 
      else:
5055 
        iprot.skip(ftype)
5056 
      iprot.readFieldEnd()
5057 
    iprot.readStructEnd()
5058 
 
5059 
  def write(self, oprot):
5060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5062 
      return
483 rajveer 5063 
    oprot.writeStructBegin('createOrder_args')
5064 
    if self.order != None:
5065 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
5066 
      self.order.write(oprot)
94 ashish 5067 
      oprot.writeFieldEnd()
5068 
    oprot.writeFieldStop()
5069 
    oprot.writeStructEnd()
5070 
 
5071 
  def __repr__(self):
5072 
    L = ['%s=%r' % (key, value)
5073 
      for key, value in self.__dict__.iteritems()]
5074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5075 
 
5076 
  def __eq__(self, other):
5077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5078 
 
5079 
  def __ne__(self, other):
5080 
    return not (self == other)
5081 
 
483 rajveer 5082 
class createOrder_result:
94 ashish 5083 
  """
5084 
  Attributes:
5085 
   - success
5086 
   - ex
5087 
  """
5088 
 
5089 
  thrift_spec = (
483 rajveer 5090 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5092 
  )
5093 
 
5094 
  def __init__(self, success=None, ex=None,):
5095 
    self.success = success
5096 
    self.ex = ex
5097 
 
5098 
  def read(self, iprot):
5099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5101 
      return
5102 
    iprot.readStructBegin()
5103 
    while True:
5104 
      (fname, ftype, fid) = iprot.readFieldBegin()
5105 
      if ftype == TType.STOP:
5106 
        break
5107 
      if fid == 0:
483 rajveer 5108 
        if ftype == TType.I64:
5109 
          self.success = iprot.readI64();
94 ashish 5110 
        else:
5111 
          iprot.skip(ftype)
5112 
      elif fid == 1:
5113 
        if ftype == TType.STRUCT:
5114 
          self.ex = TransactionServiceException()
5115 
          self.ex.read(iprot)
5116 
        else:
5117 
          iprot.skip(ftype)
5118 
      else:
5119 
        iprot.skip(ftype)
5120 
      iprot.readFieldEnd()
5121 
    iprot.readStructEnd()
5122 
 
5123 
  def write(self, oprot):
5124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5126 
      return
483 rajveer 5127 
    oprot.writeStructBegin('createOrder_result')
94 ashish 5128 
    if self.success != None:
483 rajveer 5129 
      oprot.writeFieldBegin('success', TType.I64, 0)
5130 
      oprot.writeI64(self.success)
94 ashish 5131 
      oprot.writeFieldEnd()
5132 
    if self.ex != None:
5133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5134 
      self.ex.write(oprot)
5135 
      oprot.writeFieldEnd()
5136 
    oprot.writeFieldStop()
5137 
    oprot.writeStructEnd()
5138 
 
5139 
  def __repr__(self):
5140 
    L = ['%s=%r' % (key, value)
5141 
      for key, value in self.__dict__.iteritems()]
5142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5143 
 
5144 
  def __eq__(self, other):
5145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5146 
 
5147 
  def __ne__(self, other):
5148 
    return not (self == other)
5149 
 
483 rajveer 5150 
class getOrder_args:
94 ashish 5151 
  """
5152 
  Attributes:
483 rajveer 5153 
   - id
94 ashish 5154 
  """
5155 
 
5156 
  thrift_spec = (
5157 
    None, # 0
483 rajveer 5158 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 5159 
  )
5160 
 
483 rajveer 5161 
  def __init__(self, id=None,):
5162 
    self.id = id
94 ashish 5163 
 
5164 
  def read(self, iprot):
5165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5167 
      return
5168 
    iprot.readStructBegin()
5169 
    while True:
5170 
      (fname, ftype, fid) = iprot.readFieldBegin()
5171 
      if ftype == TType.STOP:
5172 
        break
5173 
      if fid == 1:
5174 
        if ftype == TType.I64:
483 rajveer 5175 
          self.id = iprot.readI64();
94 ashish 5176 
        else:
5177 
          iprot.skip(ftype)
5178 
      else:
5179 
        iprot.skip(ftype)
5180 
      iprot.readFieldEnd()
5181 
    iprot.readStructEnd()
5182 
 
5183 
  def write(self, oprot):
5184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5186 
      return
483 rajveer 5187 
    oprot.writeStructBegin('getOrder_args')
5188 
    if self.id != None:
5189 
      oprot.writeFieldBegin('id', TType.I64, 1)
5190 
      oprot.writeI64(self.id)
94 ashish 5191 
      oprot.writeFieldEnd()
5192 
    oprot.writeFieldStop()
5193 
    oprot.writeStructEnd()
5194 
 
5195 
  def __repr__(self):
5196 
    L = ['%s=%r' % (key, value)
5197 
      for key, value in self.__dict__.iteritems()]
5198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5199 
 
5200 
  def __eq__(self, other):
5201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5202 
 
5203 
  def __ne__(self, other):
5204 
    return not (self == other)
5205 
 
483 rajveer 5206 
class getOrder_result:
94 ashish 5207 
  """
5208 
  Attributes:
5209 
   - success
5210 
   - ex
5211 
  """
5212 
 
5213 
  thrift_spec = (
483 rajveer 5214 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 5215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5216 
  )
5217 
 
5218 
  def __init__(self, success=None, ex=None,):
5219 
    self.success = success
5220 
    self.ex = ex
5221 
 
5222 
  def read(self, iprot):
5223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5225 
      return
5226 
    iprot.readStructBegin()
5227 
    while True:
5228 
      (fname, ftype, fid) = iprot.readFieldBegin()
5229 
      if ftype == TType.STOP:
5230 
        break
5231 
      if fid == 0:
483 rajveer 5232 
        if ftype == TType.STRUCT:
5233 
          self.success = Order()
5234 
          self.success.read(iprot)
94 ashish 5235 
        else:
5236 
          iprot.skip(ftype)
5237 
      elif fid == 1:
5238 
        if ftype == TType.STRUCT:
5239 
          self.ex = TransactionServiceException()
5240 
          self.ex.read(iprot)
5241 
        else:
5242 
          iprot.skip(ftype)
5243 
      else:
5244 
        iprot.skip(ftype)
5245 
      iprot.readFieldEnd()
5246 
    iprot.readStructEnd()
5247 
 
5248 
  def write(self, oprot):
5249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5251 
      return
483 rajveer 5252 
    oprot.writeStructBegin('getOrder_result')
94 ashish 5253 
    if self.success != None:
483 rajveer 5254 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5255 
      self.success.write(oprot)
94 ashish 5256 
      oprot.writeFieldEnd()
5257 
    if self.ex != None:
5258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5259 
      self.ex.write(oprot)
5260 
      oprot.writeFieldEnd()
5261 
    oprot.writeFieldStop()
5262 
    oprot.writeStructEnd()
5263 
 
5264 
  def __repr__(self):
5265 
    L = ['%s=%r' % (key, value)
5266 
      for key, value in self.__dict__.iteritems()]
5267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5268 
 
5269 
  def __eq__(self, other):
5270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5271 
 
5272 
  def __ne__(self, other):
5273 
    return not (self == other)
5274 
 
483 rajveer 5275 
class getLineItemsForOrder_args:
94 ashish 5276 
  """
5277 
  Attributes:
483 rajveer 5278 
   - orderId
94 ashish 5279 
  """
5280 
 
5281 
  thrift_spec = (
5282 
    None, # 0
483 rajveer 5283 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 5284 
  )
5285 
 
483 rajveer 5286 
  def __init__(self, orderId=None,):
5287 
    self.orderId = orderId
94 ashish 5288 
 
5289 
  def read(self, iprot):
5290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5292 
      return
5293 
    iprot.readStructBegin()
5294 
    while True:
5295 
      (fname, ftype, fid) = iprot.readFieldBegin()
5296 
      if ftype == TType.STOP:
5297 
        break
5298 
      if fid == 1:
5299 
        if ftype == TType.I64:
483 rajveer 5300 
          self.orderId = iprot.readI64();
94 ashish 5301 
        else:
5302 
          iprot.skip(ftype)
5303 
      else:
5304 
        iprot.skip(ftype)
5305 
      iprot.readFieldEnd()
5306 
    iprot.readStructEnd()
5307 
 
5308 
  def write(self, oprot):
5309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5311 
      return
483 rajveer 5312 
    oprot.writeStructBegin('getLineItemsForOrder_args')
5313 
    if self.orderId != None:
5314 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5315 
      oprot.writeI64(self.orderId)
94 ashish 5316 
      oprot.writeFieldEnd()
5317 
    oprot.writeFieldStop()
5318 
    oprot.writeStructEnd()
5319 
 
5320 
  def __repr__(self):
5321 
    L = ['%s=%r' % (key, value)
5322 
      for key, value in self.__dict__.iteritems()]
5323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5324 
 
5325 
  def __eq__(self, other):
5326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5327 
 
5328 
  def __ne__(self, other):
5329 
    return not (self == other)
5330 
 
483 rajveer 5331 
class getLineItemsForOrder_result:
94 ashish 5332 
  """
5333 
  Attributes:
5334 
   - success
5335 
   - ex
5336 
  """
5337 
 
5338 
  thrift_spec = (
483 rajveer 5339 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 5340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5341 
  )
5342 
 
5343 
  def __init__(self, success=None, ex=None,):
5344 
    self.success = success
5345 
    self.ex = ex
5346 
 
5347 
  def read(self, iprot):
5348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5350 
      return
5351 
    iprot.readStructBegin()
5352 
    while True:
5353 
      (fname, ftype, fid) = iprot.readFieldBegin()
5354 
      if ftype == TType.STOP:
5355 
        break
5356 
      if fid == 0:
483 rajveer 5357 
        if ftype == TType.LIST:
5358 
          self.success = []
1382 varun.gupt 5359 
          (_etype73, _size70) = iprot.readListBegin()
5360 
          for _i74 in xrange(_size70):
5361 
            _elem75 = LineItem()
5362 
            _elem75.read(iprot)
5363 
            self.success.append(_elem75)
483 rajveer 5364 
          iprot.readListEnd()
94 ashish 5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      elif fid == 1:
5368 
        if ftype == TType.STRUCT:
5369 
          self.ex = TransactionServiceException()
5370 
          self.ex.read(iprot)
5371 
        else:
5372 
          iprot.skip(ftype)
5373 
      else:
5374 
        iprot.skip(ftype)
5375 
      iprot.readFieldEnd()
5376 
    iprot.readStructEnd()
5377 
 
5378 
  def write(self, oprot):
5379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5381 
      return
483 rajveer 5382 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 5383 
    if self.success != None:
483 rajveer 5384 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5385 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5386 
      for iter76 in self.success:
5387 
        iter76.write(oprot)
483 rajveer 5388 
      oprot.writeListEnd()
94 ashish 5389 
      oprot.writeFieldEnd()
5390 
    if self.ex != None:
5391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5392 
      self.ex.write(oprot)
5393 
      oprot.writeFieldEnd()
5394 
    oprot.writeFieldStop()
5395 
    oprot.writeStructEnd()
5396 
 
5397 
  def __repr__(self):
5398 
    L = ['%s=%r' % (key, value)
5399 
      for key, value in self.__dict__.iteritems()]
5400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5401 
 
5402 
  def __eq__(self, other):
5403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5404 
 
5405 
  def __ne__(self, other):
5406 
    return not (self == other)
5407 
 
1528 ankur.sing 5408 
class getOrderForCustomer_args:
5409 
  """
5410 
  Attributes:
5411 
   - orderId
5412 
   - customerId
5413 
  """
5414 
 
5415 
  thrift_spec = (
5416 
    None, # 0
5417 
    (1, TType.I64, 'orderId', None, None, ), # 1
5418 
    (2, TType.I64, 'customerId', None, None, ), # 2
5419 
  )
5420 
 
5421 
  def __init__(self, orderId=None, customerId=None,):
5422 
    self.orderId = orderId
5423 
    self.customerId = customerId
5424 
 
5425 
  def read(self, iprot):
5426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5428 
      return
5429 
    iprot.readStructBegin()
5430 
    while True:
5431 
      (fname, ftype, fid) = iprot.readFieldBegin()
5432 
      if ftype == TType.STOP:
5433 
        break
5434 
      if fid == 1:
5435 
        if ftype == TType.I64:
5436 
          self.orderId = iprot.readI64();
5437 
        else:
5438 
          iprot.skip(ftype)
5439 
      elif fid == 2:
5440 
        if ftype == TType.I64:
5441 
          self.customerId = iprot.readI64();
5442 
        else:
5443 
          iprot.skip(ftype)
5444 
      else:
5445 
        iprot.skip(ftype)
5446 
      iprot.readFieldEnd()
5447 
    iprot.readStructEnd()
5448 
 
5449 
  def write(self, oprot):
5450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5452 
      return
5453 
    oprot.writeStructBegin('getOrderForCustomer_args')
5454 
    if self.orderId != None:
5455 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5456 
      oprot.writeI64(self.orderId)
5457 
      oprot.writeFieldEnd()
5458 
    if self.customerId != None:
5459 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5460 
      oprot.writeI64(self.customerId)
5461 
      oprot.writeFieldEnd()
5462 
    oprot.writeFieldStop()
5463 
    oprot.writeStructEnd()
5464 
 
5465 
  def __repr__(self):
5466 
    L = ['%s=%r' % (key, value)
5467 
      for key, value in self.__dict__.iteritems()]
5468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5469 
 
5470 
  def __eq__(self, other):
5471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5472 
 
5473 
  def __ne__(self, other):
5474 
    return not (self == other)
5475 
 
5476 
class getOrderForCustomer_result:
5477 
  """
5478 
  Attributes:
5479 
   - success
5480 
   - ex
5481 
  """
5482 
 
5483 
  thrift_spec = (
5484 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
5485 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5486 
  )
5487 
 
5488 
  def __init__(self, success=None, ex=None,):
5489 
    self.success = success
5490 
    self.ex = ex
5491 
 
5492 
  def read(self, iprot):
5493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5495 
      return
5496 
    iprot.readStructBegin()
5497 
    while True:
5498 
      (fname, ftype, fid) = iprot.readFieldBegin()
5499 
      if ftype == TType.STOP:
5500 
        break
5501 
      if fid == 0:
5502 
        if ftype == TType.STRUCT:
5503 
          self.success = Order()
5504 
          self.success.read(iprot)
5505 
        else:
5506 
          iprot.skip(ftype)
5507 
      elif fid == 1:
5508 
        if ftype == TType.STRUCT:
5509 
          self.ex = TransactionServiceException()
5510 
          self.ex.read(iprot)
5511 
        else:
5512 
          iprot.skip(ftype)
5513 
      else:
5514 
        iprot.skip(ftype)
5515 
      iprot.readFieldEnd()
5516 
    iprot.readStructEnd()
5517 
 
5518 
  def write(self, oprot):
5519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5521 
      return
5522 
    oprot.writeStructBegin('getOrderForCustomer_result')
5523 
    if self.success != None:
5524 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5525 
      self.success.write(oprot)
5526 
      oprot.writeFieldEnd()
5527 
    if self.ex != None:
5528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5529 
      self.ex.write(oprot)
5530 
      oprot.writeFieldEnd()
5531 
    oprot.writeFieldStop()
5532 
    oprot.writeStructEnd()
5533 
 
5534 
  def __repr__(self):
5535 
    L = ['%s=%r' % (key, value)
5536 
      for key, value in self.__dict__.iteritems()]
5537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5538 
 
5539 
  def __eq__(self, other):
5540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5541 
 
5542 
  def __ne__(self, other):
5543 
    return not (self == other)
5544 
 
1220 chandransh 5545 
class batchOrders_args:
5546 
  """
5547 
  Attributes:
5548 
   - warehouseId
5549 
  """
5550 
 
5551 
  thrift_spec = (
5552 
    None, # 0
5553 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
5554 
  )
5555 
 
5556 
  def __init__(self, warehouseId=None,):
5557 
    self.warehouseId = warehouseId
5558 
 
5559 
  def read(self, iprot):
5560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5562 
      return
5563 
    iprot.readStructBegin()
5564 
    while True:
5565 
      (fname, ftype, fid) = iprot.readFieldBegin()
5566 
      if ftype == TType.STOP:
5567 
        break
5568 
      if fid == 1:
5569 
        if ftype == TType.I64:
5570 
          self.warehouseId = iprot.readI64();
5571 
        else:
5572 
          iprot.skip(ftype)
5573 
      else:
5574 
        iprot.skip(ftype)
5575 
      iprot.readFieldEnd()
5576 
    iprot.readStructEnd()
5577 
 
5578 
  def write(self, oprot):
5579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5581 
      return
5582 
    oprot.writeStructBegin('batchOrders_args')
5583 
    if self.warehouseId != None:
5584 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
5585 
      oprot.writeI64(self.warehouseId)
5586 
      oprot.writeFieldEnd()
5587 
    oprot.writeFieldStop()
5588 
    oprot.writeStructEnd()
5589 
 
5590 
  def __repr__(self):
5591 
    L = ['%s=%r' % (key, value)
5592 
      for key, value in self.__dict__.iteritems()]
5593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5594 
 
5595 
  def __eq__(self, other):
5596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5597 
 
5598 
  def __ne__(self, other):
5599 
    return not (self == other)
5600 
 
5601 
class batchOrders_result:
5602 
  """
5603 
  Attributes:
5604 
   - success
5605 
   - ex
5606 
  """
5607 
 
5608 
  thrift_spec = (
5609 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
5610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5611 
  )
5612 
 
5613 
  def __init__(self, success=None, ex=None,):
5614 
    self.success = success
5615 
    self.ex = ex
5616 
 
5617 
  def read(self, iprot):
5618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5620 
      return
5621 
    iprot.readStructBegin()
5622 
    while True:
5623 
      (fname, ftype, fid) = iprot.readFieldBegin()
5624 
      if ftype == TType.STOP:
5625 
        break
5626 
      if fid == 0:
5627 
        if ftype == TType.LIST:
5628 
          self.success = []
1382 varun.gupt 5629 
          (_etype80, _size77) = iprot.readListBegin()
5630 
          for _i81 in xrange(_size77):
5631 
            _elem82 = Order()
5632 
            _elem82.read(iprot)
5633 
            self.success.append(_elem82)
1220 chandransh 5634 
          iprot.readListEnd()
5635 
        else:
5636 
          iprot.skip(ftype)
5637 
      elif fid == 1:
5638 
        if ftype == TType.STRUCT:
5639 
          self.ex = TransactionServiceException()
5640 
          self.ex.read(iprot)
5641 
        else:
5642 
          iprot.skip(ftype)
5643 
      else:
5644 
        iprot.skip(ftype)
5645 
      iprot.readFieldEnd()
5646 
    iprot.readStructEnd()
5647 
 
5648 
  def write(self, oprot):
5649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5651 
      return
5652 
    oprot.writeStructBegin('batchOrders_result')
5653 
    if self.success != None:
5654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5655 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5656 
      for iter83 in self.success:
5657 
        iter83.write(oprot)
1220 chandransh 5658 
      oprot.writeListEnd()
5659 
      oprot.writeFieldEnd()
5660 
    if self.ex != None:
5661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5662 
      self.ex.write(oprot)
5663 
      oprot.writeFieldEnd()
5664 
    oprot.writeFieldStop()
5665 
    oprot.writeStructEnd()
5666 
 
5667 
  def __repr__(self):
5668 
    L = ['%s=%r' % (key, value)
5669 
      for key, value in self.__dict__.iteritems()]
5670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5671 
 
5672 
  def __eq__(self, other):
5673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5674 
 
5675 
  def __ne__(self, other):
5676 
    return not (self == other)
5677 
 
1208 chandransh 5678 
class markOrderAsOutOfStock_args:
5679 
  """
5680 
  Attributes:
5681 
   - orderId
5682 
  """
5683 
 
5684 
  thrift_spec = (
5685 
    None, # 0
5686 
    (1, TType.I64, 'orderId', None, None, ), # 1
5687 
  )
5688 
 
5689 
  def __init__(self, orderId=None,):
5690 
    self.orderId = orderId
5691 
 
5692 
  def read(self, iprot):
5693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5695 
      return
5696 
    iprot.readStructBegin()
5697 
    while True:
5698 
      (fname, ftype, fid) = iprot.readFieldBegin()
5699 
      if ftype == TType.STOP:
5700 
        break
5701 
      if fid == 1:
5702 
        if ftype == TType.I64:
5703 
          self.orderId = iprot.readI64();
5704 
        else:
5705 
          iprot.skip(ftype)
5706 
      else:
5707 
        iprot.skip(ftype)
5708 
      iprot.readFieldEnd()
5709 
    iprot.readStructEnd()
5710 
 
5711 
  def write(self, oprot):
5712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5714 
      return
5715 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
5716 
    if self.orderId != None:
5717 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5718 
      oprot.writeI64(self.orderId)
5719 
      oprot.writeFieldEnd()
5720 
    oprot.writeFieldStop()
5721 
    oprot.writeStructEnd()
5722 
 
5723 
  def __repr__(self):
5724 
    L = ['%s=%r' % (key, value)
5725 
      for key, value in self.__dict__.iteritems()]
5726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5727 
 
5728 
  def __eq__(self, other):
5729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5730 
 
5731 
  def __ne__(self, other):
5732 
    return not (self == other)
5733 
 
5734 
class markOrderAsOutOfStock_result:
5735 
  """
5736 
  Attributes:
5737 
   - success
5738 
   - ex
5739 
  """
5740 
 
5741 
  thrift_spec = (
5742 
    (0, TType.BOOL, 'success', None, None, ), # 0
5743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5744 
  )
5745 
 
5746 
  def __init__(self, success=None, ex=None,):
5747 
    self.success = success
5748 
    self.ex = ex
5749 
 
5750 
  def read(self, iprot):
5751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5753 
      return
5754 
    iprot.readStructBegin()
5755 
    while True:
5756 
      (fname, ftype, fid) = iprot.readFieldBegin()
5757 
      if ftype == TType.STOP:
5758 
        break
5759 
      if fid == 0:
5760 
        if ftype == TType.BOOL:
5761 
          self.success = iprot.readBool();
5762 
        else:
5763 
          iprot.skip(ftype)
5764 
      elif fid == 1:
5765 
        if ftype == TType.STRUCT:
5766 
          self.ex = TransactionServiceException()
5767 
          self.ex.read(iprot)
5768 
        else:
5769 
          iprot.skip(ftype)
5770 
      else:
5771 
        iprot.skip(ftype)
5772 
      iprot.readFieldEnd()
5773 
    iprot.readStructEnd()
5774 
 
5775 
  def write(self, oprot):
5776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5778 
      return
5779 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
5780 
    if self.success != None:
5781 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5782 
      oprot.writeBool(self.success)
5783 
      oprot.writeFieldEnd()
5784 
    if self.ex != None:
5785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5786 
      self.ex.write(oprot)
5787 
      oprot.writeFieldEnd()
5788 
    oprot.writeFieldStop()
5789 
    oprot.writeStructEnd()
5790 
 
5791 
  def __repr__(self):
5792 
    L = ['%s=%r' % (key, value)
5793 
      for key, value in self.__dict__.iteritems()]
5794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5795 
 
5796 
  def __eq__(self, other):
5797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5798 
 
5799 
  def __ne__(self, other):
5800 
    return not (self == other)
5801 
 
759 chandransh 5802 
class markOrdersAsManifested_args:
5803 
  """
5804 
  Attributes:
5805 
   - warehouseId
5806 
   - providerId
5807 
  """
5808 
 
5809 
  thrift_spec = (
5810 
    None, # 0
5811 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
5812 
    (2, TType.I64, 'providerId', None, None, ), # 2
5813 
  )
5814 
 
5815 
  def __init__(self, warehouseId=None, providerId=None,):
5816 
    self.warehouseId = warehouseId
5817 
    self.providerId = providerId
5818 
 
5819 
  def read(self, iprot):
5820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5822 
      return
5823 
    iprot.readStructBegin()
5824 
    while True:
5825 
      (fname, ftype, fid) = iprot.readFieldBegin()
5826 
      if ftype == TType.STOP:
5827 
        break
5828 
      if fid == 1:
5829 
        if ftype == TType.I64:
5830 
          self.warehouseId = iprot.readI64();
5831 
        else:
5832 
          iprot.skip(ftype)
5833 
      elif fid == 2:
5834 
        if ftype == TType.I64:
5835 
          self.providerId = iprot.readI64();
5836 
        else:
5837 
          iprot.skip(ftype)
5838 
      else:
5839 
        iprot.skip(ftype)
5840 
      iprot.readFieldEnd()
5841 
    iprot.readStructEnd()
5842 
 
5843 
  def write(self, oprot):
5844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5846 
      return
5847 
    oprot.writeStructBegin('markOrdersAsManifested_args')
5848 
    if self.warehouseId != None:
5849 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
5850 
      oprot.writeI64(self.warehouseId)
5851 
      oprot.writeFieldEnd()
5852 
    if self.providerId != None:
5853 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
5854 
      oprot.writeI64(self.providerId)
5855 
      oprot.writeFieldEnd()
5856 
    oprot.writeFieldStop()
5857 
    oprot.writeStructEnd()
5858 
 
5859 
  def __repr__(self):
5860 
    L = ['%s=%r' % (key, value)
5861 
      for key, value in self.__dict__.iteritems()]
5862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5863 
 
5864 
  def __eq__(self, other):
5865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5866 
 
5867 
  def __ne__(self, other):
5868 
    return not (self == other)
5869 
 
5870 
class markOrdersAsManifested_result:
5871 
  """
5872 
  Attributes:
5873 
   - success
5874 
   - ex
5875 
  """
5876 
 
5877 
  thrift_spec = (
5878 
    (0, TType.BOOL, 'success', None, None, ), # 0
5879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5880 
  )
5881 
 
5882 
  def __init__(self, success=None, ex=None,):
5883 
    self.success = success
5884 
    self.ex = ex
5885 
 
5886 
  def read(self, iprot):
5887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5889 
      return
5890 
    iprot.readStructBegin()
5891 
    while True:
5892 
      (fname, ftype, fid) = iprot.readFieldBegin()
5893 
      if ftype == TType.STOP:
5894 
        break
5895 
      if fid == 0:
5896 
        if ftype == TType.BOOL:
5897 
          self.success = iprot.readBool();
5898 
        else:
5899 
          iprot.skip(ftype)
5900 
      elif fid == 1:
5901 
        if ftype == TType.STRUCT:
5902 
          self.ex = TransactionServiceException()
5903 
          self.ex.read(iprot)
5904 
        else:
5905 
          iprot.skip(ftype)
5906 
      else:
5907 
        iprot.skip(ftype)
5908 
      iprot.readFieldEnd()
5909 
    iprot.readStructEnd()
5910 
 
5911 
  def write(self, oprot):
5912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5914 
      return
5915 
    oprot.writeStructBegin('markOrdersAsManifested_result')
5916 
    if self.success != None:
5917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5918 
      oprot.writeBool(self.success)
5919 
      oprot.writeFieldEnd()
5920 
    if self.ex != None:
5921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5922 
      self.ex.write(oprot)
5923 
      oprot.writeFieldEnd()
5924 
    oprot.writeFieldStop()
5925 
    oprot.writeStructEnd()
5926 
 
5927 
  def __repr__(self):
5928 
    L = ['%s=%r' % (key, value)
5929 
      for key, value in self.__dict__.iteritems()]
5930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5931 
 
5932 
  def __eq__(self, other):
5933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5934 
 
5935 
  def __ne__(self, other):
5936 
    return not (self == other)
5937 
 
1113 chandransh 5938 
class markOrdersAsPickedUp_args:
5939 
  """
5940 
  Attributes:
5941 
   - providerId
5942 
   - pickupDetails
5943 
  """
5944 
 
5945 
  thrift_spec = (
5946 
    None, # 0
5947 
    (1, TType.I64, 'providerId', None, None, ), # 1
1246 chandransh 5948 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
1113 chandransh 5949 
  )
5950 
 
5951 
  def __init__(self, providerId=None, pickupDetails=None,):
5952 
    self.providerId = providerId
5953 
    self.pickupDetails = pickupDetails
5954 
 
5955 
  def read(self, iprot):
5956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5958 
      return
5959 
    iprot.readStructBegin()
5960 
    while True:
5961 
      (fname, ftype, fid) = iprot.readFieldBegin()
5962 
      if ftype == TType.STOP:
5963 
        break
5964 
      if fid == 1:
5965 
        if ftype == TType.I64:
5966 
          self.providerId = iprot.readI64();
5967 
        else:
5968 
          iprot.skip(ftype)
5969 
      elif fid == 2:
5970 
        if ftype == TType.MAP:
5971 
          self.pickupDetails = {}
1382 varun.gupt 5972 
          (_ktype85, _vtype86, _size84 ) = iprot.readMapBegin()
5973 
          for _i88 in xrange(_size84):
5974 
            _key89 = iprot.readString();
5975 
            _val90 = iprot.readString();
5976 
            self.pickupDetails[_key89] = _val90
1113 chandransh 5977 
          iprot.readMapEnd()
5978 
        else:
5979 
          iprot.skip(ftype)
5980 
      else:
5981 
        iprot.skip(ftype)
5982 
      iprot.readFieldEnd()
5983 
    iprot.readStructEnd()
5984 
 
5985 
  def write(self, oprot):
5986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5988 
      return
5989 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
5990 
    if self.providerId != None:
5991 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
5992 
      oprot.writeI64(self.providerId)
5993 
      oprot.writeFieldEnd()
5994 
    if self.pickupDetails != None:
5995 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
1246 chandransh 5996 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
1382 varun.gupt 5997 
      for kiter91,viter92 in self.pickupDetails.items():
5998 
        oprot.writeString(kiter91)
5999 
        oprot.writeString(viter92)
1113 chandransh 6000 
      oprot.writeMapEnd()
6001 
      oprot.writeFieldEnd()
6002 
    oprot.writeFieldStop()
6003 
    oprot.writeStructEnd()
6004 
 
6005 
  def __repr__(self):
6006 
    L = ['%s=%r' % (key, value)
6007 
      for key, value in self.__dict__.iteritems()]
6008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6009 
 
6010 
  def __eq__(self, other):
6011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6012 
 
6013 
  def __ne__(self, other):
6014 
    return not (self == other)
6015 
 
6016 
class markOrdersAsPickedUp_result:
6017 
  """
6018 
  Attributes:
6019 
   - success
6020 
   - ex
6021 
  """
6022 
 
6023 
  thrift_spec = (
6024 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6026 
  )
6027 
 
6028 
  def __init__(self, success=None, ex=None,):
6029 
    self.success = success
6030 
    self.ex = ex
6031 
 
6032 
  def read(self, iprot):
6033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6035 
      return
6036 
    iprot.readStructBegin()
6037 
    while True:
6038 
      (fname, ftype, fid) = iprot.readFieldBegin()
6039 
      if ftype == TType.STOP:
6040 
        break
6041 
      if fid == 0:
6042 
        if ftype == TType.LIST:
6043 
          self.success = []
1382 varun.gupt 6044 
          (_etype96, _size93) = iprot.readListBegin()
6045 
          for _i97 in xrange(_size93):
6046 
            _elem98 = Order()
6047 
            _elem98.read(iprot)
6048 
            self.success.append(_elem98)
1113 chandransh 6049 
          iprot.readListEnd()
6050 
        else:
6051 
          iprot.skip(ftype)
6052 
      elif fid == 1:
6053 
        if ftype == TType.STRUCT:
6054 
          self.ex = TransactionServiceException()
6055 
          self.ex.read(iprot)
6056 
        else:
6057 
          iprot.skip(ftype)
6058 
      else:
6059 
        iprot.skip(ftype)
6060 
      iprot.readFieldEnd()
6061 
    iprot.readStructEnd()
6062 
 
6063 
  def write(self, oprot):
6064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6066 
      return
6067 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
6068 
    if self.success != None:
6069 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6070 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 6071 
      for iter99 in self.success:
6072 
        iter99.write(oprot)
1113 chandransh 6073 
      oprot.writeListEnd()
6074 
      oprot.writeFieldEnd()
6075 
    if self.ex != None:
6076 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6077 
      self.ex.write(oprot)
6078 
      oprot.writeFieldEnd()
6079 
    oprot.writeFieldStop()
6080 
    oprot.writeStructEnd()
6081 
 
6082 
  def __repr__(self):
6083 
    L = ['%s=%r' % (key, value)
6084 
      for key, value in self.__dict__.iteritems()]
6085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6086 
 
6087 
  def __eq__(self, other):
6088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6089 
 
6090 
  def __ne__(self, other):
6091 
    return not (self == other)
6092 
 
1132 chandransh 6093 
class markOrdersAsDelivered_args:
6094 
  """
6095 
  Attributes:
6096 
   - providerId
6097 
   - deliveredOrders
6098 
  """
6099 
 
6100 
  thrift_spec = (
6101 
    None, # 0
6102 
    (1, TType.I64, 'providerId', None, None, ), # 1
6103 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6104 
  )
6105 
 
6106 
  def __init__(self, providerId=None, deliveredOrders=None,):
6107 
    self.providerId = providerId
6108 
    self.deliveredOrders = deliveredOrders
6109 
 
6110 
  def read(self, iprot):
6111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6113 
      return
6114 
    iprot.readStructBegin()
6115 
    while True:
6116 
      (fname, ftype, fid) = iprot.readFieldBegin()
6117 
      if ftype == TType.STOP:
6118 
        break
6119 
      if fid == 1:
6120 
        if ftype == TType.I64:
6121 
          self.providerId = iprot.readI64();
6122 
        else:
6123 
          iprot.skip(ftype)
6124 
      elif fid == 2:
6125 
        if ftype == TType.MAP:
6126 
          self.deliveredOrders = {}
1382 varun.gupt 6127 
          (_ktype101, _vtype102, _size100 ) = iprot.readMapBegin()
6128 
          for _i104 in xrange(_size100):
6129 
            _key105 = iprot.readString();
6130 
            _val106 = iprot.readString();
6131 
            self.deliveredOrders[_key105] = _val106
1132 chandransh 6132 
          iprot.readMapEnd()
6133 
        else:
6134 
          iprot.skip(ftype)
6135 
      else:
6136 
        iprot.skip(ftype)
6137 
      iprot.readFieldEnd()
6138 
    iprot.readStructEnd()
6139 
 
6140 
  def write(self, oprot):
6141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6143 
      return
6144 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
6145 
    if self.providerId != None:
6146 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6147 
      oprot.writeI64(self.providerId)
6148 
      oprot.writeFieldEnd()
6149 
    if self.deliveredOrders != None:
6150 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
6151 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
1382 varun.gupt 6152 
      for kiter107,viter108 in self.deliveredOrders.items():
6153 
        oprot.writeString(kiter107)
6154 
        oprot.writeString(viter108)
1132 chandransh 6155 
      oprot.writeMapEnd()
6156 
      oprot.writeFieldEnd()
6157 
    oprot.writeFieldStop()
6158 
    oprot.writeStructEnd()
6159 
 
6160 
  def __repr__(self):
6161 
    L = ['%s=%r' % (key, value)
6162 
      for key, value in self.__dict__.iteritems()]
6163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6164 
 
6165 
  def __eq__(self, other):
6166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6167 
 
6168 
  def __ne__(self, other):
6169 
    return not (self == other)
6170 
 
6171 
class markOrdersAsDelivered_result:
6172 
  """
6173 
  Attributes:
6174 
   - ex
6175 
  """
6176 
 
6177 
  thrift_spec = (
6178 
    None, # 0
6179 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6180 
  )
6181 
 
6182 
  def __init__(self, ex=None,):
6183 
    self.ex = ex
6184 
 
6185 
  def read(self, iprot):
6186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6188 
      return
6189 
    iprot.readStructBegin()
6190 
    while True:
6191 
      (fname, ftype, fid) = iprot.readFieldBegin()
6192 
      if ftype == TType.STOP:
6193 
        break
6194 
      if fid == 1:
6195 
        if ftype == TType.STRUCT:
6196 
          self.ex = TransactionServiceException()
6197 
          self.ex.read(iprot)
6198 
        else:
6199 
          iprot.skip(ftype)
6200 
      else:
6201 
        iprot.skip(ftype)
6202 
      iprot.readFieldEnd()
6203 
    iprot.readStructEnd()
6204 
 
6205 
  def write(self, oprot):
6206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6208 
      return
6209 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
6210 
    if self.ex != None:
6211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6212 
      self.ex.write(oprot)
6213 
      oprot.writeFieldEnd()
6214 
    oprot.writeFieldStop()
6215 
    oprot.writeStructEnd()
6216 
 
6217 
  def __repr__(self):
6218 
    L = ['%s=%r' % (key, value)
6219 
      for key, value in self.__dict__.iteritems()]
6220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6221 
 
6222 
  def __eq__(self, other):
6223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6224 
 
6225 
  def __ne__(self, other):
6226 
    return not (self == other)
6227 
 
1135 chandransh 6228 
class markOrdersAsFailed_args:
6229 
  """
6230 
  Attributes:
6231 
   - providerId
6232 
   - returnedOrders
6233 
  """
6234 
 
6235 
  thrift_spec = (
6236 
    None, # 0
6237 
    (1, TType.I64, 'providerId', None, None, ), # 1
6238 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6239 
  )
6240 
 
6241 
  def __init__(self, providerId=None, returnedOrders=None,):
6242 
    self.providerId = providerId
6243 
    self.returnedOrders = returnedOrders
6244 
 
6245 
  def read(self, iprot):
6246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6248 
      return
6249 
    iprot.readStructBegin()
6250 
    while True:
6251 
      (fname, ftype, fid) = iprot.readFieldBegin()
6252 
      if ftype == TType.STOP:
6253 
        break
6254 
      if fid == 1:
6255 
        if ftype == TType.I64:
6256 
          self.providerId = iprot.readI64();
6257 
        else:
6258 
          iprot.skip(ftype)
6259 
      elif fid == 2:
6260 
        if ftype == TType.MAP:
6261 
          self.returnedOrders = {}
1382 varun.gupt 6262 
          (_ktype110, _vtype111, _size109 ) = iprot.readMapBegin()
6263 
          for _i113 in xrange(_size109):
6264 
            _key114 = iprot.readString();
6265 
            _val115 = iprot.readString();
6266 
            self.returnedOrders[_key114] = _val115
1135 chandransh 6267 
          iprot.readMapEnd()
6268 
        else:
6269 
          iprot.skip(ftype)
6270 
      else:
6271 
        iprot.skip(ftype)
6272 
      iprot.readFieldEnd()
6273 
    iprot.readStructEnd()
6274 
 
6275 
  def write(self, oprot):
6276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6278 
      return
6279 
    oprot.writeStructBegin('markOrdersAsFailed_args')
6280 
    if self.providerId != None:
6281 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6282 
      oprot.writeI64(self.providerId)
6283 
      oprot.writeFieldEnd()
6284 
    if self.returnedOrders != None:
6285 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
6286 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
1382 varun.gupt 6287 
      for kiter116,viter117 in self.returnedOrders.items():
6288 
        oprot.writeString(kiter116)
6289 
        oprot.writeString(viter117)
1135 chandransh 6290 
      oprot.writeMapEnd()
6291 
      oprot.writeFieldEnd()
6292 
    oprot.writeFieldStop()
6293 
    oprot.writeStructEnd()
6294 
 
6295 
  def __repr__(self):
6296 
    L = ['%s=%r' % (key, value)
6297 
      for key, value in self.__dict__.iteritems()]
6298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6299 
 
6300 
  def __eq__(self, other):
6301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6302 
 
6303 
  def __ne__(self, other):
6304 
    return not (self == other)
6305 
 
6306 
class markOrdersAsFailed_result:
6307 
  """
6308 
  Attributes:
6309 
   - ex
6310 
  """
6311 
 
6312 
  thrift_spec = (
6313 
    None, # 0
6314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6315 
  )
6316 
 
6317 
  def __init__(self, ex=None,):
6318 
    self.ex = ex
6319 
 
6320 
  def read(self, iprot):
6321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6323 
      return
6324 
    iprot.readStructBegin()
6325 
    while True:
6326 
      (fname, ftype, fid) = iprot.readFieldBegin()
6327 
      if ftype == TType.STOP:
6328 
        break
6329 
      if fid == 1:
6330 
        if ftype == TType.STRUCT:
6331 
          self.ex = TransactionServiceException()
6332 
          self.ex.read(iprot)
6333 
        else:
6334 
          iprot.skip(ftype)
6335 
      else:
6336 
        iprot.skip(ftype)
6337 
      iprot.readFieldEnd()
6338 
    iprot.readStructEnd()
6339 
 
6340 
  def write(self, oprot):
6341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6343 
      return
6344 
    oprot.writeStructBegin('markOrdersAsFailed_result')
6345 
    if self.ex != None:
6346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6347 
      self.ex.write(oprot)
6348 
      oprot.writeFieldEnd()
6349 
    oprot.writeFieldStop()
6350 
    oprot.writeStructEnd()
6351 
 
6352 
  def __repr__(self):
6353 
    L = ['%s=%r' % (key, value)
6354 
      for key, value in self.__dict__.iteritems()]
6355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6356 
 
6357 
  def __eq__(self, other):
6358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6359 
 
6360 
  def __ne__(self, other):
6361 
    return not (self == other)
6362 
 
1246 chandransh 6363 
class updateNonDeliveryReason_args:
6364 
  """
6365 
  Attributes:
6366 
   - providerId
6367 
   - undeliveredOrders
6368 
  """
6369 
 
6370 
  thrift_spec = (
6371 
    None, # 0
6372 
    (1, TType.I64, 'providerId', None, None, ), # 1
6373 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6374 
  )
6375 
 
6376 
  def __init__(self, providerId=None, undeliveredOrders=None,):
6377 
    self.providerId = providerId
6378 
    self.undeliveredOrders = undeliveredOrders
6379 
 
6380 
  def read(self, iprot):
6381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6383 
      return
6384 
    iprot.readStructBegin()
6385 
    while True:
6386 
      (fname, ftype, fid) = iprot.readFieldBegin()
6387 
      if ftype == TType.STOP:
6388 
        break
6389 
      if fid == 1:
6390 
        if ftype == TType.I64:
6391 
          self.providerId = iprot.readI64();
6392 
        else:
6393 
          iprot.skip(ftype)
6394 
      elif fid == 2:
6395 
        if ftype == TType.MAP:
6396 
          self.undeliveredOrders = {}
1382 varun.gupt 6397 
          (_ktype119, _vtype120, _size118 ) = iprot.readMapBegin()
6398 
          for _i122 in xrange(_size118):
6399 
            _key123 = iprot.readString();
6400 
            _val124 = iprot.readString();
6401 
            self.undeliveredOrders[_key123] = _val124
1246 chandransh 6402 
          iprot.readMapEnd()
6403 
        else:
6404 
          iprot.skip(ftype)
6405 
      else:
6406 
        iprot.skip(ftype)
6407 
      iprot.readFieldEnd()
6408 
    iprot.readStructEnd()
6409 
 
6410 
  def write(self, oprot):
6411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6413 
      return
6414 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
6415 
    if self.providerId != None:
6416 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6417 
      oprot.writeI64(self.providerId)
6418 
      oprot.writeFieldEnd()
6419 
    if self.undeliveredOrders != None:
6420 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
6421 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
1382 varun.gupt 6422 
      for kiter125,viter126 in self.undeliveredOrders.items():
6423 
        oprot.writeString(kiter125)
6424 
        oprot.writeString(viter126)
1246 chandransh 6425 
      oprot.writeMapEnd()
6426 
      oprot.writeFieldEnd()
6427 
    oprot.writeFieldStop()
6428 
    oprot.writeStructEnd()
6429 
 
6430 
  def __repr__(self):
6431 
    L = ['%s=%r' % (key, value)
6432 
      for key, value in self.__dict__.iteritems()]
6433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6434 
 
6435 
  def __eq__(self, other):
6436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6437 
 
6438 
  def __ne__(self, other):
6439 
    return not (self == other)
6440 
 
6441 
class updateNonDeliveryReason_result:
6442 
  """
6443 
  Attributes:
6444 
   - ex
6445 
  """
6446 
 
6447 
  thrift_spec = (
6448 
    None, # 0
6449 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6450 
  )
6451 
 
6452 
  def __init__(self, ex=None,):
6453 
    self.ex = ex
6454 
 
6455 
  def read(self, iprot):
6456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6458 
      return
6459 
    iprot.readStructBegin()
6460 
    while True:
6461 
      (fname, ftype, fid) = iprot.readFieldBegin()
6462 
      if ftype == TType.STOP:
6463 
        break
6464 
      if fid == 1:
6465 
        if ftype == TType.STRUCT:
6466 
          self.ex = TransactionServiceException()
6467 
          self.ex.read(iprot)
6468 
        else:
6469 
          iprot.skip(ftype)
6470 
      else:
6471 
        iprot.skip(ftype)
6472 
      iprot.readFieldEnd()
6473 
    iprot.readStructEnd()
6474 
 
6475 
  def write(self, oprot):
6476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6478 
      return
6479 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
6480 
    if self.ex != None:
6481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6482 
      self.ex.write(oprot)
6483 
      oprot.writeFieldEnd()
6484 
    oprot.writeFieldStop()
6485 
    oprot.writeStructEnd()
6486 
 
6487 
  def __repr__(self):
6488 
    L = ['%s=%r' % (key, value)
6489 
      for key, value in self.__dict__.iteritems()]
6490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6491 
 
6492 
  def __eq__(self, other):
6493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6494 
 
6495 
  def __ne__(self, other):
6496 
    return not (self == other)
6497 
 
1408 ankur.sing 6498 
class getUndeliveredOrders_args:
6499 
  """
6500 
  Attributes:
6501 
   - providerId
6502 
   - warehouseId
6503 
  """
6504 
 
6505 
  thrift_spec = (
6506 
    None, # 0
6507 
    (1, TType.I64, 'providerId', None, None, ), # 1
6508 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6509 
  )
6510 
 
6511 
  def __init__(self, providerId=None, warehouseId=None,):
6512 
    self.providerId = providerId
6513 
    self.warehouseId = warehouseId
6514 
 
6515 
  def read(self, iprot):
6516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6518 
      return
6519 
    iprot.readStructBegin()
6520 
    while True:
6521 
      (fname, ftype, fid) = iprot.readFieldBegin()
6522 
      if ftype == TType.STOP:
6523 
        break
6524 
      if fid == 1:
6525 
        if ftype == TType.I64:
6526 
          self.providerId = iprot.readI64();
6527 
        else:
6528 
          iprot.skip(ftype)
6529 
      elif fid == 2:
6530 
        if ftype == TType.I64:
6531 
          self.warehouseId = iprot.readI64();
6532 
        else:
6533 
          iprot.skip(ftype)
6534 
      else:
6535 
        iprot.skip(ftype)
6536 
      iprot.readFieldEnd()
6537 
    iprot.readStructEnd()
6538 
 
6539 
  def write(self, oprot):
6540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6542 
      return
6543 
    oprot.writeStructBegin('getUndeliveredOrders_args')
6544 
    if self.providerId != None:
6545 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6546 
      oprot.writeI64(self.providerId)
6547 
      oprot.writeFieldEnd()
6548 
    if self.warehouseId != None:
6549 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
6550 
      oprot.writeI64(self.warehouseId)
6551 
      oprot.writeFieldEnd()
6552 
    oprot.writeFieldStop()
6553 
    oprot.writeStructEnd()
6554 
 
6555 
  def __repr__(self):
6556 
    L = ['%s=%r' % (key, value)
6557 
      for key, value in self.__dict__.iteritems()]
6558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6559 
 
6560 
  def __eq__(self, other):
6561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6562 
 
6563 
  def __ne__(self, other):
6564 
    return not (self == other)
6565 
 
6566 
class getUndeliveredOrders_result:
6567 
  """
6568 
  Attributes:
6569 
   - success
6570 
  """
6571 
 
6572 
  thrift_spec = (
6573 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6574 
  )
6575 
 
6576 
  def __init__(self, success=None,):
6577 
    self.success = success
6578 
 
6579 
  def read(self, iprot):
6580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6582 
      return
6583 
    iprot.readStructBegin()
6584 
    while True:
6585 
      (fname, ftype, fid) = iprot.readFieldBegin()
6586 
      if ftype == TType.STOP:
6587 
        break
6588 
      if fid == 0:
6589 
        if ftype == TType.LIST:
6590 
          self.success = []
6591 
          (_etype130, _size127) = iprot.readListBegin()
6592 
          for _i131 in xrange(_size127):
6593 
            _elem132 = Order()
6594 
            _elem132.read(iprot)
6595 
            self.success.append(_elem132)
6596 
          iprot.readListEnd()
6597 
        else:
6598 
          iprot.skip(ftype)
6599 
      else:
6600 
        iprot.skip(ftype)
6601 
      iprot.readFieldEnd()
6602 
    iprot.readStructEnd()
6603 
 
6604 
  def write(self, oprot):
6605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6607 
      return
6608 
    oprot.writeStructBegin('getUndeliveredOrders_result')
6609 
    if self.success != None:
6610 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6611 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6612 
      for iter133 in self.success:
6613 
        iter133.write(oprot)
6614 
      oprot.writeListEnd()
6615 
      oprot.writeFieldEnd()
6616 
    oprot.writeFieldStop()
6617 
    oprot.writeStructEnd()
6618 
 
6619 
  def __repr__(self):
6620 
    L = ['%s=%r' % (key, value)
6621 
      for key, value in self.__dict__.iteritems()]
6622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6623 
 
6624 
  def __eq__(self, other):
6625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6626 
 
6627 
  def __ne__(self, other):
6628 
    return not (self == other)
6629 
 
304 ashish 6630 
class getAlerts_args:
6631 
  """
6632 
  Attributes:
483 rajveer 6633 
   - orderId
304 ashish 6634 
   - valid
6635 
  """
94 ashish 6636 
 
304 ashish 6637 
  thrift_spec = (
6638 
    None, # 0
483 rajveer 6639 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 6640 
    (2, TType.BOOL, 'valid', None, None, ), # 2
6641 
  )
6642 
 
483 rajveer 6643 
  def __init__(self, orderId=None, valid=None,):
6644 
    self.orderId = orderId
304 ashish 6645 
    self.valid = valid
6646 
 
6647 
  def read(self, iprot):
6648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6650 
      return
6651 
    iprot.readStructBegin()
6652 
    while True:
6653 
      (fname, ftype, fid) = iprot.readFieldBegin()
6654 
      if ftype == TType.STOP:
6655 
        break
6656 
      if fid == 1:
6657 
        if ftype == TType.I64:
483 rajveer 6658 
          self.orderId = iprot.readI64();
304 ashish 6659 
        else:
6660 
          iprot.skip(ftype)
6661 
      elif fid == 2:
6662 
        if ftype == TType.BOOL:
6663 
          self.valid = iprot.readBool();
6664 
        else:
6665 
          iprot.skip(ftype)
6666 
      else:
6667 
        iprot.skip(ftype)
6668 
      iprot.readFieldEnd()
6669 
    iprot.readStructEnd()
6670 
 
6671 
  def write(self, oprot):
6672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6674 
      return
6675 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 6676 
    if self.orderId != None:
6677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6678 
      oprot.writeI64(self.orderId)
304 ashish 6679 
      oprot.writeFieldEnd()
6680 
    if self.valid != None:
6681 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
6682 
      oprot.writeBool(self.valid)
6683 
      oprot.writeFieldEnd()
6684 
    oprot.writeFieldStop()
6685 
    oprot.writeStructEnd()
6686 
 
6687 
  def __repr__(self):
6688 
    L = ['%s=%r' % (key, value)
6689 
      for key, value in self.__dict__.iteritems()]
6690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6691 
 
6692 
  def __eq__(self, other):
6693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6694 
 
6695 
  def __ne__(self, other):
6696 
    return not (self == other)
6697 
 
6698 
class getAlerts_result:
6699 
  """
6700 
  Attributes:
6701 
   - success
6702 
  """
6703 
 
6704 
  thrift_spec = (
6705 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
6706 
  )
6707 
 
6708 
  def __init__(self, success=None,):
6709 
    self.success = success
6710 
 
6711 
  def read(self, iprot):
6712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6714 
      return
6715 
    iprot.readStructBegin()
6716 
    while True:
6717 
      (fname, ftype, fid) = iprot.readFieldBegin()
6718 
      if ftype == TType.STOP:
6719 
        break
6720 
      if fid == 0:
6721 
        if ftype == TType.LIST:
6722 
          self.success = []
1408 ankur.sing 6723 
          (_etype137, _size134) = iprot.readListBegin()
6724 
          for _i138 in xrange(_size134):
6725 
            _elem139 = Alert()
6726 
            _elem139.read(iprot)
6727 
            self.success.append(_elem139)
304 ashish 6728 
          iprot.readListEnd()
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      else:
6732 
        iprot.skip(ftype)
6733 
      iprot.readFieldEnd()
6734 
    iprot.readStructEnd()
6735 
 
6736 
  def write(self, oprot):
6737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6739 
      return
6740 
    oprot.writeStructBegin('getAlerts_result')
6741 
    if self.success != None:
6742 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6743 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1408 ankur.sing 6744 
      for iter140 in self.success:
6745 
        iter140.write(oprot)
304 ashish 6746 
      oprot.writeListEnd()
6747 
      oprot.writeFieldEnd()
6748 
    oprot.writeFieldStop()
6749 
    oprot.writeStructEnd()
6750 
 
6751 
  def __repr__(self):
6752 
    L = ['%s=%r' % (key, value)
6753 
      for key, value in self.__dict__.iteritems()]
6754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6755 
 
6756 
  def __eq__(self, other):
6757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6758 
 
6759 
  def __ne__(self, other):
6760 
    return not (self == other)
6761 
 
6762 
class setAlert_args:
6763 
  """
6764 
  Attributes:
483 rajveer 6765 
   - orderId
304 ashish 6766 
   - unset
6767 
   - type
6768 
   - comment
6769 
  """
6770 
 
6771 
  thrift_spec = (
6772 
    None, # 0
483 rajveer 6773 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 6774 
    (2, TType.BOOL, 'unset', None, None, ), # 2
6775 
    (3, TType.I64, 'type', None, None, ), # 3
6776 
    (4, TType.STRING, 'comment', None, None, ), # 4
6777 
  )
6778 
 
483 rajveer 6779 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
6780 
    self.orderId = orderId
304 ashish 6781 
    self.unset = unset
6782 
    self.type = type
6783 
    self.comment = comment
6784 
 
6785 
  def read(self, iprot):
6786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6788 
      return
6789 
    iprot.readStructBegin()
6790 
    while True:
6791 
      (fname, ftype, fid) = iprot.readFieldBegin()
6792 
      if ftype == TType.STOP:
6793 
        break
6794 
      if fid == 1:
6795 
        if ftype == TType.I64:
483 rajveer 6796 
          self.orderId = iprot.readI64();
304 ashish 6797 
        else:
6798 
          iprot.skip(ftype)
6799 
      elif fid == 2:
6800 
        if ftype == TType.BOOL:
6801 
          self.unset = iprot.readBool();
6802 
        else:
6803 
          iprot.skip(ftype)
6804 
      elif fid == 3:
6805 
        if ftype == TType.I64:
6806 
          self.type = iprot.readI64();
6807 
        else:
6808 
          iprot.skip(ftype)
6809 
      elif fid == 4:
6810 
        if ftype == TType.STRING:
6811 
          self.comment = iprot.readString();
6812 
        else:
6813 
          iprot.skip(ftype)
6814 
      else:
6815 
        iprot.skip(ftype)
6816 
      iprot.readFieldEnd()
6817 
    iprot.readStructEnd()
6818 
 
6819 
  def write(self, oprot):
6820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6822 
      return
6823 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 6824 
    if self.orderId != None:
6825 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6826 
      oprot.writeI64(self.orderId)
304 ashish 6827 
      oprot.writeFieldEnd()
6828 
    if self.unset != None:
6829 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
6830 
      oprot.writeBool(self.unset)
6831 
      oprot.writeFieldEnd()
6832 
    if self.type != None:
6833 
      oprot.writeFieldBegin('type', TType.I64, 3)
6834 
      oprot.writeI64(self.type)
6835 
      oprot.writeFieldEnd()
6836 
    if self.comment != None:
6837 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
6838 
      oprot.writeString(self.comment)
6839 
      oprot.writeFieldEnd()
6840 
    oprot.writeFieldStop()
6841 
    oprot.writeStructEnd()
6842 
 
6843 
  def __repr__(self):
6844 
    L = ['%s=%r' % (key, value)
6845 
      for key, value in self.__dict__.iteritems()]
6846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6847 
 
6848 
  def __eq__(self, other):
6849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6850 
 
6851 
  def __ne__(self, other):
6852 
    return not (self == other)
6853 
 
6854 
class setAlert_result:
6855 
 
6856 
  thrift_spec = (
6857 
  )
6858 
 
6859 
  def read(self, iprot):
6860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6862 
      return
6863 
    iprot.readStructBegin()
6864 
    while True:
6865 
      (fname, ftype, fid) = iprot.readFieldBegin()
6866 
      if ftype == TType.STOP:
6867 
        break
6868 
      else:
6869 
        iprot.skip(ftype)
6870 
      iprot.readFieldEnd()
6871 
    iprot.readStructEnd()
6872 
 
6873 
  def write(self, oprot):
6874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6876 
      return
6877 
    oprot.writeStructBegin('setAlert_result')
6878 
    oprot.writeFieldStop()
6879 
    oprot.writeStructEnd()
6880 
 
6881 
  def __repr__(self):
6882 
    L = ['%s=%r' % (key, value)
6883 
      for key, value in self.__dict__.iteritems()]
6884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6885 
 
6886 
  def __eq__(self, other):
6887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6888 
 
6889 
  def __ne__(self, other):
6890 
    return not (self == other)
6891 
 
1596 ankur.sing 6892 
class getValidOrderCount_args:
304 ashish 6893 
 
1596 ankur.sing 6894 
  thrift_spec = (
6895 
  )
6896 
 
6897 
  def read(self, iprot):
6898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6900 
      return
6901 
    iprot.readStructBegin()
6902 
    while True:
6903 
      (fname, ftype, fid) = iprot.readFieldBegin()
6904 
      if ftype == TType.STOP:
6905 
        break
6906 
      else:
6907 
        iprot.skip(ftype)
6908 
      iprot.readFieldEnd()
6909 
    iprot.readStructEnd()
6910 
 
6911 
  def write(self, oprot):
6912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6914 
      return
6915 
    oprot.writeStructBegin('getValidOrderCount_args')
6916 
    oprot.writeFieldStop()
6917 
    oprot.writeStructEnd()
6918 
 
6919 
  def __repr__(self):
6920 
    L = ['%s=%r' % (key, value)
6921 
      for key, value in self.__dict__.iteritems()]
6922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6923 
 
6924 
  def __eq__(self, other):
6925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6926 
 
6927 
  def __ne__(self, other):
6928 
    return not (self == other)
6929 
 
6930 
class getValidOrderCount_result:
6931 
  """
6932 
  Attributes:
6933 
   - success
6934 
  """
6935 
 
6936 
  thrift_spec = (
6937 
    (0, TType.I64, 'success', None, None, ), # 0
6938 
  )
6939 
 
6940 
  def __init__(self, success=None,):
6941 
    self.success = success
6942 
 
6943 
  def read(self, iprot):
6944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6946 
      return
6947 
    iprot.readStructBegin()
6948 
    while True:
6949 
      (fname, ftype, fid) = iprot.readFieldBegin()
6950 
      if ftype == TType.STOP:
6951 
        break
6952 
      if fid == 0:
6953 
        if ftype == TType.I64:
6954 
          self.success = iprot.readI64();
6955 
        else:
6956 
          iprot.skip(ftype)
6957 
      else:
6958 
        iprot.skip(ftype)
6959 
      iprot.readFieldEnd()
6960 
    iprot.readStructEnd()
6961 
 
6962 
  def write(self, oprot):
6963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6965 
      return
6966 
    oprot.writeStructBegin('getValidOrderCount_result')
6967 
    if self.success != None:
6968 
      oprot.writeFieldBegin('success', TType.I64, 0)
6969 
      oprot.writeI64(self.success)
6970 
      oprot.writeFieldEnd()
6971 
    oprot.writeFieldStop()
6972 
    oprot.writeStructEnd()
6973 
 
6974 
  def __repr__(self):
6975 
    L = ['%s=%r' % (key, value)
6976 
      for key, value in self.__dict__.iteritems()]
6977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6978 
 
6979 
  def __eq__(self, other):
6980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6981 
 
6982 
  def __ne__(self, other):
6983 
    return not (self == other)
6984 
 
1627 ankur.sing 6985 
class getNoOfCustomersWithSuccessfulTransaction_args:
1596 ankur.sing 6986 
 
1627 ankur.sing 6987 
  thrift_spec = (
6988 
  )
6989 
 
6990 
  def read(self, iprot):
6991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6993 
      return
6994 
    iprot.readStructBegin()
6995 
    while True:
6996 
      (fname, ftype, fid) = iprot.readFieldBegin()
6997 
      if ftype == TType.STOP:
6998 
        break
6999 
      else:
7000 
        iprot.skip(ftype)
7001 
      iprot.readFieldEnd()
7002 
    iprot.readStructEnd()
7003 
 
7004 
  def write(self, oprot):
7005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7007 
      return
7008 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7009 
    oprot.writeFieldStop()
7010 
    oprot.writeStructEnd()
7011 
 
7012 
  def __repr__(self):
7013 
    L = ['%s=%r' % (key, value)
7014 
      for key, value in self.__dict__.iteritems()]
7015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7016 
 
7017 
  def __eq__(self, other):
7018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7019 
 
7020 
  def __ne__(self, other):
7021 
    return not (self == other)
7022 
 
7023 
class getNoOfCustomersWithSuccessfulTransaction_result:
7024 
  """
7025 
  Attributes:
7026 
   - success
7027 
  """
7028 
 
7029 
  thrift_spec = (
7030 
    (0, TType.I64, 'success', None, None, ), # 0
7031 
  )
7032 
 
7033 
  def __init__(self, success=None,):
7034 
    self.success = success
7035 
 
7036 
  def read(self, iprot):
7037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7039 
      return
7040 
    iprot.readStructBegin()
7041 
    while True:
7042 
      (fname, ftype, fid) = iprot.readFieldBegin()
7043 
      if ftype == TType.STOP:
7044 
        break
7045 
      if fid == 0:
7046 
        if ftype == TType.I64:
7047 
          self.success = iprot.readI64();
7048 
        else:
7049 
          iprot.skip(ftype)
7050 
      else:
7051 
        iprot.skip(ftype)
7052 
      iprot.readFieldEnd()
7053 
    iprot.readStructEnd()
7054 
 
7055 
  def write(self, oprot):
7056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7058 
      return
7059 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
7060 
    if self.success != None:
7061 
      oprot.writeFieldBegin('success', TType.I64, 0)
7062 
      oprot.writeI64(self.success)
7063 
      oprot.writeFieldEnd()
7064 
    oprot.writeFieldStop()
7065 
    oprot.writeStructEnd()
7066 
 
7067 
  def __repr__(self):
7068 
    L = ['%s=%r' % (key, value)
7069 
      for key, value in self.__dict__.iteritems()]
7070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7071 
 
7072 
  def __eq__(self, other):
7073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7074 
 
7075 
  def __ne__(self, other):
7076 
    return not (self == other)
7077 
 
1731 ankur.sing 7078 
class getValidOrdersAmountRange_args:
1627 ankur.sing 7079 
 
7080 
  thrift_spec = (
7081 
  )
7082 
 
7083 
  def read(self, iprot):
7084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7086 
      return
7087 
    iprot.readStructBegin()
7088 
    while True:
7089 
      (fname, ftype, fid) = iprot.readFieldBegin()
7090 
      if ftype == TType.STOP:
7091 
        break
7092 
      else:
7093 
        iprot.skip(ftype)
7094 
      iprot.readFieldEnd()
7095 
    iprot.readStructEnd()
7096 
 
7097 
  def write(self, oprot):
7098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7100 
      return
1731 ankur.sing 7101 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
1627 ankur.sing 7102 
    oprot.writeFieldStop()
7103 
    oprot.writeStructEnd()
7104 
 
7105 
  def __repr__(self):
7106 
    L = ['%s=%r' % (key, value)
7107 
      for key, value in self.__dict__.iteritems()]
7108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7109 
 
7110 
  def __eq__(self, other):
7111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7112 
 
7113 
  def __ne__(self, other):
7114 
    return not (self == other)
7115 
 
1731 ankur.sing 7116 
class getValidOrdersAmountRange_result:
1627 ankur.sing 7117 
  """
7118 
  Attributes:
7119 
   - success
7120 
  """
7121 
 
7122 
  thrift_spec = (
1731 ankur.sing 7123 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
1627 ankur.sing 7124 
  )
7125 
 
7126 
  def __init__(self, success=None,):
7127 
    self.success = success
7128 
 
7129 
  def read(self, iprot):
7130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7132 
      return
7133 
    iprot.readStructBegin()
7134 
    while True:
7135 
      (fname, ftype, fid) = iprot.readFieldBegin()
7136 
      if ftype == TType.STOP:
7137 
        break
7138 
      if fid == 0:
1731 ankur.sing 7139 
        if ftype == TType.LIST:
7140 
          self.success = []
7141 
          (_etype144, _size141) = iprot.readListBegin()
7142 
          for _i145 in xrange(_size141):
7143 
            _elem146 = iprot.readDouble();
7144 
            self.success.append(_elem146)
7145 
          iprot.readListEnd()
1627 ankur.sing 7146 
        else:
7147 
          iprot.skip(ftype)
7148 
      else:
7149 
        iprot.skip(ftype)
7150 
      iprot.readFieldEnd()
7151 
    iprot.readStructEnd()
7152 
 
7153 
  def write(self, oprot):
7154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7156 
      return
1731 ankur.sing 7157 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
1627 ankur.sing 7158 
    if self.success != None:
1731 ankur.sing 7159 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7160 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
7161 
      for iter147 in self.success:
7162 
        oprot.writeDouble(iter147)
7163 
      oprot.writeListEnd()
1627 ankur.sing 7164 
      oprot.writeFieldEnd()
7165 
    oprot.writeFieldStop()
7166 
    oprot.writeStructEnd()
7167 
 
7168 
  def __repr__(self):
7169 
    L = ['%s=%r' % (key, value)
7170 
      for key, value in self.__dict__.iteritems()]
7171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7172 
 
7173 
  def __eq__(self, other):
7174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7175 
 
7176 
  def __ne__(self, other):
7177 
    return not (self == other)
7178 
 
1886 ankur.sing 7179 
class getValidOrders_args:
7180 
  """
7181 
  Attributes:
7182 
   - limit
7183 
  """
1627 ankur.sing 7184 
 
1886 ankur.sing 7185 
  thrift_spec = (
7186 
    None, # 0
7187 
    (1, TType.I64, 'limit', None, None, ), # 1
7188 
  )
7189 
 
7190 
  def __init__(self, limit=None,):
7191 
    self.limit = limit
7192 
 
7193 
  def read(self, iprot):
7194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7196 
      return
7197 
    iprot.readStructBegin()
7198 
    while True:
7199 
      (fname, ftype, fid) = iprot.readFieldBegin()
7200 
      if ftype == TType.STOP:
7201 
        break
7202 
      if fid == 1:
7203 
        if ftype == TType.I64:
7204 
          self.limit = iprot.readI64();
7205 
        else:
7206 
          iprot.skip(ftype)
7207 
      else:
7208 
        iprot.skip(ftype)
7209 
      iprot.readFieldEnd()
7210 
    iprot.readStructEnd()
7211 
 
7212 
  def write(self, oprot):
7213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7215 
      return
7216 
    oprot.writeStructBegin('getValidOrders_args')
7217 
    if self.limit != None:
7218 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7219 
      oprot.writeI64(self.limit)
7220 
      oprot.writeFieldEnd()
7221 
    oprot.writeFieldStop()
7222 
    oprot.writeStructEnd()
7223 
 
7224 
  def __repr__(self):
7225 
    L = ['%s=%r' % (key, value)
7226 
      for key, value in self.__dict__.iteritems()]
7227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7228 
 
7229 
  def __eq__(self, other):
7230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7231 
 
7232 
  def __ne__(self, other):
7233 
    return not (self == other)
7234 
 
7235 
class getValidOrders_result:
7236 
  """
7237 
  Attributes:
7238 
   - success
7239 
  """
7240 
 
7241 
  thrift_spec = (
7242 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7243 
  )
7244 
 
7245 
  def __init__(self, success=None,):
7246 
    self.success = success
7247 
 
7248 
  def read(self, iprot):
7249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7251 
      return
7252 
    iprot.readStructBegin()
7253 
    while True:
7254 
      (fname, ftype, fid) = iprot.readFieldBegin()
7255 
      if ftype == TType.STOP:
7256 
        break
7257 
      if fid == 0:
7258 
        if ftype == TType.LIST:
7259 
          self.success = []
7260 
          (_etype151, _size148) = iprot.readListBegin()
7261 
          for _i152 in xrange(_size148):
7262 
            _elem153 = Order()
7263 
            _elem153.read(iprot)
7264 
            self.success.append(_elem153)
7265 
          iprot.readListEnd()
7266 
        else:
7267 
          iprot.skip(ftype)
7268 
      else:
7269 
        iprot.skip(ftype)
7270 
      iprot.readFieldEnd()
7271 
    iprot.readStructEnd()
7272 
 
7273 
  def write(self, oprot):
7274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7276 
      return
7277 
    oprot.writeStructBegin('getValidOrders_result')
7278 
    if self.success != None:
7279 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7280 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7281 
      for iter154 in self.success:
7282 
        iter154.write(oprot)
7283 
      oprot.writeListEnd()
7284 
      oprot.writeFieldEnd()
7285 
    oprot.writeFieldStop()
7286 
    oprot.writeStructEnd()
7287 
 
7288 
  def __repr__(self):
7289 
    L = ['%s=%r' % (key, value)
7290 
      for key, value in self.__dict__.iteritems()]
7291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7292 
 
7293 
  def __eq__(self, other):
7294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7295 
 
7296 
  def __ne__(self, other):
7297 
    return not (self == other)
7298 
 
2536 chandransh 7299 
class toggleDOAFlag_args:
7300 
  """
7301 
  Attributes:
7302 
   - orderId
7303 
  """
1886 ankur.sing 7304 
 
2536 chandransh 7305 
  thrift_spec = (
7306 
    None, # 0
7307 
    (1, TType.I64, 'orderId', None, None, ), # 1
7308 
  )
7309 
 
7310 
  def __init__(self, orderId=None,):
7311 
    self.orderId = orderId
7312 
 
7313 
  def read(self, iprot):
7314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7316 
      return
7317 
    iprot.readStructBegin()
7318 
    while True:
7319 
      (fname, ftype, fid) = iprot.readFieldBegin()
7320 
      if ftype == TType.STOP:
7321 
        break
7322 
      if fid == 1:
7323 
        if ftype == TType.I64:
7324 
          self.orderId = iprot.readI64();
7325 
        else:
7326 
          iprot.skip(ftype)
7327 
      else:
7328 
        iprot.skip(ftype)
7329 
      iprot.readFieldEnd()
7330 
    iprot.readStructEnd()
7331 
 
7332 
  def write(self, oprot):
7333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7335 
      return
7336 
    oprot.writeStructBegin('toggleDOAFlag_args')
7337 
    if self.orderId != None:
7338 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7339 
      oprot.writeI64(self.orderId)
7340 
      oprot.writeFieldEnd()
7341 
    oprot.writeFieldStop()
7342 
    oprot.writeStructEnd()
7343 
 
7344 
  def __repr__(self):
7345 
    L = ['%s=%r' % (key, value)
7346 
      for key, value in self.__dict__.iteritems()]
7347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7348 
 
7349 
  def __eq__(self, other):
7350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7351 
 
7352 
  def __ne__(self, other):
7353 
    return not (self == other)
7354 
 
7355 
class toggleDOAFlag_result:
7356 
  """
7357 
  Attributes:
7358 
   - success
7359 
   - ex
7360 
  """
7361 
 
7362 
  thrift_spec = (
7363 
    (0, TType.BOOL, 'success', None, None, ), # 0
7364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7365 
  )
7366 
 
7367 
  def __init__(self, success=None, ex=None,):
7368 
    self.success = success
7369 
    self.ex = ex
7370 
 
7371 
  def read(self, iprot):
7372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7374 
      return
7375 
    iprot.readStructBegin()
7376 
    while True:
7377 
      (fname, ftype, fid) = iprot.readFieldBegin()
7378 
      if ftype == TType.STOP:
7379 
        break
7380 
      if fid == 0:
7381 
        if ftype == TType.BOOL:
7382 
          self.success = iprot.readBool();
7383 
        else:
7384 
          iprot.skip(ftype)
7385 
      elif fid == 1:
7386 
        if ftype == TType.STRUCT:
7387 
          self.ex = TransactionServiceException()
7388 
          self.ex.read(iprot)
7389 
        else:
7390 
          iprot.skip(ftype)
7391 
      else:
7392 
        iprot.skip(ftype)
7393 
      iprot.readFieldEnd()
7394 
    iprot.readStructEnd()
7395 
 
7396 
  def write(self, oprot):
7397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7399 
      return
7400 
    oprot.writeStructBegin('toggleDOAFlag_result')
7401 
    if self.success != None:
7402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7403 
      oprot.writeBool(self.success)
7404 
      oprot.writeFieldEnd()
7405 
    if self.ex != None:
7406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7407 
      self.ex.write(oprot)
7408 
      oprot.writeFieldEnd()
7409 
    oprot.writeFieldStop()
7410 
    oprot.writeStructEnd()
7411 
 
7412 
  def __repr__(self):
7413 
    L = ['%s=%r' % (key, value)
7414 
      for key, value in self.__dict__.iteritems()]
7415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7416 
 
7417 
  def __eq__(self, other):
7418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7419 
 
7420 
  def __ne__(self, other):
7421 
    return not (self == other)
7422 
 
7423 
class requestPickupNumber_args:
7424 
  """
7425 
  Attributes:
7426 
   - orderId
7427 
  """
7428 
 
7429 
  thrift_spec = (
7430 
    None, # 0
7431 
    (1, TType.I64, 'orderId', None, None, ), # 1
7432 
  )
7433 
 
7434 
  def __init__(self, orderId=None,):
7435 
    self.orderId = orderId
7436 
 
7437 
  def read(self, iprot):
7438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7440 
      return
7441 
    iprot.readStructBegin()
7442 
    while True:
7443 
      (fname, ftype, fid) = iprot.readFieldBegin()
7444 
      if ftype == TType.STOP:
7445 
        break
7446 
      if fid == 1:
7447 
        if ftype == TType.I64:
7448 
          self.orderId = iprot.readI64();
7449 
        else:
7450 
          iprot.skip(ftype)
7451 
      else:
7452 
        iprot.skip(ftype)
7453 
      iprot.readFieldEnd()
7454 
    iprot.readStructEnd()
7455 
 
7456 
  def write(self, oprot):
7457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7459 
      return
7460 
    oprot.writeStructBegin('requestPickupNumber_args')
7461 
    if self.orderId != None:
7462 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7463 
      oprot.writeI64(self.orderId)
7464 
      oprot.writeFieldEnd()
7465 
    oprot.writeFieldStop()
7466 
    oprot.writeStructEnd()
7467 
 
7468 
  def __repr__(self):
7469 
    L = ['%s=%r' % (key, value)
7470 
      for key, value in self.__dict__.iteritems()]
7471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7472 
 
7473 
  def __eq__(self, other):
7474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7475 
 
7476 
  def __ne__(self, other):
7477 
    return not (self == other)
7478 
 
7479 
class requestPickupNumber_result:
7480 
  """
7481 
  Attributes:
7482 
   - success
7483 
   - ex
7484 
  """
7485 
 
7486 
  thrift_spec = (
7487 
    (0, TType.BOOL, 'success', None, None, ), # 0
7488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7489 
  )
7490 
 
7491 
  def __init__(self, success=None, ex=None,):
7492 
    self.success = success
7493 
    self.ex = ex
7494 
 
7495 
  def read(self, iprot):
7496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7498 
      return
7499 
    iprot.readStructBegin()
7500 
    while True:
7501 
      (fname, ftype, fid) = iprot.readFieldBegin()
7502 
      if ftype == TType.STOP:
7503 
        break
7504 
      if fid == 0:
7505 
        if ftype == TType.BOOL:
7506 
          self.success = iprot.readBool();
7507 
        else:
7508 
          iprot.skip(ftype)
7509 
      elif fid == 1:
7510 
        if ftype == TType.STRUCT:
7511 
          self.ex = TransactionServiceException()
7512 
          self.ex.read(iprot)
7513 
        else:
7514 
          iprot.skip(ftype)
7515 
      else:
7516 
        iprot.skip(ftype)
7517 
      iprot.readFieldEnd()
7518 
    iprot.readStructEnd()
7519 
 
7520 
  def write(self, oprot):
7521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7523 
      return
7524 
    oprot.writeStructBegin('requestPickupNumber_result')
7525 
    if self.success != None:
7526 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7527 
      oprot.writeBool(self.success)
7528 
      oprot.writeFieldEnd()
7529 
    if self.ex != None:
7530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7531 
      self.ex.write(oprot)
7532 
      oprot.writeFieldEnd()
7533 
    oprot.writeFieldStop()
7534 
    oprot.writeStructEnd()
7535 
 
7536 
  def __repr__(self):
7537 
    L = ['%s=%r' % (key, value)
7538 
      for key, value in self.__dict__.iteritems()]
7539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7540 
 
7541 
  def __eq__(self, other):
7542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7543 
 
7544 
  def __ne__(self, other):
7545 
    return not (self == other)
7546 
 
7547 
class authorizePickup_args:
7548 
  """
7549 
  Attributes:
7550 
   - orderId
7551 
   - pickupNumber
7552 
  """
7553 
 
7554 
  thrift_spec = (
7555 
    None, # 0
7556 
    (1, TType.I64, 'orderId', None, None, ), # 1
7557 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
7558 
  )
7559 
 
7560 
  def __init__(self, orderId=None, pickupNumber=None,):
7561 
    self.orderId = orderId
7562 
    self.pickupNumber = pickupNumber
7563 
 
7564 
  def read(self, iprot):
7565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7567 
      return
7568 
    iprot.readStructBegin()
7569 
    while True:
7570 
      (fname, ftype, fid) = iprot.readFieldBegin()
7571 
      if ftype == TType.STOP:
7572 
        break
7573 
      if fid == 1:
7574 
        if ftype == TType.I64:
7575 
          self.orderId = iprot.readI64();
7576 
        else:
7577 
          iprot.skip(ftype)
7578 
      elif fid == 2:
7579 
        if ftype == TType.STRING:
7580 
          self.pickupNumber = iprot.readString();
7581 
        else:
7582 
          iprot.skip(ftype)
7583 
      else:
7584 
        iprot.skip(ftype)
7585 
      iprot.readFieldEnd()
7586 
    iprot.readStructEnd()
7587 
 
7588 
  def write(self, oprot):
7589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7591 
      return
7592 
    oprot.writeStructBegin('authorizePickup_args')
7593 
    if self.orderId != None:
7594 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7595 
      oprot.writeI64(self.orderId)
7596 
      oprot.writeFieldEnd()
7597 
    if self.pickupNumber != None:
7598 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
7599 
      oprot.writeString(self.pickupNumber)
7600 
      oprot.writeFieldEnd()
7601 
    oprot.writeFieldStop()
7602 
    oprot.writeStructEnd()
7603 
 
7604 
  def __repr__(self):
7605 
    L = ['%s=%r' % (key, value)
7606 
      for key, value in self.__dict__.iteritems()]
7607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7608 
 
7609 
  def __eq__(self, other):
7610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7611 
 
7612 
  def __ne__(self, other):
7613 
    return not (self == other)
7614 
 
7615 
class authorizePickup_result:
7616 
  """
7617 
  Attributes:
7618 
   - success
7619 
   - ex
7620 
  """
7621 
 
7622 
  thrift_spec = (
7623 
    (0, TType.BOOL, 'success', None, None, ), # 0
7624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7625 
  )
7626 
 
7627 
  def __init__(self, success=None, ex=None,):
7628 
    self.success = success
7629 
    self.ex = ex
7630 
 
7631 
  def read(self, iprot):
7632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7634 
      return
7635 
    iprot.readStructBegin()
7636 
    while True:
7637 
      (fname, ftype, fid) = iprot.readFieldBegin()
7638 
      if ftype == TType.STOP:
7639 
        break
7640 
      if fid == 0:
7641 
        if ftype == TType.BOOL:
7642 
          self.success = iprot.readBool();
7643 
        else:
7644 
          iprot.skip(ftype)
7645 
      elif fid == 1:
7646 
        if ftype == TType.STRUCT:
7647 
          self.ex = TransactionServiceException()
7648 
          self.ex.read(iprot)
7649 
        else:
7650 
          iprot.skip(ftype)
7651 
      else:
7652 
        iprot.skip(ftype)
7653 
      iprot.readFieldEnd()
7654 
    iprot.readStructEnd()
7655 
 
7656 
  def write(self, oprot):
7657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7659 
      return
7660 
    oprot.writeStructBegin('authorizePickup_result')
7661 
    if self.success != None:
7662 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7663 
      oprot.writeBool(self.success)
7664 
      oprot.writeFieldEnd()
7665 
    if self.ex != None:
7666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7667 
      self.ex.write(oprot)
7668 
      oprot.writeFieldEnd()
7669 
    oprot.writeFieldStop()
7670 
    oprot.writeStructEnd()
7671 
 
7672 
  def __repr__(self):
7673 
    L = ['%s=%r' % (key, value)
7674 
      for key, value in self.__dict__.iteritems()]
7675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7676 
 
7677 
  def __eq__(self, other):
7678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7679 
 
7680 
  def __ne__(self, other):
7681 
    return not (self == other)
7682 
 
7683