Subversion Repositories SmartDukaan

Rev

Rev 2690 | Rev 2764 | 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
2591 chandransh 385 
    If the order is in any other status, it returns false.
2536 chandransh 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 
 
2616 chandransh 394 
  def receiveReturn(self, orderId):
2591 chandransh 395 
    """
2599 chandransh 396 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 397 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 398 
    If the order is in any other state, it returns false.
399 
    Throws an exception if the order with the given id couldn't be found.
400 
 
401 
    Parameters:
402 
     - orderId
403 
    """
404 
    pass
2536 chandransh 405 
 
2591 chandransh 406 
  def validateDoa(self, orderId, isValid):
407 
    """
2599 chandransh 408 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 409 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 410 
    If the order is in any other state, it returns false.
411 
    Throws an exception if the order with the given id couldn't be found.
412 
 
413 
    Parameters:
414 
     - orderId
415 
     - isValid
416 
    """
417 
    pass
418 
 
2616 chandransh 419 
  def reshipOrder(self, orderId):
420 
    """
421 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
422 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
423 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
424 
 
425 
    If the order is in DOA_CERT_VALID state, it does the following:
426 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
427 
    	2. Creates a return order for the warehouse executive to return the DOA material.
428 
    	3. Marks the current order as the final DOA_RESHIPPED state.
429 
 
430 
    Returns the id of the newly created order.
431 
 
432 
    Throws an exception if the order with the given id couldn't be found.
433 
 
434 
    Parameters:
435 
     - orderId
436 
    """
437 
    pass
2591 chandransh 438 
 
2616 chandransh 439 
  def refundOrder(self, orderId):
440 
    """
441 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
442 
    	1. Creates a refund request for batch processing.
443 
    	2. Creates a return order for the warehouse executive to return the shipped material.
444 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
445 
 
446 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
447 
    	1. Creates a refund request for batch processing.
448 
    	2. Marks the current order as the REFUNDED final state.
449 
 
450 
    Returns True if it is successful, False otherwise.
451 
 
452 
    Throws an exception if the order with the given id couldn't be found.
453 
 
454 
    Parameters:
455 
     - orderId
456 
    """
457 
    pass
458 
 
2690 chandransh 459 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
460 
    """
461 
    Get all return orders created between the from and to dates for the given warehouse.
462 
    Ignores the warehouse if it is passed as -1.
463 
 
464 
    Parameters:
465 
     - warehouseId
466 
     - fromDate
467 
     - toDate
468 
    """
469 
    pass
2616 chandransh 470 
 
2700 chandransh 471 
  def getReturnOrder(self, id):
472 
    """
473 
    Returns the ReturnOrder corresponding to the given id.
474 
    Throws an exception if the return order with the given id couldn't be found.
475 
 
476 
    Parameters:
477 
     - id
478 
    """
479 
    pass
480 
 
2690 chandransh 481 
  def processReturn(self, returnOrderId):
482 
    """
483 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
484 
 
485 
    Parameters:
486 
     - returnOrderId
487 
    """
488 
    pass
489 
 
490 
 
94 ashish 491 
class Client(Iface):
492 
  def __init__(self, iprot, oprot=None):
493 
    self._iprot = self._oprot = iprot
494 
    if oprot != None:
495 
      self._oprot = oprot
496 
    self._seqid = 0
497 
 
765 rajveer 498 
  def closeSession(self, ):
499 
    """
500 
    For closing the open session in sqlalchemy
501 
    """
502 
    self.send_closeSession()
503 
    self.recv_closeSession()
504 
 
505 
  def send_closeSession(self, ):
506 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
507 
    args = closeSession_args()
508 
    args.write(self._oprot)
509 
    self._oprot.writeMessageEnd()
510 
    self._oprot.trans.flush()
511 
 
512 
  def recv_closeSession(self, ):
513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
514 
    if mtype == TMessageType.EXCEPTION:
515 
      x = TApplicationException()
516 
      x.read(self._iprot)
517 
      self._iprot.readMessageEnd()
518 
      raise x
519 
    result = closeSession_result()
520 
    result.read(self._iprot)
521 
    self._iprot.readMessageEnd()
522 
    return
523 
 
94 ashish 524 
  def createTransaction(self, transaction):
525 
    """
526 
    Parameters:
527 
     - transaction
528 
    """
529 
    self.send_createTransaction(transaction)
132 ashish 530 
    return self.recv_createTransaction()
94 ashish 531 
 
532 
  def send_createTransaction(self, transaction):
533 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
534 
    args = createTransaction_args()
535 
    args.transaction = transaction
536 
    args.write(self._oprot)
537 
    self._oprot.writeMessageEnd()
538 
    self._oprot.trans.flush()
539 
 
540 
  def recv_createTransaction(self, ):
541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
542 
    if mtype == TMessageType.EXCEPTION:
543 
      x = TApplicationException()
544 
      x.read(self._iprot)
545 
      self._iprot.readMessageEnd()
546 
      raise x
547 
    result = createTransaction_result()
548 
    result.read(self._iprot)
549 
    self._iprot.readMessageEnd()
132 ashish 550 
    if result.success != None:
551 
      return result.success
94 ashish 552 
    if result.ex != None:
553 
      raise result.ex
132 ashish 554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 555 
 
556 
  def getTransaction(self, id):
557 
    """
558 
    Parameters:
559 
     - id
560 
    """
561 
    self.send_getTransaction(id)
562 
    return self.recv_getTransaction()
563 
 
564 
  def send_getTransaction(self, id):
565 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
566 
    args = getTransaction_args()
567 
    args.id = id
568 
    args.write(self._oprot)
569 
    self._oprot.writeMessageEnd()
570 
    self._oprot.trans.flush()
571 
 
572 
  def recv_getTransaction(self, ):
573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
574 
    if mtype == TMessageType.EXCEPTION:
575 
      x = TApplicationException()
576 
      x.read(self._iprot)
577 
      self._iprot.readMessageEnd()
578 
      raise x
579 
    result = getTransaction_result()
580 
    result.read(self._iprot)
581 
    self._iprot.readMessageEnd()
582 
    if result.success != None:
583 
      return result.success
584 
    if result.ex != None:
585 
      raise result.ex
586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
587 
 
588 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
589 
    """
590 
    Parameters:
591 
     - customerId
592 
     - from_date
593 
     - to_date
594 
     - status
595 
    """
596 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
597 
    return self.recv_getTransactionsForCustomer()
598 
 
599 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
600 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
601 
    args = getTransactionsForCustomer_args()
602 
    args.customerId = customerId
603 
    args.from_date = from_date
604 
    args.to_date = to_date
605 
    args.status = status
606 
    args.write(self._oprot)
607 
    self._oprot.writeMessageEnd()
608 
    self._oprot.trans.flush()
609 
 
610 
  def recv_getTransactionsForCustomer(self, ):
611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
612 
    if mtype == TMessageType.EXCEPTION:
613 
      x = TApplicationException()
614 
      x.read(self._iprot)
615 
      self._iprot.readMessageEnd()
616 
      raise x
617 
    result = getTransactionsForCustomer_result()
618 
    result.read(self._iprot)
619 
    self._iprot.readMessageEnd()
620 
    if result.success != None:
621 
      return result.success
622 
    if result.ex != None:
623 
      raise result.ex
624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
625 
 
132 ashish 626 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
627 
    """
628 
    Parameters:
629 
     - shoppingCartId
630 
    """
631 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
632 
    return self.recv_getTransactionsForShoppingCartId()
633 
 
634 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
635 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
636 
    args = getTransactionsForShoppingCartId_args()
637 
    args.shoppingCartId = shoppingCartId
638 
    args.write(self._oprot)
639 
    self._oprot.writeMessageEnd()
640 
    self._oprot.trans.flush()
641 
 
642 
  def recv_getTransactionsForShoppingCartId(self, ):
643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
644 
    if mtype == TMessageType.EXCEPTION:
645 
      x = TApplicationException()
646 
      x.read(self._iprot)
647 
      self._iprot.readMessageEnd()
648 
      raise x
649 
    result = getTransactionsForShoppingCartId_result()
650 
    result.read(self._iprot)
651 
    self._iprot.readMessageEnd()
652 
    if result.success != None:
653 
      return result.success
654 
    if result.ex != None:
655 
      raise result.ex
656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
657 
 
94 ashish 658 
  def getTransactionStatus(self, transactionId):
659 
    """
660 
    Parameters:
661 
     - transactionId
662 
    """
663 
    self.send_getTransactionStatus(transactionId)
664 
    return self.recv_getTransactionStatus()
665 
 
666 
  def send_getTransactionStatus(self, transactionId):
667 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
668 
    args = getTransactionStatus_args()
669 
    args.transactionId = transactionId
670 
    args.write(self._oprot)
671 
    self._oprot.writeMessageEnd()
672 
    self._oprot.trans.flush()
673 
 
674 
  def recv_getTransactionStatus(self, ):
675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
676 
    if mtype == TMessageType.EXCEPTION:
677 
      x = TApplicationException()
678 
      x.read(self._iprot)
679 
      self._iprot.readMessageEnd()
680 
      raise x
681 
    result = getTransactionStatus_result()
682 
    result.read(self._iprot)
683 
    self._iprot.readMessageEnd()
684 
    if result.success != None:
685 
      return result.success
686 
    if result.ex != None:
687 
      raise result.ex
688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
689 
 
690 
  def changeTransactionStatus(self, transactionId, status, description):
691 
    """
692 
    Parameters:
693 
     - transactionId
694 
     - status
695 
     - description
696 
    """
697 
    self.send_changeTransactionStatus(transactionId, status, description)
698 
    return self.recv_changeTransactionStatus()
699 
 
700 
  def send_changeTransactionStatus(self, transactionId, status, description):
701 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
702 
    args = changeTransactionStatus_args()
703 
    args.transactionId = transactionId
704 
    args.status = status
705 
    args.description = description
706 
    args.write(self._oprot)
707 
    self._oprot.writeMessageEnd()
708 
    self._oprot.trans.flush()
709 
 
710 
  def recv_changeTransactionStatus(self, ):
711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
712 
    if mtype == TMessageType.EXCEPTION:
713 
      x = TApplicationException()
714 
      x.read(self._iprot)
715 
      self._iprot.readMessageEnd()
716 
      raise x
717 
    result = changeTransactionStatus_result()
718 
    result.read(self._iprot)
719 
    self._iprot.readMessageEnd()
720 
    if result.success != None:
721 
      return result.success
722 
    if result.ex != None:
723 
      raise result.ex
724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
725 
 
1398 varun.gupt 726 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 727 
    """
728 
    Parameters:
729 
     - transactionId
730 
    """
1398 varun.gupt 731 
    self.send_enqueueTransactionInfoEmail(transactionId)
732 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 733 
 
1398 varun.gupt 734 
  def send_enqueueTransactionInfoEmail(self, transactionId):
735 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
736 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 737 
    args.transactionId = transactionId
738 
    args.write(self._oprot)
739 
    self._oprot.writeMessageEnd()
740 
    self._oprot.trans.flush()
741 
 
1398 varun.gupt 742 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
744 
    if mtype == TMessageType.EXCEPTION:
745 
      x = TApplicationException()
746 
      x.read(self._iprot)
747 
      self._iprot.readMessageEnd()
748 
      raise x
1398 varun.gupt 749 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 750 
    result.read(self._iprot)
751 
    self._iprot.readMessageEnd()
752 
    if result.success != None:
753 
      return result.success
754 
    if result.ex != None:
755 
      raise result.ex
1398 varun.gupt 756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 757 
 
483 rajveer 758 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
94 ashish 759 
    """
760 
    Parameters:
483 rajveer 761 
     - status
762 
     - from_date
763 
     - to_date
764 
     - warehouse_id
94 ashish 765 
    """
483 rajveer 766 
    self.send_getAllOrders(status, from_date, to_date, warehouse_id)
767 
    return self.recv_getAllOrders()
94 ashish 768 
 
483 rajveer 769 
  def send_getAllOrders(self, status, from_date, to_date, warehouse_id):
770 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
771 
    args = getAllOrders_args()
772 
    args.status = status
773 
    args.from_date = from_date
774 
    args.to_date = to_date
775 
    args.warehouse_id = warehouse_id
94 ashish 776 
    args.write(self._oprot)
777 
    self._oprot.writeMessageEnd()
778 
    self._oprot.trans.flush()
779 
 
483 rajveer 780 
  def recv_getAllOrders(self, ):
94 ashish 781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
782 
    if mtype == TMessageType.EXCEPTION:
783 
      x = TApplicationException()
784 
      x.read(self._iprot)
785 
      self._iprot.readMessageEnd()
786 
      raise x
483 rajveer 787 
    result = getAllOrders_result()
94 ashish 788 
    result.read(self._iprot)
789 
    self._iprot.readMessageEnd()
790 
    if result.success != None:
791 
      return result.success
792 
    if result.ex != None:
793 
      raise result.ex
483 rajveer 794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 795 
 
999 varun.gupt 796 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
797 
    """
1132 chandransh 798 
    Returns orders within a range of their billing dates
799 
 
999 varun.gupt 800 
    Parameters:
801 
     - status
802 
     - start_billing_date
803 
     - end_billing_date
804 
     - warehouse_id
805 
    """
806 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
807 
    return self.recv_getOrdersByBillingDate()
808 
 
809 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
810 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
811 
    args = getOrdersByBillingDate_args()
812 
    args.status = status
813 
    args.start_billing_date = start_billing_date
814 
    args.end_billing_date = end_billing_date
815 
    args.warehouse_id = warehouse_id
816 
    args.write(self._oprot)
817 
    self._oprot.writeMessageEnd()
818 
    self._oprot.trans.flush()
819 
 
820 
  def recv_getOrdersByBillingDate(self, ):
821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
822 
    if mtype == TMessageType.EXCEPTION:
823 
      x = TApplicationException()
824 
      x.read(self._iprot)
825 
      self._iprot.readMessageEnd()
826 
      raise x
827 
    result = getOrdersByBillingDate_result()
828 
    result.read(self._iprot)
829 
    self._iprot.readMessageEnd()
830 
    if result.success != None:
831 
      return result.success
832 
    if result.ex != None:
833 
      raise result.ex
834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
835 
 
1382 varun.gupt 836 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
837 
    """
838 
    Returns order ids for orders which can be returned
839 
 
840 
    Parameters:
841 
     - customer_id
842 
     - limit
843 
    """
844 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
845 
    return self.recv_getReturnableOrdersForCustomer()
846 
 
847 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
848 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
849 
    args = getReturnableOrdersForCustomer_args()
850 
    args.customer_id = customer_id
851 
    args.limit = limit
852 
    args.write(self._oprot)
853 
    self._oprot.writeMessageEnd()
854 
    self._oprot.trans.flush()
855 
 
856 
  def recv_getReturnableOrdersForCustomer(self, ):
857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
858 
    if mtype == TMessageType.EXCEPTION:
859 
      x = TApplicationException()
860 
      x.read(self._iprot)
861 
      self._iprot.readMessageEnd()
862 
      raise x
863 
    result = getReturnableOrdersForCustomer_result()
864 
    result.read(self._iprot)
865 
    self._iprot.readMessageEnd()
866 
    if result.success != None:
867 
      return result.success
868 
    if result.ex != None:
869 
      raise result.ex
870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
871 
 
872 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
873 
    """
874 
    Returns order ids for orders which can be cancelled
875 
 
876 
    Parameters:
877 
     - customer_id
878 
     - limit
879 
    """
880 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
881 
    return self.recv_getCancellableOrdersForCustomer()
882 
 
883 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
884 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
885 
    args = getCancellableOrdersForCustomer_args()
886 
    args.customer_id = customer_id
887 
    args.limit = limit
888 
    args.write(self._oprot)
889 
    self._oprot.writeMessageEnd()
890 
    self._oprot.trans.flush()
891 
 
892 
  def recv_getCancellableOrdersForCustomer(self, ):
893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
894 
    if mtype == TMessageType.EXCEPTION:
895 
      x = TApplicationException()
896 
      x.read(self._iprot)
897 
      self._iprot.readMessageEnd()
898 
      raise x
899 
    result = getCancellableOrdersForCustomer_result()
900 
    result.read(self._iprot)
901 
    self._iprot.readMessageEnd()
902 
    if result.success != None:
903 
      return result.success
904 
    if result.ex != None:
905 
      raise result.ex
906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
907 
 
483 rajveer 908 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 909 
    """
910 
    Parameters:
483 rajveer 911 
     - orderId
912 
     - status
913 
     - description
94 ashish 914 
    """
483 rajveer 915 
    self.send_changeOrderStatus(orderId, status, description)
916 
    return self.recv_changeOrderStatus()
94 ashish 917 
 
483 rajveer 918 
  def send_changeOrderStatus(self, orderId, status, description):
919 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
920 
    args = changeOrderStatus_args()
921 
    args.orderId = orderId
922 
    args.status = status
923 
    args.description = description
94 ashish 924 
    args.write(self._oprot)
925 
    self._oprot.writeMessageEnd()
926 
    self._oprot.trans.flush()
927 
 
483 rajveer 928 
  def recv_changeOrderStatus(self, ):
94 ashish 929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
930 
    if mtype == TMessageType.EXCEPTION:
931 
      x = TApplicationException()
932 
      x.read(self._iprot)
933 
      self._iprot.readMessageEnd()
934 
      raise x
483 rajveer 935 
    result = changeOrderStatus_result()
94 ashish 936 
    result.read(self._iprot)
937 
    self._iprot.readMessageEnd()
938 
    if result.success != None:
939 
      return result.success
940 
    if result.ex != None:
941 
      raise result.ex
483 rajveer 942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 943 
 
1149 chandransh 944 
  def addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 945 
    """
1149 chandransh 946 
    Add billing details such as the bill number and the biller to the Order.
947 
 
494 rajveer 948 
    Parameters:
949 
     - orderId
950 
     - invoice_number
951 
     - billed_by
952 
    """
1149 chandransh 953 
    self.send_addBillingDetails(orderId, invoice_number, billed_by)
494 rajveer 954 
    return self.recv_addBillingDetails()
955 
 
1149 chandransh 956 
  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
494 rajveer 957 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
958 
    args = addBillingDetails_args()
959 
    args.orderId = orderId
960 
    args.invoice_number = invoice_number
961 
    args.billed_by = billed_by
962 
    args.write(self._oprot)
963 
    self._oprot.writeMessageEnd()
964 
    self._oprot.trans.flush()
965 
 
966 
  def recv_addBillingDetails(self, ):
967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
968 
    if mtype == TMessageType.EXCEPTION:
969 
      x = TApplicationException()
970 
      x.read(self._iprot)
971 
      self._iprot.readMessageEnd()
972 
      raise x
973 
    result = addBillingDetails_result()
974 
    result.read(self._iprot)
975 
    self._iprot.readMessageEnd()
976 
    if result.success != None:
977 
      return result.success
978 
    if result.ex != None:
979 
      raise result.ex
980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
981 
 
1149 chandransh 982 
  def addJacketNumber(self, orderId, jacketNumber):
983 
    """
2446 chandransh 984 
    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
985 
    Also marks the order as billed and sets the billing timestamp.
986 
    Return false if it doesn't find the order with the given ID.
1149 chandransh 987 
 
988 
    Parameters:
989 
     - orderId
990 
     - jacketNumber
991 
    """
992 
    self.send_addJacketNumber(orderId, jacketNumber)
993 
    return self.recv_addJacketNumber()
994 
 
995 
  def send_addJacketNumber(self, orderId, jacketNumber):
996 
    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
997 
    args = addJacketNumber_args()
998 
    args.orderId = orderId
999 
    args.jacketNumber = jacketNumber
1000 
    args.write(self._oprot)
1001 
    self._oprot.writeMessageEnd()
1002 
    self._oprot.trans.flush()
1003 
 
1004 
  def recv_addJacketNumber(self, ):
1005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1006 
    if mtype == TMessageType.EXCEPTION:
1007 
      x = TApplicationException()
1008 
      x.read(self._iprot)
1009 
      self._iprot.readMessageEnd()
1010 
      raise x
1011 
    result = addJacketNumber_result()
1012 
    result.read(self._iprot)
1013 
    self._iprot.readMessageEnd()
1014 
    if result.success != None:
1015 
      return result.success
1016 
    if result.ex != None:
1017 
      raise result.ex
1018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
1019 
 
921 rajveer 1020 
  def acceptOrder(self, orderId):
1021 
    """
1022 
    Parameters:
1023 
     - orderId
1024 
    """
1025 
    self.send_acceptOrder(orderId)
1026 
    return self.recv_acceptOrder()
1027 
 
1028 
  def send_acceptOrder(self, orderId):
1029 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
1030 
    args = acceptOrder_args()
1031 
    args.orderId = orderId
1032 
    args.write(self._oprot)
1033 
    self._oprot.writeMessageEnd()
1034 
    self._oprot.trans.flush()
1035 
 
1036 
  def recv_acceptOrder(self, ):
1037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1038 
    if mtype == TMessageType.EXCEPTION:
1039 
      x = TApplicationException()
1040 
      x.read(self._iprot)
1041 
      self._iprot.readMessageEnd()
1042 
      raise x
1043 
    result = acceptOrder_result()
1044 
    result.read(self._iprot)
1045 
    self._iprot.readMessageEnd()
1046 
    if result.success != None:
1047 
      return result.success
1048 
    if result.ex != None:
1049 
      raise result.ex
1050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1051 
 
1052 
  def billOrder(self, orderId):
1053 
    """
1054 
    Parameters:
1055 
     - orderId
1056 
    """
1057 
    self.send_billOrder(orderId)
1058 
    return self.recv_billOrder()
1059 
 
1060 
  def send_billOrder(self, orderId):
1061 
    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
1062 
    args = billOrder_args()
1063 
    args.orderId = orderId
1064 
    args.write(self._oprot)
1065 
    self._oprot.writeMessageEnd()
1066 
    self._oprot.trans.flush()
1067 
 
1068 
  def recv_billOrder(self, ):
1069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1070 
    if mtype == TMessageType.EXCEPTION:
1071 
      x = TApplicationException()
1072 
      x.read(self._iprot)
1073 
      self._iprot.readMessageEnd()
1074 
      raise x
1075 
    result = billOrder_result()
1076 
    result.read(self._iprot)
1077 
    self._iprot.readMessageEnd()
1078 
    if result.success != None:
1079 
      return result.success
1080 
    if result.ex != None:
1081 
      raise result.ex
1082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
1083 
 
1528 ankur.sing 1084 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1085 
    """
1528 ankur.sing 1086 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1087 
    only user who owns the transaction can view its order details.
1088 
 
94 ashish 1089 
    Parameters:
1090 
     - transactionId
1528 ankur.sing 1091 
     - customerId
94 ashish 1092 
    """
1528 ankur.sing 1093 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1094 
    return self.recv_getOrdersForTransaction()
94 ashish 1095 
 
1528 ankur.sing 1096 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1097 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1098 
    args = getOrdersForTransaction_args()
94 ashish 1099 
    args.transactionId = transactionId
1528 ankur.sing 1100 
    args.customerId = customerId
94 ashish 1101 
    args.write(self._oprot)
1102 
    self._oprot.writeMessageEnd()
1103 
    self._oprot.trans.flush()
1104 
 
483 rajveer 1105 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1107 
    if mtype == TMessageType.EXCEPTION:
1108 
      x = TApplicationException()
1109 
      x.read(self._iprot)
1110 
      self._iprot.readMessageEnd()
1111 
      raise x
483 rajveer 1112 
    result = getOrdersForTransaction_result()
94 ashish 1113 
    result.read(self._iprot)
1114 
    self._iprot.readMessageEnd()
1115 
    if result.success != None:
1116 
      return result.success
1117 
    if result.ex != None:
1118 
      raise result.ex
483 rajveer 1119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 1120 
 
483 rajveer 1121 
  def getOrdersForCustomer(self, customerId, from_date, to_date, status):
94 ashish 1122 
    """
1123 
    Parameters:
483 rajveer 1124 
     - customerId
1125 
     - from_date
1126 
     - to_date
1127 
     - status
94 ashish 1128 
    """
483 rajveer 1129 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, status)
1130 
    return self.recv_getOrdersForCustomer()
94 ashish 1131 
 
483 rajveer 1132 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, status):
1133 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
1134 
    args = getOrdersForCustomer_args()
1135 
    args.customerId = customerId
1136 
    args.from_date = from_date
1137 
    args.to_date = to_date
1138 
    args.status = status
94 ashish 1139 
    args.write(self._oprot)
1140 
    self._oprot.writeMessageEnd()
1141 
    self._oprot.trans.flush()
1142 
 
483 rajveer 1143 
  def recv_getOrdersForCustomer(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 = getOrdersForCustomer_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, "getOrdersForCustomer failed: unknown result");
94 ashish 1158 
 
483 rajveer 1159 
  def createOrder(self, order):
94 ashish 1160 
    """
1161 
    Parameters:
483 rajveer 1162 
     - order
94 ashish 1163 
    """
483 rajveer 1164 
    self.send_createOrder(order)
1165 
    return self.recv_createOrder()
94 ashish 1166 
 
483 rajveer 1167 
  def send_createOrder(self, order):
1168 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
1169 
    args = createOrder_args()
1170 
    args.order = order
94 ashish 1171 
    args.write(self._oprot)
1172 
    self._oprot.writeMessageEnd()
1173 
    self._oprot.trans.flush()
1174 
 
483 rajveer 1175 
  def recv_createOrder(self, ):
94 ashish 1176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1177 
    if mtype == TMessageType.EXCEPTION:
1178 
      x = TApplicationException()
1179 
      x.read(self._iprot)
1180 
      self._iprot.readMessageEnd()
1181 
      raise x
483 rajveer 1182 
    result = createOrder_result()
94 ashish 1183 
    result.read(self._iprot)
1184 
    self._iprot.readMessageEnd()
1185 
    if result.success != None:
1186 
      return result.success
1187 
    if result.ex != None:
1188 
      raise result.ex
483 rajveer 1189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 1190 
 
483 rajveer 1191 
  def getOrder(self, id):
94 ashish 1192 
    """
1193 
    Parameters:
483 rajveer 1194 
     - id
94 ashish 1195 
    """
483 rajveer 1196 
    self.send_getOrder(id)
1197 
    return self.recv_getOrder()
94 ashish 1198 
 
483 rajveer 1199 
  def send_getOrder(self, id):
1200 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
1201 
    args = getOrder_args()
1202 
    args.id = id
94 ashish 1203 
    args.write(self._oprot)
1204 
    self._oprot.writeMessageEnd()
1205 
    self._oprot.trans.flush()
1206 
 
483 rajveer 1207 
  def recv_getOrder(self, ):
94 ashish 1208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1209 
    if mtype == TMessageType.EXCEPTION:
1210 
      x = TApplicationException()
1211 
      x.read(self._iprot)
1212 
      self._iprot.readMessageEnd()
1213 
      raise x
483 rajveer 1214 
    result = getOrder_result()
94 ashish 1215 
    result.read(self._iprot)
1216 
    self._iprot.readMessageEnd()
1217 
    if result.success != None:
1218 
      return result.success
1219 
    if result.ex != None:
1220 
      raise result.ex
483 rajveer 1221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 1222 
 
483 rajveer 1223 
  def getLineItemsForOrder(self, orderId):
94 ashish 1224 
    """
1225 
    Parameters:
483 rajveer 1226 
     - orderId
94 ashish 1227 
    """
483 rajveer 1228 
    self.send_getLineItemsForOrder(orderId)
1229 
    return self.recv_getLineItemsForOrder()
94 ashish 1230 
 
483 rajveer 1231 
  def send_getLineItemsForOrder(self, orderId):
1232 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
1233 
    args = getLineItemsForOrder_args()
1234 
    args.orderId = orderId
94 ashish 1235 
    args.write(self._oprot)
1236 
    self._oprot.writeMessageEnd()
1237 
    self._oprot.trans.flush()
1238 
 
483 rajveer 1239 
  def recv_getLineItemsForOrder(self, ):
94 ashish 1240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1241 
    if mtype == TMessageType.EXCEPTION:
1242 
      x = TApplicationException()
1243 
      x.read(self._iprot)
1244 
      self._iprot.readMessageEnd()
1245 
      raise x
483 rajveer 1246 
    result = getLineItemsForOrder_result()
94 ashish 1247 
    result.read(self._iprot)
1248 
    self._iprot.readMessageEnd()
1249 
    if result.success != None:
1250 
      return result.success
1251 
    if result.ex != None:
1252 
      raise result.ex
483 rajveer 1253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 1254 
 
1528 ankur.sing 1255 
  def getOrderForCustomer(self, orderId, customerId):
1256 
    """
1257 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
1258 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
1259 
 
1260 
    Parameters:
1261 
     - orderId
1262 
     - customerId
1263 
    """
1264 
    self.send_getOrderForCustomer(orderId, customerId)
1265 
    return self.recv_getOrderForCustomer()
1266 
 
1267 
  def send_getOrderForCustomer(self, orderId, customerId):
1268 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
1269 
    args = getOrderForCustomer_args()
1270 
    args.orderId = orderId
1271 
    args.customerId = customerId
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_getOrderForCustomer(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = getOrderForCustomer_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
1286 
    if result.success != None:
1287 
      return result.success
1288 
    if result.ex != None:
1289 
      raise result.ex
1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
1291 
 
1220 chandransh 1292 
  def batchOrders(self, warehouseId):
1293 
    """
1294 
    Create a batch of all the pending orders for the given warehouse.
1295 
    The returned list is orderd by created_timestamp.
1296 
    If there are no pending orders, an empty list is returned.
1297 
 
1298 
    Parameters:
1299 
     - warehouseId
1300 
    """
1301 
    self.send_batchOrders(warehouseId)
1302 
    return self.recv_batchOrders()
1303 
 
1304 
  def send_batchOrders(self, warehouseId):
1305 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
1306 
    args = batchOrders_args()
1307 
    args.warehouseId = warehouseId
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_batchOrders(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = batchOrders_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
1322 
    if result.success != None:
1323 
      return result.success
1324 
    if result.ex != None:
1325 
      raise result.ex
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
1327 
 
1208 chandransh 1328 
  def markOrderAsOutOfStock(self, orderId):
1329 
    """
1330 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
1331 
 
1332 
    Parameters:
1333 
     - orderId
1334 
    """
1335 
    self.send_markOrderAsOutOfStock(orderId)
1336 
    return self.recv_markOrderAsOutOfStock()
1337 
 
1338 
  def send_markOrderAsOutOfStock(self, orderId):
1339 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
1340 
    args = markOrderAsOutOfStock_args()
1341 
    args.orderId = orderId
1342 
    args.write(self._oprot)
1343 
    self._oprot.writeMessageEnd()
1344 
    self._oprot.trans.flush()
1345 
 
1346 
  def recv_markOrderAsOutOfStock(self, ):
1347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1348 
    if mtype == TMessageType.EXCEPTION:
1349 
      x = TApplicationException()
1350 
      x.read(self._iprot)
1351 
      self._iprot.readMessageEnd()
1352 
      raise x
1353 
    result = markOrderAsOutOfStock_result()
1354 
    result.read(self._iprot)
1355 
    self._iprot.readMessageEnd()
1356 
    if result.success != None:
1357 
      return result.success
1358 
    if result.ex != None:
1359 
      raise result.ex
1360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
1361 
 
759 chandransh 1362 
  def markOrdersAsManifested(self, warehouseId, providerId):
1363 
    """
1364 
    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
1365 
 
1366 
    Parameters:
1367 
     - warehouseId
1368 
     - providerId
1369 
    """
1370 
    self.send_markOrdersAsManifested(warehouseId, providerId)
1371 
    return self.recv_markOrdersAsManifested()
1372 
 
1373 
  def send_markOrdersAsManifested(self, warehouseId, providerId):
1374 
    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
1375 
    args = markOrdersAsManifested_args()
1376 
    args.warehouseId = warehouseId
1377 
    args.providerId = providerId
1378 
    args.write(self._oprot)
1379 
    self._oprot.writeMessageEnd()
1380 
    self._oprot.trans.flush()
1381 
 
1382 
  def recv_markOrdersAsManifested(self, ):
1383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1384 
    if mtype == TMessageType.EXCEPTION:
1385 
      x = TApplicationException()
1386 
      x.read(self._iprot)
1387 
      self._iprot.readMessageEnd()
1388 
      raise x
1389 
    result = markOrdersAsManifested_result()
1390 
    result.read(self._iprot)
1391 
    self._iprot.readMessageEnd()
1392 
    if result.success != None:
1393 
      return result.success
1394 
    if result.ex != None:
1395 
      raise result.ex
1396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
1397 
 
1113 chandransh 1398 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
1399 
    """
1400 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
1401 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
1402 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1403 
 
1404 
    Parameters:
1405 
     - providerId
1406 
     - pickupDetails
1407 
    """
1408 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
1409 
    return self.recv_markOrdersAsPickedUp()
1410 
 
1411 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
1412 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
1413 
    args = markOrdersAsPickedUp_args()
1414 
    args.providerId = providerId
1415 
    args.pickupDetails = pickupDetails
1416 
    args.write(self._oprot)
1417 
    self._oprot.writeMessageEnd()
1418 
    self._oprot.trans.flush()
1419 
 
1420 
  def recv_markOrdersAsPickedUp(self, ):
1421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1422 
    if mtype == TMessageType.EXCEPTION:
1423 
      x = TApplicationException()
1424 
      x.read(self._iprot)
1425 
      self._iprot.readMessageEnd()
1426 
      raise x
1427 
    result = markOrdersAsPickedUp_result()
1428 
    result.read(self._iprot)
1429 
    self._iprot.readMessageEnd()
1430 
    if result.success != None:
1431 
      return result.success
1432 
    if result.ex != None:
1433 
      raise result.ex
1434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
1435 
 
1132 chandransh 1436 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
1437 
    """
1438 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
1439 
    the name of the receiver.
1440 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1441 
 
1442 
    Parameters:
1443 
     - providerId
1444 
     - deliveredOrders
1445 
    """
1446 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
1447 
    self.recv_markOrdersAsDelivered()
1448 
 
1449 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
1450 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
1451 
    args = markOrdersAsDelivered_args()
1452 
    args.providerId = providerId
1453 
    args.deliveredOrders = deliveredOrders
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_markOrdersAsDelivered(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = markOrdersAsDelivered_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
1468 
    if result.ex != None:
1469 
      raise result.ex
1470 
    return
1471 
 
1135 chandransh 1472 
  def markOrdersAsFailed(self, providerId, returnedOrders):
1473 
    """
1474 
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
1475 
    Raises an exception if we encounter report for an AWB number that we did not ship.
1476 
 
1477 
    Parameters:
1478 
     - providerId
1479 
     - returnedOrders
1480 
    """
1481 
    self.send_markOrdersAsFailed(providerId, returnedOrders)
1482 
    self.recv_markOrdersAsFailed()
1483 
 
1484 
  def send_markOrdersAsFailed(self, providerId, returnedOrders):
1485 
    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
1486 
    args = markOrdersAsFailed_args()
1487 
    args.providerId = providerId
1488 
    args.returnedOrders = returnedOrders
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_markOrdersAsFailed(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = markOrdersAsFailed_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
1503 
    if result.ex != None:
1504 
      raise result.ex
1505 
    return
1506 
 
1246 chandransh 1507 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1508 
    """
1509 
    Update the status description of orders whose AWB numbers are keys of the Map.
1510 
 
1511 
    Parameters:
1512 
     - providerId
1513 
     - undeliveredOrders
1514 
    """
1515 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
1516 
    self.recv_updateNonDeliveryReason()
1517 
 
1518 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
1519 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
1520 
    args = updateNonDeliveryReason_args()
1521 
    args.providerId = providerId
1522 
    args.undeliveredOrders = undeliveredOrders
1523 
    args.write(self._oprot)
1524 
    self._oprot.writeMessageEnd()
1525 
    self._oprot.trans.flush()
1526 
 
1527 
  def recv_updateNonDeliveryReason(self, ):
1528 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1529 
    if mtype == TMessageType.EXCEPTION:
1530 
      x = TApplicationException()
1531 
      x.read(self._iprot)
1532 
      self._iprot.readMessageEnd()
1533 
      raise x
1534 
    result = updateNonDeliveryReason_result()
1535 
    result.read(self._iprot)
1536 
    self._iprot.readMessageEnd()
1537 
    if result.ex != None:
1538 
      raise result.ex
1539 
    return
1540 
 
1408 ankur.sing 1541 
  def getUndeliveredOrders(self, providerId, warehouseId):
1542 
    """
1543 
    Returns the list of orders whose delivery time has passed but have not been
1544 
    delivered yet for the given provider and warehouse. To get a complete list of
1545 
    undelivered orders, pass them as -1.
1546 
    Returns an empty list if no such orders exist.
1547 
 
1548 
    Parameters:
1549 
     - providerId
1550 
     - warehouseId
1551 
    """
1552 
    self.send_getUndeliveredOrders(providerId, warehouseId)
1553 
    return self.recv_getUndeliveredOrders()
1554 
 
1555 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
1556 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
1557 
    args = getUndeliveredOrders_args()
1558 
    args.providerId = providerId
1559 
    args.warehouseId = warehouseId
1560 
    args.write(self._oprot)
1561 
    self._oprot.writeMessageEnd()
1562 
    self._oprot.trans.flush()
1563 
 
1564 
  def recv_getUndeliveredOrders(self, ):
1565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1566 
    if mtype == TMessageType.EXCEPTION:
1567 
      x = TApplicationException()
1568 
      x.read(self._iprot)
1569 
      self._iprot.readMessageEnd()
1570 
      raise x
1571 
    result = getUndeliveredOrders_result()
1572 
    result.read(self._iprot)
1573 
    self._iprot.readMessageEnd()
1574 
    if result.success != None:
1575 
      return result.success
1576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1577 
 
483 rajveer 1578 
  def getAlerts(self, orderId, valid):
94 ashish 1579 
    """
1580 
    Parameters:
483 rajveer 1581 
     - orderId
304 ashish 1582 
     - valid
1583 
    """
483 rajveer 1584 
    self.send_getAlerts(orderId, valid)
304 ashish 1585 
    return self.recv_getAlerts()
94 ashish 1586 
 
483 rajveer 1587 
  def send_getAlerts(self, orderId, valid):
304 ashish 1588 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
1589 
    args = getAlerts_args()
483 rajveer 1590 
    args.orderId = orderId
304 ashish 1591 
    args.valid = valid
1592 
    args.write(self._oprot)
1593 
    self._oprot.writeMessageEnd()
1594 
    self._oprot.trans.flush()
1595 
 
1596 
  def recv_getAlerts(self, ):
1597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1598 
    if mtype == TMessageType.EXCEPTION:
1599 
      x = TApplicationException()
1600 
      x.read(self._iprot)
1601 
      self._iprot.readMessageEnd()
1602 
      raise x
1603 
    result = getAlerts_result()
1604 
    result.read(self._iprot)
1605 
    self._iprot.readMessageEnd()
1606 
    if result.success != None:
1607 
      return result.success
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
1609 
 
483 rajveer 1610 
  def setAlert(self, orderId, unset, type, comment):
304 ashish 1611 
    """
1612 
    Parameters:
483 rajveer 1613 
     - orderId
304 ashish 1614 
     - unset
1615 
     - type
1616 
     - comment
1617 
    """
483 rajveer 1618 
    self.send_setAlert(orderId, unset, type, comment)
304 ashish 1619 
    self.recv_setAlert()
1620 
 
483 rajveer 1621 
  def send_setAlert(self, orderId, unset, type, comment):
304 ashish 1622 
    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
1623 
    args = setAlert_args()
483 rajveer 1624 
    args.orderId = orderId
304 ashish 1625 
    args.unset = unset
1626 
    args.type = type
1627 
    args.comment = comment
1628 
    args.write(self._oprot)
1629 
    self._oprot.writeMessageEnd()
1630 
    self._oprot.trans.flush()
1631 
 
1632 
  def recv_setAlert(self, ):
1633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1634 
    if mtype == TMessageType.EXCEPTION:
1635 
      x = TApplicationException()
1636 
      x.read(self._iprot)
1637 
      self._iprot.readMessageEnd()
1638 
      raise x
1639 
    result = setAlert_result()
1640 
    result.read(self._iprot)
1641 
    self._iprot.readMessageEnd()
1642 
    return
1643 
 
1596 ankur.sing 1644 
  def getValidOrderCount(self, ):
1645 
    """
1646 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1647 
    """
1648 
    self.send_getValidOrderCount()
1649 
    return self.recv_getValidOrderCount()
304 ashish 1650 
 
1596 ankur.sing 1651 
  def send_getValidOrderCount(self, ):
1652 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
1653 
    args = getValidOrderCount_args()
1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getValidOrderCount(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getValidOrderCount_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
1668 
    if result.success != None:
1669 
      return result.success
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
1671 
 
1627 ankur.sing 1672 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
1673 
    """
1674 
    Returns the number of distinct customers who have done successful transactions
1675 
    """
1676 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
1677 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
1596 ankur.sing 1678 
 
1627 ankur.sing 1679 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
1680 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
1681 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
1682 
    args.write(self._oprot)
1683 
    self._oprot.writeMessageEnd()
1684 
    self._oprot.trans.flush()
1685 
 
1686 
  def recv_getNoOfCustomersWithSuccessfulTransaction(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 = getNoOfCustomersWithSuccessfulTransaction_result()
1694 
    result.read(self._iprot)
1695 
    self._iprot.readMessageEnd()
1696 
    if result.success != None:
1697 
      return result.success
1698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
1699 
 
1731 ankur.sing 1700 
  def getValidOrdersAmountRange(self, ):
1627 ankur.sing 1701 
    """
1731 ankur.sing 1702 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
1703 
    List contains two values, first minimum amount and second maximum amount.
1627 ankur.sing 1704 
    """
1731 ankur.sing 1705 
    self.send_getValidOrdersAmountRange()
1706 
    return self.recv_getValidOrdersAmountRange()
1627 ankur.sing 1707 
 
1731 ankur.sing 1708 
  def send_getValidOrdersAmountRange(self, ):
1709 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
1710 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 1711 
    args.write(self._oprot)
1712 
    self._oprot.writeMessageEnd()
1713 
    self._oprot.trans.flush()
1714 
 
1731 ankur.sing 1715 
  def recv_getValidOrdersAmountRange(self, ):
1627 ankur.sing 1716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1717 
    if mtype == TMessageType.EXCEPTION:
1718 
      x = TApplicationException()
1719 
      x.read(self._iprot)
1720 
      self._iprot.readMessageEnd()
1721 
      raise x
1731 ankur.sing 1722 
    result = getValidOrdersAmountRange_result()
1627 ankur.sing 1723 
    result.read(self._iprot)
1724 
    self._iprot.readMessageEnd()
1725 
    if result.success != None:
1726 
      return result.success
1731 ankur.sing 1727 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
1627 ankur.sing 1728 
 
1886 ankur.sing 1729 
  def getValidOrders(self, limit):
1730 
    """
1731 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
1732 
    If limit is passed as 0, then all valid Orders are returned.
1733 
 
1734 
    Parameters:
1735 
     - limit
1736 
    """
1737 
    self.send_getValidOrders(limit)
1738 
    return self.recv_getValidOrders()
1627 ankur.sing 1739 
 
1886 ankur.sing 1740 
  def send_getValidOrders(self, limit):
1741 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
1742 
    args = getValidOrders_args()
1743 
    args.limit = limit
1744 
    args.write(self._oprot)
1745 
    self._oprot.writeMessageEnd()
1746 
    self._oprot.trans.flush()
1747 
 
1748 
  def recv_getValidOrders(self, ):
1749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1750 
    if mtype == TMessageType.EXCEPTION:
1751 
      x = TApplicationException()
1752 
      x.read(self._iprot)
1753 
      self._iprot.readMessageEnd()
1754 
      raise x
1755 
    result = getValidOrders_result()
1756 
    result.read(self._iprot)
1757 
    self._iprot.readMessageEnd()
1758 
    if result.success != None:
1759 
      return result.success
1760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
1761 
 
2536 chandransh 1762 
  def toggleDOAFlag(self, orderId):
1763 
    """
1764 
    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.
1765 
    Returns the final flag status.
1766 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
1767 
 
1768 
    Parameters:
1769 
     - orderId
1770 
    """
1771 
    self.send_toggleDOAFlag(orderId)
1772 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 1773 
 
2536 chandransh 1774 
  def send_toggleDOAFlag(self, orderId):
1775 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
1776 
    args = toggleDOAFlag_args()
1777 
    args.orderId = orderId
1778 
    args.write(self._oprot)
1779 
    self._oprot.writeMessageEnd()
1780 
    self._oprot.trans.flush()
1781 
 
1782 
  def recv_toggleDOAFlag(self, ):
1783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1784 
    if mtype == TMessageType.EXCEPTION:
1785 
      x = TApplicationException()
1786 
      x.read(self._iprot)
1787 
      self._iprot.readMessageEnd()
1788 
      raise x
1789 
    result = toggleDOAFlag_result()
1790 
    result.read(self._iprot)
1791 
    self._iprot.readMessageEnd()
1792 
    if result.success != None:
1793 
      return result.success
1794 
    if result.ex != None:
1795 
      raise result.ex
1796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
1797 
 
1798 
  def requestPickupNumber(self, orderId):
1799 
    """
1800 
    Sends out an email to the account manager of the original courier provider used to ship the order.
1801 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
1802 
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
1803 
    For any other status, it returns false.
1804 
    Throws an exception if the order with the given id couldn't be found.
1805 
 
1806 
    Parameters:
1807 
     - orderId
1808 
    """
1809 
    self.send_requestPickupNumber(orderId)
1810 
    return self.recv_requestPickupNumber()
1811 
 
1812 
  def send_requestPickupNumber(self, orderId):
1813 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
1814 
    args = requestPickupNumber_args()
1815 
    args.orderId = orderId
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_requestPickupNumber(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = requestPickupNumber_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
1830 
    if result.success != None:
1831 
      return result.success
1832 
    if result.ex != None:
1833 
      raise result.ex
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
1835 
 
1836 
  def authorizePickup(self, orderId, pickupNumber):
1837 
    """
1838 
    If the order status is DOA_PICKUP_REQUESTED, it does the following
1839 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
1840 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
1841 
    	3. Returns true
2591 chandransh 1842 
    If the order is in any other status, it returns false.
2536 chandransh 1843 
    Throws an exception if the order with the given id couldn't be found.
1844 
 
1845 
    Parameters:
1846 
     - orderId
1847 
     - pickupNumber
1848 
    """
1849 
    self.send_authorizePickup(orderId, pickupNumber)
1850 
    return self.recv_authorizePickup()
1851 
 
1852 
  def send_authorizePickup(self, orderId, pickupNumber):
1853 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
1854 
    args = authorizePickup_args()
1855 
    args.orderId = orderId
1856 
    args.pickupNumber = pickupNumber
1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
1861 
  def recv_authorizePickup(self, ):
1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
1868 
    result = authorizePickup_result()
1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
1871 
    if result.success != None:
1872 
      return result.success
1873 
    if result.ex != None:
1874 
      raise result.ex
1875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
1876 
 
2616 chandransh 1877 
  def receiveReturn(self, orderId):
2591 chandransh 1878 
    """
2599 chandransh 1879 
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
2616 chandransh 1880 
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
2591 chandransh 1881 
    If the order is in any other state, it returns false.
1882 
    Throws an exception if the order with the given id couldn't be found.
1883 
 
1884 
    Parameters:
1885 
     - orderId
1886 
    """
2616 chandransh 1887 
    self.send_receiveReturn(orderId)
1888 
    return self.recv_receiveReturn()
2536 chandransh 1889 
 
2616 chandransh 1890 
  def send_receiveReturn(self, orderId):
1891 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
1892 
    args = receiveReturn_args()
2591 chandransh 1893 
    args.orderId = orderId
1894 
    args.write(self._oprot)
1895 
    self._oprot.writeMessageEnd()
1896 
    self._oprot.trans.flush()
1897 
 
2616 chandransh 1898 
  def recv_receiveReturn(self, ):
2591 chandransh 1899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1900 
    if mtype == TMessageType.EXCEPTION:
1901 
      x = TApplicationException()
1902 
      x.read(self._iprot)
1903 
      self._iprot.readMessageEnd()
1904 
      raise x
2616 chandransh 1905 
    result = receiveReturn_result()
2591 chandransh 1906 
    result.read(self._iprot)
1907 
    self._iprot.readMessageEnd()
1908 
    if result.success != None:
1909 
      return result.success
1910 
    if result.ex != None:
1911 
      raise result.ex
2616 chandransh 1912 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 1913 
 
1914 
  def validateDoa(self, orderId, isValid):
1915 
    """
2599 chandransh 1916 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
2616 chandransh 1917 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 1918 
    If the order is in any other state, it returns false.
1919 
    Throws an exception if the order with the given id couldn't be found.
1920 
 
1921 
    Parameters:
1922 
     - orderId
1923 
     - isValid
1924 
    """
1925 
    self.send_validateDoa(orderId, isValid)
1926 
    return self.recv_validateDoa()
1927 
 
1928 
  def send_validateDoa(self, orderId, isValid):
1929 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
1930 
    args = validateDoa_args()
1931 
    args.orderId = orderId
1932 
    args.isValid = isValid
1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
1937 
  def recv_validateDoa(self, ):
1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
1944 
    result = validateDoa_result()
1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
1947 
    if result.success != None:
1948 
      return result.success
1949 
    if result.ex != None:
1950 
      raise result.ex
1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
1952 
 
2616 chandransh 1953 
  def reshipOrder(self, orderId):
1954 
    """
1955 
    If the order is in SALES_RET_RECEIVED or DOA_CERT_INVALID state, it does the following:
1956 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
1957 
    	2. Marks the current order as one of the final states SALES_RET_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
1958 
 
1959 
    If the order is in DOA_CERT_VALID state, it does the following:
1960 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
1961 
    	2. Creates a return order for the warehouse executive to return the DOA material.
1962 
    	3. Marks the current order as the final DOA_RESHIPPED state.
1963 
 
1964 
    Returns the id of the newly created order.
1965 
 
1966 
    Throws an exception if the order with the given id couldn't be found.
1967 
 
1968 
    Parameters:
1969 
     - orderId
1970 
    """
1971 
    self.send_reshipOrder(orderId)
1972 
    return self.recv_reshipOrder()
2591 chandransh 1973 
 
2616 chandransh 1974 
  def send_reshipOrder(self, orderId):
1975 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
1976 
    args = reshipOrder_args()
1977 
    args.orderId = orderId
1978 
    args.write(self._oprot)
1979 
    self._oprot.writeMessageEnd()
1980 
    self._oprot.trans.flush()
1981 
 
1982 
  def recv_reshipOrder(self, ):
1983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1984 
    if mtype == TMessageType.EXCEPTION:
1985 
      x = TApplicationException()
1986 
      x.read(self._iprot)
1987 
      self._iprot.readMessageEnd()
1988 
      raise x
1989 
    result = reshipOrder_result()
1990 
    result.read(self._iprot)
1991 
    self._iprot.readMessageEnd()
1992 
    if result.success != None:
1993 
      return result.success
1994 
    if result.ex != None:
1995 
      raise result.ex
1996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
1997 
 
1998 
  def refundOrder(self, orderId):
1999 
    """
2000 
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2001 
    	1. Creates a refund request for batch processing.
2002 
    	2. Creates a return order for the warehouse executive to return the shipped material.
2003 
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
2004 
 
2005 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
2006 
    	1. Creates a refund request for batch processing.
2007 
    	2. Marks the current order as the REFUNDED final state.
2008 
 
2009 
    Returns True if it is successful, False otherwise.
2010 
 
2011 
    Throws an exception if the order with the given id couldn't be found.
2012 
 
2013 
    Parameters:
2014 
     - orderId
2015 
    """
2016 
    self.send_refundOrder(orderId)
2017 
    return self.recv_refundOrder()
2018 
 
2019 
  def send_refundOrder(self, orderId):
2020 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
2021 
    args = refundOrder_args()
2022 
    args.orderId = orderId
2023 
    args.write(self._oprot)
2024 
    self._oprot.writeMessageEnd()
2025 
    self._oprot.trans.flush()
2026 
 
2027 
  def recv_refundOrder(self, ):
2028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2029 
    if mtype == TMessageType.EXCEPTION:
2030 
      x = TApplicationException()
2031 
      x.read(self._iprot)
2032 
      self._iprot.readMessageEnd()
2033 
      raise x
2034 
    result = refundOrder_result()
2035 
    result.read(self._iprot)
2036 
    self._iprot.readMessageEnd()
2037 
    if result.success != None:
2038 
      return result.success
2039 
    if result.ex != None:
2040 
      raise result.ex
2041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
2042 
 
2690 chandransh 2043 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
2044 
    """
2045 
    Get all return orders created between the from and to dates for the given warehouse.
2046 
    Ignores the warehouse if it is passed as -1.
2047 
 
2048 
    Parameters:
2049 
     - warehouseId
2050 
     - fromDate
2051 
     - toDate
2052 
    """
2053 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
2054 
    return self.recv_getReturnOrders()
2616 chandransh 2055 
 
2690 chandransh 2056 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
2057 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
2058 
    args = getReturnOrders_args()
2059 
    args.warehouseId = warehouseId
2060 
    args.fromDate = fromDate
2061 
    args.toDate = toDate
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_getReturnOrders(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = getReturnOrders_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
2076 
    if result.success != None:
2077 
      return result.success
2078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
2079 
 
2700 chandransh 2080 
  def getReturnOrder(self, id):
2081 
    """
2082 
    Returns the ReturnOrder corresponding to the given id.
2083 
    Throws an exception if the return order with the given id couldn't be found.
2084 
 
2085 
    Parameters:
2086 
     - id
2087 
    """
2088 
    self.send_getReturnOrder(id)
2089 
    return self.recv_getReturnOrder()
2090 
 
2091 
  def send_getReturnOrder(self, id):
2092 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
2093 
    args = getReturnOrder_args()
2094 
    args.id = id
2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
2099 
  def recv_getReturnOrder(self, ):
2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
2106 
    result = getReturnOrder_result()
2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success != None:
2110 
      return result.success
2111 
    if result.ex != None:
2112 
      raise result.ex
2113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
2114 
 
2690 chandransh 2115 
  def processReturn(self, returnOrderId):
2116 
    """
2117 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
2118 
 
2119 
    Parameters:
2120 
     - returnOrderId
2121 
    """
2122 
    self.send_processReturn(returnOrderId)
2123 
    self.recv_processReturn()
2124 
 
2125 
  def send_processReturn(self, returnOrderId):
2126 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
2127 
    args = processReturn_args()
2128 
    args.returnOrderId = returnOrderId
2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
2133 
  def recv_processReturn(self, ):
2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
2140 
    result = processReturn_result()
2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
2143 
    if result.ex != None:
2144 
      raise result.ex
2145 
    return
2146 
 
2147 
 
94 ashish 2148 
class Processor(Iface, TProcessor):
2149 
  def __init__(self, handler):
2150 
    self._handler = handler
2151 
    self._processMap = {}
765 rajveer 2152 
    self._processMap["closeSession"] = Processor.process_closeSession
94 ashish 2153 
    self._processMap["createTransaction"] = Processor.process_createTransaction
2154 
    self._processMap["getTransaction"] = Processor.process_getTransaction
2155 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 2156 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 2157 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
2158 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 2159 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 2160 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
999 varun.gupt 2161 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
1382 varun.gupt 2162 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
2163 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 2164 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
494 rajveer 2165 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
1149 chandransh 2166 
    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
921 rajveer 2167 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
2168 
    self._processMap["billOrder"] = Processor.process_billOrder
483 rajveer 2169 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
2170 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
2171 
    self._processMap["createOrder"] = Processor.process_createOrder
2172 
    self._processMap["getOrder"] = Processor.process_getOrder
2173 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
1528 ankur.sing 2174 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
1220 chandransh 2175 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 2176 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
759 chandransh 2177 
    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
1113 chandransh 2178 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
1132 chandransh 2179 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
1135 chandransh 2180 
    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
1246 chandransh 2181 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
1408 ankur.sing 2182 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
304 ashish 2183 
    self._processMap["getAlerts"] = Processor.process_getAlerts
2184 
    self._processMap["setAlert"] = Processor.process_setAlert
1596 ankur.sing 2185 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
1627 ankur.sing 2186 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
1731 ankur.sing 2187 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
1886 ankur.sing 2188 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
2536 chandransh 2189 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
2190 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
2191 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2616 chandransh 2192 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 2193 
    self._processMap["validateDoa"] = Processor.process_validateDoa
2616 chandransh 2194 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
2195 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 2196 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
2700 chandransh 2197 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 2198 
    self._processMap["processReturn"] = Processor.process_processReturn
94 ashish 2199 
 
2200 
  def process(self, iprot, oprot):
2201 
    (name, type, seqid) = iprot.readMessageBegin()
2202 
    if name not in self._processMap:
2203 
      iprot.skip(TType.STRUCT)
2204 
      iprot.readMessageEnd()
2205 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2206 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2207 
      x.write(oprot)
2208 
      oprot.writeMessageEnd()
2209 
      oprot.trans.flush()
2210 
      return
2211 
    else:
2212 
      self._processMap[name](self, seqid, iprot, oprot)
2213 
    return True
2214 
 
765 rajveer 2215 
  def process_closeSession(self, seqid, iprot, oprot):
2216 
    args = closeSession_args()
2217 
    args.read(iprot)
2218 
    iprot.readMessageEnd()
2219 
    result = closeSession_result()
2220 
    self._handler.closeSession()
2221 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2222 
    result.write(oprot)
2223 
    oprot.writeMessageEnd()
2224 
    oprot.trans.flush()
2225 
 
94 ashish 2226 
  def process_createTransaction(self, seqid, iprot, oprot):
2227 
    args = createTransaction_args()
2228 
    args.read(iprot)
2229 
    iprot.readMessageEnd()
2230 
    result = createTransaction_result()
2231 
    try:
132 ashish 2232 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 2233 
    except TransactionServiceException, ex:
2234 
      result.ex = ex
2235 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
2236 
    result.write(oprot)
2237 
    oprot.writeMessageEnd()
2238 
    oprot.trans.flush()
2239 
 
2240 
  def process_getTransaction(self, seqid, iprot, oprot):
2241 
    args = getTransaction_args()
2242 
    args.read(iprot)
2243 
    iprot.readMessageEnd()
2244 
    result = getTransaction_result()
2245 
    try:
2246 
      result.success = self._handler.getTransaction(args.id)
2247 
    except TransactionServiceException, ex:
2248 
      result.ex = ex
2249 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
2250 
    result.write(oprot)
2251 
    oprot.writeMessageEnd()
2252 
    oprot.trans.flush()
2253 
 
2254 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
2255 
    args = getTransactionsForCustomer_args()
2256 
    args.read(iprot)
2257 
    iprot.readMessageEnd()
2258 
    result = getTransactionsForCustomer_result()
2259 
    try:
2260 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
2261 
    except TransactionServiceException, ex:
2262 
      result.ex = ex
2263 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
2264 
    result.write(oprot)
2265 
    oprot.writeMessageEnd()
2266 
    oprot.trans.flush()
2267 
 
132 ashish 2268 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
2269 
    args = getTransactionsForShoppingCartId_args()
2270 
    args.read(iprot)
2271 
    iprot.readMessageEnd()
2272 
    result = getTransactionsForShoppingCartId_result()
2273 
    try:
2274 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
2275 
    except TransactionServiceException, ex:
2276 
      result.ex = ex
2277 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
2278 
    result.write(oprot)
2279 
    oprot.writeMessageEnd()
2280 
    oprot.trans.flush()
2281 
 
94 ashish 2282 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
2283 
    args = getTransactionStatus_args()
2284 
    args.read(iprot)
2285 
    iprot.readMessageEnd()
2286 
    result = getTransactionStatus_result()
2287 
    try:
2288 
      result.success = self._handler.getTransactionStatus(args.transactionId)
2289 
    except TransactionServiceException, ex:
2290 
      result.ex = ex
2291 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
2292 
    result.write(oprot)
2293 
    oprot.writeMessageEnd()
2294 
    oprot.trans.flush()
2295 
 
2296 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
2297 
    args = changeTransactionStatus_args()
2298 
    args.read(iprot)
2299 
    iprot.readMessageEnd()
2300 
    result = changeTransactionStatus_result()
2301 
    try:
2302 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description)
2303 
    except TransactionServiceException, ex:
2304 
      result.ex = ex
2305 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
2306 
    result.write(oprot)
2307 
    oprot.writeMessageEnd()
2308 
    oprot.trans.flush()
2309 
 
1398 varun.gupt 2310 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
2311 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 2312 
    args.read(iprot)
2313 
    iprot.readMessageEnd()
1398 varun.gupt 2314 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 2315 
    try:
1398 varun.gupt 2316 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 2317 
    except TransactionServiceException, ex:
2318 
      result.ex = ex
1398 varun.gupt 2319 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 2320 
    result.write(oprot)
2321 
    oprot.writeMessageEnd()
2322 
    oprot.trans.flush()
2323 
 
483 rajveer 2324 
  def process_getAllOrders(self, seqid, iprot, oprot):
2325 
    args = getAllOrders_args()
94 ashish 2326 
    args.read(iprot)
2327 
    iprot.readMessageEnd()
483 rajveer 2328 
    result = getAllOrders_result()
94 ashish 2329 
    try:
483 rajveer 2330 
      result.success = self._handler.getAllOrders(args.status, args.from_date, args.to_date, args.warehouse_id)
94 ashish 2331 
    except TransactionServiceException, ex:
2332 
      result.ex = ex
483 rajveer 2333 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 2334 
    result.write(oprot)
2335 
    oprot.writeMessageEnd()
2336 
    oprot.trans.flush()
2337 
 
999 varun.gupt 2338 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
2339 
    args = getOrdersByBillingDate_args()
2340 
    args.read(iprot)
2341 
    iprot.readMessageEnd()
2342 
    result = getOrdersByBillingDate_result()
2343 
    try:
2344 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
2345 
    except TransactionServiceException, ex:
2346 
      result.ex = ex
2347 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
2348 
    result.write(oprot)
2349 
    oprot.writeMessageEnd()
2350 
    oprot.trans.flush()
2351 
 
1382 varun.gupt 2352 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
2353 
    args = getReturnableOrdersForCustomer_args()
2354 
    args.read(iprot)
2355 
    iprot.readMessageEnd()
2356 
    result = getReturnableOrdersForCustomer_result()
2357 
    try:
2358 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
2359 
    except TransactionServiceException, ex:
2360 
      result.ex = ex
2361 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
2362 
    result.write(oprot)
2363 
    oprot.writeMessageEnd()
2364 
    oprot.trans.flush()
2365 
 
2366 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
2367 
    args = getCancellableOrdersForCustomer_args()
2368 
    args.read(iprot)
2369 
    iprot.readMessageEnd()
2370 
    result = getCancellableOrdersForCustomer_result()
2371 
    try:
2372 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
2373 
    except TransactionServiceException, ex:
2374 
      result.ex = ex
2375 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
2376 
    result.write(oprot)
2377 
    oprot.writeMessageEnd()
2378 
    oprot.trans.flush()
2379 
 
483 rajveer 2380 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
2381 
    args = changeOrderStatus_args()
94 ashish 2382 
    args.read(iprot)
2383 
    iprot.readMessageEnd()
483 rajveer 2384 
    result = changeOrderStatus_result()
94 ashish 2385 
    try:
483 rajveer 2386 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 2387 
    except TransactionServiceException, ex:
2388 
      result.ex = ex
483 rajveer 2389 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 2390 
    result.write(oprot)
2391 
    oprot.writeMessageEnd()
2392 
    oprot.trans.flush()
2393 
 
494 rajveer 2394 
  def process_addBillingDetails(self, seqid, iprot, oprot):
2395 
    args = addBillingDetails_args()
2396 
    args.read(iprot)
2397 
    iprot.readMessageEnd()
2398 
    result = addBillingDetails_result()
2399 
    try:
1149 chandransh 2400 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
494 rajveer 2401 
    except TransactionServiceException, ex:
2402 
      result.ex = ex
2403 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
2404 
    result.write(oprot)
2405 
    oprot.writeMessageEnd()
2406 
    oprot.trans.flush()
2407 
 
1149 chandransh 2408 
  def process_addJacketNumber(self, seqid, iprot, oprot):
2409 
    args = addJacketNumber_args()
2410 
    args.read(iprot)
2411 
    iprot.readMessageEnd()
2412 
    result = addJacketNumber_result()
2413 
    try:
2414 
      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber)
2415 
    except TransactionServiceException, ex:
2416 
      result.ex = ex
2417 
    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
2418 
    result.write(oprot)
2419 
    oprot.writeMessageEnd()
2420 
    oprot.trans.flush()
2421 
 
921 rajveer 2422 
  def process_acceptOrder(self, seqid, iprot, oprot):
2423 
    args = acceptOrder_args()
2424 
    args.read(iprot)
2425 
    iprot.readMessageEnd()
2426 
    result = acceptOrder_result()
2427 
    try:
2428 
      result.success = self._handler.acceptOrder(args.orderId)
2429 
    except TransactionServiceException, ex:
2430 
      result.ex = ex
2431 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
2432 
    result.write(oprot)
2433 
    oprot.writeMessageEnd()
2434 
    oprot.trans.flush()
2435 
 
2436 
  def process_billOrder(self, seqid, iprot, oprot):
2437 
    args = billOrder_args()
2438 
    args.read(iprot)
2439 
    iprot.readMessageEnd()
2440 
    result = billOrder_result()
2441 
    try:
2442 
      result.success = self._handler.billOrder(args.orderId)
2443 
    except TransactionServiceException, ex:
2444 
      result.ex = ex
2445 
    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
2446 
    result.write(oprot)
2447 
    oprot.writeMessageEnd()
2448 
    oprot.trans.flush()
2449 
 
483 rajveer 2450 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
2451 
    args = getOrdersForTransaction_args()
94 ashish 2452 
    args.read(iprot)
2453 
    iprot.readMessageEnd()
483 rajveer 2454 
    result = getOrdersForTransaction_result()
94 ashish 2455 
    try:
1528 ankur.sing 2456 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 2457 
    except TransactionServiceException, ex:
2458 
      result.ex = ex
483 rajveer 2459 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 2460 
    result.write(oprot)
2461 
    oprot.writeMessageEnd()
2462 
    oprot.trans.flush()
2463 
 
483 rajveer 2464 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
2465 
    args = getOrdersForCustomer_args()
94 ashish 2466 
    args.read(iprot)
2467 
    iprot.readMessageEnd()
483 rajveer 2468 
    result = getOrdersForCustomer_result()
94 ashish 2469 
    try:
483 rajveer 2470 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.status)
94 ashish 2471 
    except TransactionServiceException, ex:
2472 
      result.ex = ex
483 rajveer 2473 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 2474 
    result.write(oprot)
2475 
    oprot.writeMessageEnd()
2476 
    oprot.trans.flush()
2477 
 
483 rajveer 2478 
  def process_createOrder(self, seqid, iprot, oprot):
2479 
    args = createOrder_args()
94 ashish 2480 
    args.read(iprot)
2481 
    iprot.readMessageEnd()
483 rajveer 2482 
    result = createOrder_result()
94 ashish 2483 
    try:
483 rajveer 2484 
      result.success = self._handler.createOrder(args.order)
94 ashish 2485 
    except TransactionServiceException, ex:
2486 
      result.ex = ex
483 rajveer 2487 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 2488 
    result.write(oprot)
2489 
    oprot.writeMessageEnd()
2490 
    oprot.trans.flush()
2491 
 
483 rajveer 2492 
  def process_getOrder(self, seqid, iprot, oprot):
2493 
    args = getOrder_args()
94 ashish 2494 
    args.read(iprot)
2495 
    iprot.readMessageEnd()
483 rajveer 2496 
    result = getOrder_result()
94 ashish 2497 
    try:
483 rajveer 2498 
      result.success = self._handler.getOrder(args.id)
94 ashish 2499 
    except TransactionServiceException, ex:
2500 
      result.ex = ex
483 rajveer 2501 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 2502 
    result.write(oprot)
2503 
    oprot.writeMessageEnd()
2504 
    oprot.trans.flush()
2505 
 
483 rajveer 2506 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
2507 
    args = getLineItemsForOrder_args()
94 ashish 2508 
    args.read(iprot)
2509 
    iprot.readMessageEnd()
483 rajveer 2510 
    result = getLineItemsForOrder_result()
94 ashish 2511 
    try:
483 rajveer 2512 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 2513 
    except TransactionServiceException, ex:
2514 
      result.ex = ex
483 rajveer 2515 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 2516 
    result.write(oprot)
2517 
    oprot.writeMessageEnd()
2518 
    oprot.trans.flush()
2519 
 
1528 ankur.sing 2520 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
2521 
    args = getOrderForCustomer_args()
2522 
    args.read(iprot)
2523 
    iprot.readMessageEnd()
2524 
    result = getOrderForCustomer_result()
2525 
    try:
2526 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
2527 
    except TransactionServiceException, ex:
2528 
      result.ex = ex
2529 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
2530 
    result.write(oprot)
2531 
    oprot.writeMessageEnd()
2532 
    oprot.trans.flush()
2533 
 
1220 chandransh 2534 
  def process_batchOrders(self, seqid, iprot, oprot):
2535 
    args = batchOrders_args()
2536 
    args.read(iprot)
2537 
    iprot.readMessageEnd()
2538 
    result = batchOrders_result()
2539 
    try:
2540 
      result.success = self._handler.batchOrders(args.warehouseId)
2541 
    except TransactionServiceException, ex:
2542 
      result.ex = ex
2543 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
2544 
    result.write(oprot)
2545 
    oprot.writeMessageEnd()
2546 
    oprot.trans.flush()
2547 
 
1208 chandransh 2548 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
2549 
    args = markOrderAsOutOfStock_args()
2550 
    args.read(iprot)
2551 
    iprot.readMessageEnd()
2552 
    result = markOrderAsOutOfStock_result()
2553 
    try:
2554 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
2555 
    except TransactionServiceException, ex:
2556 
      result.ex = ex
2557 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
2558 
    result.write(oprot)
2559 
    oprot.writeMessageEnd()
2560 
    oprot.trans.flush()
2561 
 
759 chandransh 2562 
  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
2563 
    args = markOrdersAsManifested_args()
2564 
    args.read(iprot)
2565 
    iprot.readMessageEnd()
2566 
    result = markOrdersAsManifested_result()
2567 
    try:
2568 
      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
2569 
    except TransactionServiceException, ex:
2570 
      result.ex = ex
2571 
    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
2572 
    result.write(oprot)
2573 
    oprot.writeMessageEnd()
2574 
    oprot.trans.flush()
2575 
 
1113 chandransh 2576 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
2577 
    args = markOrdersAsPickedUp_args()
2578 
    args.read(iprot)
2579 
    iprot.readMessageEnd()
2580 
    result = markOrdersAsPickedUp_result()
2581 
    try:
2582 
      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
2583 
    except TransactionServiceException, ex:
2584 
      result.ex = ex
2585 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
2586 
    result.write(oprot)
2587 
    oprot.writeMessageEnd()
2588 
    oprot.trans.flush()
2589 
 
1132 chandransh 2590 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
2591 
    args = markOrdersAsDelivered_args()
2592 
    args.read(iprot)
2593 
    iprot.readMessageEnd()
2594 
    result = markOrdersAsDelivered_result()
2595 
    try:
2596 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
2597 
    except TransactionServiceException, ex:
2598 
      result.ex = ex
2599 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
2600 
    result.write(oprot)
2601 
    oprot.writeMessageEnd()
2602 
    oprot.trans.flush()
2603 
 
1135 chandransh 2604 
  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
2605 
    args = markOrdersAsFailed_args()
2606 
    args.read(iprot)
2607 
    iprot.readMessageEnd()
2608 
    result = markOrdersAsFailed_result()
2609 
    try:
2610 
      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
2611 
    except TransactionServiceException, ex:
2612 
      result.ex = ex
2613 
    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
2614 
    result.write(oprot)
2615 
    oprot.writeMessageEnd()
2616 
    oprot.trans.flush()
2617 
 
1246 chandransh 2618 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
2619 
    args = updateNonDeliveryReason_args()
2620 
    args.read(iprot)
2621 
    iprot.readMessageEnd()
2622 
    result = updateNonDeliveryReason_result()
2623 
    try:
2624 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
2625 
    except TransactionServiceException, ex:
2626 
      result.ex = ex
2627 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
2628 
    result.write(oprot)
2629 
    oprot.writeMessageEnd()
2630 
    oprot.trans.flush()
2631 
 
1408 ankur.sing 2632 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
2633 
    args = getUndeliveredOrders_args()
2634 
    args.read(iprot)
2635 
    iprot.readMessageEnd()
2636 
    result = getUndeliveredOrders_result()
2637 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
2638 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
2639 
    result.write(oprot)
2640 
    oprot.writeMessageEnd()
2641 
    oprot.trans.flush()
2642 
 
304 ashish 2643 
  def process_getAlerts(self, seqid, iprot, oprot):
2644 
    args = getAlerts_args()
2645 
    args.read(iprot)
2646 
    iprot.readMessageEnd()
2647 
    result = getAlerts_result()
483 rajveer 2648 
    result.success = self._handler.getAlerts(args.orderId, args.valid)
304 ashish 2649 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
2650 
    result.write(oprot)
2651 
    oprot.writeMessageEnd()
2652 
    oprot.trans.flush()
94 ashish 2653 
 
304 ashish 2654 
  def process_setAlert(self, seqid, iprot, oprot):
2655 
    args = setAlert_args()
2656 
    args.read(iprot)
2657 
    iprot.readMessageEnd()
2658 
    result = setAlert_result()
483 rajveer 2659 
    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
304 ashish 2660 
    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
2661 
    result.write(oprot)
2662 
    oprot.writeMessageEnd()
2663 
    oprot.trans.flush()
2664 
 
1596 ankur.sing 2665 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
2666 
    args = getValidOrderCount_args()
2667 
    args.read(iprot)
2668 
    iprot.readMessageEnd()
2669 
    result = getValidOrderCount_result()
2670 
    result.success = self._handler.getValidOrderCount()
2671 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
2672 
    result.write(oprot)
2673 
    oprot.writeMessageEnd()
2674 
    oprot.trans.flush()
304 ashish 2675 
 
1627 ankur.sing 2676 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
2677 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2678 
    args.read(iprot)
2679 
    iprot.readMessageEnd()
2680 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2681 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
2682 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
2683 
    result.write(oprot)
2684 
    oprot.writeMessageEnd()
2685 
    oprot.trans.flush()
1596 ankur.sing 2686 
 
1731 ankur.sing 2687 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
2688 
    args = getValidOrdersAmountRange_args()
1627 ankur.sing 2689 
    args.read(iprot)
2690 
    iprot.readMessageEnd()
1731 ankur.sing 2691 
    result = getValidOrdersAmountRange_result()
2692 
    result.success = self._handler.getValidOrdersAmountRange()
2693 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
1627 ankur.sing 2694 
    result.write(oprot)
2695 
    oprot.writeMessageEnd()
2696 
    oprot.trans.flush()
2697 
 
1886 ankur.sing 2698 
  def process_getValidOrders(self, seqid, iprot, oprot):
2699 
    args = getValidOrders_args()
2700 
    args.read(iprot)
2701 
    iprot.readMessageEnd()
2702 
    result = getValidOrders_result()
2703 
    result.success = self._handler.getValidOrders(args.limit)
2704 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
2705 
    result.write(oprot)
2706 
    oprot.writeMessageEnd()
2707 
    oprot.trans.flush()
1627 ankur.sing 2708 
 
2536 chandransh 2709 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
2710 
    args = toggleDOAFlag_args()
2711 
    args.read(iprot)
2712 
    iprot.readMessageEnd()
2713 
    result = toggleDOAFlag_result()
2714 
    try:
2715 
      result.success = self._handler.toggleDOAFlag(args.orderId)
2716 
    except TransactionServiceException, ex:
2717 
      result.ex = ex
2718 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
2719 
    result.write(oprot)
2720 
    oprot.writeMessageEnd()
2721 
    oprot.trans.flush()
1886 ankur.sing 2722 
 
2536 chandransh 2723 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
2724 
    args = requestPickupNumber_args()
2725 
    args.read(iprot)
2726 
    iprot.readMessageEnd()
2727 
    result = requestPickupNumber_result()
2728 
    try:
2729 
      result.success = self._handler.requestPickupNumber(args.orderId)
2730 
    except TransactionServiceException, ex:
2731 
      result.ex = ex
2732 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
2733 
    result.write(oprot)
2734 
    oprot.writeMessageEnd()
2735 
    oprot.trans.flush()
2736 
 
2737 
  def process_authorizePickup(self, seqid, iprot, oprot):
2738 
    args = authorizePickup_args()
2739 
    args.read(iprot)
2740 
    iprot.readMessageEnd()
2741 
    result = authorizePickup_result()
2742 
    try:
2743 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber)
2744 
    except TransactionServiceException, ex:
2745 
      result.ex = ex
2746 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
2747 
    result.write(oprot)
2748 
    oprot.writeMessageEnd()
2749 
    oprot.trans.flush()
2750 
 
2616 chandransh 2751 
  def process_receiveReturn(self, seqid, iprot, oprot):
2752 
    args = receiveReturn_args()
2591 chandransh 2753 
    args.read(iprot)
2754 
    iprot.readMessageEnd()
2616 chandransh 2755 
    result = receiveReturn_result()
2591 chandransh 2756 
    try:
2616 chandransh 2757 
      result.success = self._handler.receiveReturn(args.orderId)
2591 chandransh 2758 
    except TransactionServiceException, ex:
2759 
      result.ex = ex
2616 chandransh 2760 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 2761 
    result.write(oprot)
2762 
    oprot.writeMessageEnd()
2763 
    oprot.trans.flush()
2536 chandransh 2764 
 
2591 chandransh 2765 
  def process_validateDoa(self, seqid, iprot, oprot):
2766 
    args = validateDoa_args()
2767 
    args.read(iprot)
2768 
    iprot.readMessageEnd()
2769 
    result = validateDoa_result()
2770 
    try:
2771 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
2772 
    except TransactionServiceException, ex:
2773 
      result.ex = ex
2774 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
2775 
    result.write(oprot)
2776 
    oprot.writeMessageEnd()
2777 
    oprot.trans.flush()
2778 
 
2616 chandransh 2779 
  def process_reshipOrder(self, seqid, iprot, oprot):
2780 
    args = reshipOrder_args()
2781 
    args.read(iprot)
2782 
    iprot.readMessageEnd()
2783 
    result = reshipOrder_result()
2784 
    try:
2785 
      result.success = self._handler.reshipOrder(args.orderId)
2786 
    except TransactionServiceException, ex:
2787 
      result.ex = ex
2788 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
2789 
    result.write(oprot)
2790 
    oprot.writeMessageEnd()
2791 
    oprot.trans.flush()
2591 chandransh 2792 
 
2616 chandransh 2793 
  def process_refundOrder(self, seqid, iprot, oprot):
2794 
    args = refundOrder_args()
2795 
    args.read(iprot)
2796 
    iprot.readMessageEnd()
2797 
    result = refundOrder_result()
2798 
    try:
2799 
      result.success = self._handler.refundOrder(args.orderId)
2800 
    except TransactionServiceException, ex:
2801 
      result.ex = ex
2802 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
2803 
    result.write(oprot)
2804 
    oprot.writeMessageEnd()
2805 
    oprot.trans.flush()
2806 
 
2690 chandransh 2807 
  def process_getReturnOrders(self, seqid, iprot, oprot):
2808 
    args = getReturnOrders_args()
2809 
    args.read(iprot)
2810 
    iprot.readMessageEnd()
2811 
    result = getReturnOrders_result()
2812 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
2813 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
2814 
    result.write(oprot)
2815 
    oprot.writeMessageEnd()
2816 
    oprot.trans.flush()
2616 chandransh 2817 
 
2700 chandransh 2818 
  def process_getReturnOrder(self, seqid, iprot, oprot):
2819 
    args = getReturnOrder_args()
2820 
    args.read(iprot)
2821 
    iprot.readMessageEnd()
2822 
    result = getReturnOrder_result()
2823 
    try:
2824 
      result.success = self._handler.getReturnOrder(args.id)
2825 
    except TransactionServiceException, ex:
2826 
      result.ex = ex
2827 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
2828 
    result.write(oprot)
2829 
    oprot.writeMessageEnd()
2830 
    oprot.trans.flush()
2831 
 
2690 chandransh 2832 
  def process_processReturn(self, seqid, iprot, oprot):
2833 
    args = processReturn_args()
2834 
    args.read(iprot)
2835 
    iprot.readMessageEnd()
2836 
    result = processReturn_result()
2837 
    try:
2838 
      self._handler.processReturn(args.returnOrderId)
2839 
    except TransactionServiceException, ex:
2840 
      result.ex = ex
2841 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
2842 
    result.write(oprot)
2843 
    oprot.writeMessageEnd()
2844 
    oprot.trans.flush()
2845 
 
2846 
 
94 ashish 2847 
# HELPER FUNCTIONS AND STRUCTURES
2848 
 
765 rajveer 2849 
class closeSession_args:
2850 
 
2851 
  thrift_spec = (
2852 
  )
2853 
 
2854 
  def read(self, iprot):
2855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2857 
      return
2858 
    iprot.readStructBegin()
2859 
    while True:
2860 
      (fname, ftype, fid) = iprot.readFieldBegin()
2861 
      if ftype == TType.STOP:
2862 
        break
2863 
      else:
2864 
        iprot.skip(ftype)
2865 
      iprot.readFieldEnd()
2866 
    iprot.readStructEnd()
2867 
 
2868 
  def write(self, oprot):
2869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2871 
      return
2872 
    oprot.writeStructBegin('closeSession_args')
2873 
    oprot.writeFieldStop()
2874 
    oprot.writeStructEnd()
2875 
 
2876 
  def __repr__(self):
2877 
    L = ['%s=%r' % (key, value)
2878 
      for key, value in self.__dict__.iteritems()]
2879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2880 
 
2881 
  def __eq__(self, other):
2882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2883 
 
2884 
  def __ne__(self, other):
2885 
    return not (self == other)
2886 
 
2887 
class closeSession_result:
2888 
 
2889 
  thrift_spec = (
2890 
  )
2891 
 
2892 
  def read(self, iprot):
2893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2895 
      return
2896 
    iprot.readStructBegin()
2897 
    while True:
2898 
      (fname, ftype, fid) = iprot.readFieldBegin()
2899 
      if ftype == TType.STOP:
2900 
        break
2901 
      else:
2902 
        iprot.skip(ftype)
2903 
      iprot.readFieldEnd()
2904 
    iprot.readStructEnd()
2905 
 
2906 
  def write(self, oprot):
2907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2909 
      return
2910 
    oprot.writeStructBegin('closeSession_result')
2911 
    oprot.writeFieldStop()
2912 
    oprot.writeStructEnd()
2913 
 
2914 
  def __repr__(self):
2915 
    L = ['%s=%r' % (key, value)
2916 
      for key, value in self.__dict__.iteritems()]
2917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2918 
 
2919 
  def __eq__(self, other):
2920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2921 
 
2922 
  def __ne__(self, other):
2923 
    return not (self == other)
2924 
 
94 ashish 2925 
class createTransaction_args:
2926 
  """
2927 
  Attributes:
2928 
   - transaction
2929 
  """
2930 
 
2931 
  thrift_spec = (
2932 
    None, # 0
2933 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
2934 
  )
2935 
 
2936 
  def __init__(self, transaction=None,):
2937 
    self.transaction = transaction
2938 
 
2939 
  def read(self, iprot):
2940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
2941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
2942 
      return
2943 
    iprot.readStructBegin()
2944 
    while True:
2945 
      (fname, ftype, fid) = iprot.readFieldBegin()
2946 
      if ftype == TType.STOP:
2947 
        break
2948 
      if fid == 1:
2949 
        if ftype == TType.STRUCT:
2950 
          self.transaction = Transaction()
2951 
          self.transaction.read(iprot)
2952 
        else:
2953 
          iprot.skip(ftype)
2954 
      else:
2955 
        iprot.skip(ftype)
2956 
      iprot.readFieldEnd()
2957 
    iprot.readStructEnd()
2958 
 
2959 
  def write(self, oprot):
2960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
2961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
2962 
      return
2963 
    oprot.writeStructBegin('createTransaction_args')
2964 
    if self.transaction != None:
2965 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
2966 
      self.transaction.write(oprot)
2967 
      oprot.writeFieldEnd()
2968 
    oprot.writeFieldStop()
2969 
    oprot.writeStructEnd()
2970 
 
2971 
  def __repr__(self):
2972 
    L = ['%s=%r' % (key, value)
2973 
      for key, value in self.__dict__.iteritems()]
2974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
2975 
 
2976 
  def __eq__(self, other):
2977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
2978 
 
2979 
  def __ne__(self, other):
2980 
    return not (self == other)
2981 
 
2982 
class createTransaction_result:
2983 
  """
2984 
  Attributes:
132 ashish 2985 
   - success
94 ashish 2986 
   - ex
2987 
  """
2988 
 
2989 
  thrift_spec = (
132 ashish 2990 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 2991 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
2992 
  )
2993 
 
132 ashish 2994 
  def __init__(self, success=None, ex=None,):
2995 
    self.success = success
94 ashish 2996 
    self.ex = ex
2997 
 
2998 
  def read(self, iprot):
2999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3001 
      return
3002 
    iprot.readStructBegin()
3003 
    while True:
3004 
      (fname, ftype, fid) = iprot.readFieldBegin()
3005 
      if ftype == TType.STOP:
3006 
        break
132 ashish 3007 
      if fid == 0:
3008 
        if ftype == TType.I64:
3009 
          self.success = iprot.readI64();
3010 
        else:
3011 
          iprot.skip(ftype)
3012 
      elif fid == 1:
94 ashish 3013 
        if ftype == TType.STRUCT:
3014 
          self.ex = TransactionServiceException()
3015 
          self.ex.read(iprot)
3016 
        else:
3017 
          iprot.skip(ftype)
3018 
      else:
3019 
        iprot.skip(ftype)
3020 
      iprot.readFieldEnd()
3021 
    iprot.readStructEnd()
3022 
 
3023 
  def write(self, oprot):
3024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3026 
      return
3027 
    oprot.writeStructBegin('createTransaction_result')
132 ashish 3028 
    if self.success != None:
3029 
      oprot.writeFieldBegin('success', TType.I64, 0)
3030 
      oprot.writeI64(self.success)
3031 
      oprot.writeFieldEnd()
94 ashish 3032 
    if self.ex != None:
3033 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3034 
      self.ex.write(oprot)
3035 
      oprot.writeFieldEnd()
3036 
    oprot.writeFieldStop()
3037 
    oprot.writeStructEnd()
3038 
 
3039 
  def __repr__(self):
3040 
    L = ['%s=%r' % (key, value)
3041 
      for key, value in self.__dict__.iteritems()]
3042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3043 
 
3044 
  def __eq__(self, other):
3045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3046 
 
3047 
  def __ne__(self, other):
3048 
    return not (self == other)
3049 
 
3050 
class getTransaction_args:
3051 
  """
3052 
  Attributes:
3053 
   - id
3054 
  """
3055 
 
3056 
  thrift_spec = (
3057 
    None, # 0
3058 
    (1, TType.I64, 'id', None, None, ), # 1
3059 
  )
3060 
 
3061 
  def __init__(self, id=None,):
3062 
    self.id = id
3063 
 
3064 
  def read(self, iprot):
3065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3067 
      return
3068 
    iprot.readStructBegin()
3069 
    while True:
3070 
      (fname, ftype, fid) = iprot.readFieldBegin()
3071 
      if ftype == TType.STOP:
3072 
        break
3073 
      if fid == 1:
3074 
        if ftype == TType.I64:
3075 
          self.id = iprot.readI64();
3076 
        else:
3077 
          iprot.skip(ftype)
3078 
      else:
3079 
        iprot.skip(ftype)
3080 
      iprot.readFieldEnd()
3081 
    iprot.readStructEnd()
3082 
 
3083 
  def write(self, oprot):
3084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3086 
      return
3087 
    oprot.writeStructBegin('getTransaction_args')
3088 
    if self.id != None:
3089 
      oprot.writeFieldBegin('id', TType.I64, 1)
3090 
      oprot.writeI64(self.id)
3091 
      oprot.writeFieldEnd()
3092 
    oprot.writeFieldStop()
3093 
    oprot.writeStructEnd()
3094 
 
3095 
  def __repr__(self):
3096 
    L = ['%s=%r' % (key, value)
3097 
      for key, value in self.__dict__.iteritems()]
3098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3099 
 
3100 
  def __eq__(self, other):
3101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3102 
 
3103 
  def __ne__(self, other):
3104 
    return not (self == other)
3105 
 
3106 
class getTransaction_result:
3107 
  """
3108 
  Attributes:
3109 
   - success
3110 
   - ex
3111 
  """
3112 
 
3113 
  thrift_spec = (
3114 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
3115 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3116 
  )
3117 
 
3118 
  def __init__(self, success=None, ex=None,):
3119 
    self.success = success
3120 
    self.ex = ex
3121 
 
3122 
  def read(self, iprot):
3123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3125 
      return
3126 
    iprot.readStructBegin()
3127 
    while True:
3128 
      (fname, ftype, fid) = iprot.readFieldBegin()
3129 
      if ftype == TType.STOP:
3130 
        break
3131 
      if fid == 0:
3132 
        if ftype == TType.STRUCT:
3133 
          self.success = Transaction()
3134 
          self.success.read(iprot)
3135 
        else:
3136 
          iprot.skip(ftype)
3137 
      elif fid == 1:
3138 
        if ftype == TType.STRUCT:
3139 
          self.ex = TransactionServiceException()
3140 
          self.ex.read(iprot)
3141 
        else:
3142 
          iprot.skip(ftype)
3143 
      else:
3144 
        iprot.skip(ftype)
3145 
      iprot.readFieldEnd()
3146 
    iprot.readStructEnd()
3147 
 
3148 
  def write(self, oprot):
3149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3151 
      return
3152 
    oprot.writeStructBegin('getTransaction_result')
3153 
    if self.success != None:
3154 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3155 
      self.success.write(oprot)
3156 
      oprot.writeFieldEnd()
3157 
    if self.ex != None:
3158 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3159 
      self.ex.write(oprot)
3160 
      oprot.writeFieldEnd()
3161 
    oprot.writeFieldStop()
3162 
    oprot.writeStructEnd()
3163 
 
3164 
  def __repr__(self):
3165 
    L = ['%s=%r' % (key, value)
3166 
      for key, value in self.__dict__.iteritems()]
3167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3168 
 
3169 
  def __eq__(self, other):
3170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3171 
 
3172 
  def __ne__(self, other):
3173 
    return not (self == other)
3174 
 
3175 
class getTransactionsForCustomer_args:
3176 
  """
3177 
  Attributes:
3178 
   - customerId
3179 
   - from_date
3180 
   - to_date
3181 
   - status
3182 
  """
3183 
 
3184 
  thrift_spec = (
3185 
    None, # 0
3186 
    (1, TType.I64, 'customerId', None, None, ), # 1
3187 
    (2, TType.I64, 'from_date', None, None, ), # 2
3188 
    (3, TType.I64, 'to_date', None, None, ), # 3
3189 
    (4, TType.I32, 'status', None, None, ), # 4
3190 
  )
3191 
 
3192 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
3193 
    self.customerId = customerId
3194 
    self.from_date = from_date
3195 
    self.to_date = to_date
3196 
    self.status = status
3197 
 
3198 
  def read(self, iprot):
3199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3201 
      return
3202 
    iprot.readStructBegin()
3203 
    while True:
3204 
      (fname, ftype, fid) = iprot.readFieldBegin()
3205 
      if ftype == TType.STOP:
3206 
        break
3207 
      if fid == 1:
3208 
        if ftype == TType.I64:
3209 
          self.customerId = iprot.readI64();
3210 
        else:
3211 
          iprot.skip(ftype)
3212 
      elif fid == 2:
3213 
        if ftype == TType.I64:
3214 
          self.from_date = iprot.readI64();
3215 
        else:
3216 
          iprot.skip(ftype)
3217 
      elif fid == 3:
3218 
        if ftype == TType.I64:
3219 
          self.to_date = iprot.readI64();
3220 
        else:
3221 
          iprot.skip(ftype)
3222 
      elif fid == 4:
3223 
        if ftype == TType.I32:
3224 
          self.status = iprot.readI32();
3225 
        else:
3226 
          iprot.skip(ftype)
3227 
      else:
3228 
        iprot.skip(ftype)
3229 
      iprot.readFieldEnd()
3230 
    iprot.readStructEnd()
3231 
 
3232 
  def write(self, oprot):
3233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3235 
      return
3236 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3237 
    if self.customerId != None:
3238 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
3239 
      oprot.writeI64(self.customerId)
3240 
      oprot.writeFieldEnd()
3241 
    if self.from_date != None:
3242 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3243 
      oprot.writeI64(self.from_date)
3244 
      oprot.writeFieldEnd()
3245 
    if self.to_date != None:
3246 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3247 
      oprot.writeI64(self.to_date)
3248 
      oprot.writeFieldEnd()
3249 
    if self.status != None:
3250 
      oprot.writeFieldBegin('status', TType.I32, 4)
3251 
      oprot.writeI32(self.status)
3252 
      oprot.writeFieldEnd()
3253 
    oprot.writeFieldStop()
3254 
    oprot.writeStructEnd()
3255 
 
3256 
  def __repr__(self):
3257 
    L = ['%s=%r' % (key, value)
3258 
      for key, value in self.__dict__.iteritems()]
3259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3260 
 
3261 
  def __eq__(self, other):
3262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3263 
 
3264 
  def __ne__(self, other):
3265 
    return not (self == other)
3266 
 
3267 
class getTransactionsForCustomer_result:
3268 
  """
3269 
  Attributes:
3270 
   - success
3271 
   - ex
3272 
  """
3273 
 
3274 
  thrift_spec = (
3275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3277 
  )
3278 
 
3279 
  def __init__(self, success=None, ex=None,):
3280 
    self.success = success
3281 
    self.ex = ex
3282 
 
3283 
  def read(self, iprot):
3284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3286 
      return
3287 
    iprot.readStructBegin()
3288 
    while True:
3289 
      (fname, ftype, fid) = iprot.readFieldBegin()
3290 
      if ftype == TType.STOP:
3291 
        break
3292 
      if fid == 0:
3293 
        if ftype == TType.LIST:
3294 
          self.success = []
685 chandransh 3295 
          (_etype17, _size14) = iprot.readListBegin()
3296 
          for _i18 in xrange(_size14):
3297 
            _elem19 = Transaction()
3298 
            _elem19.read(iprot)
3299 
            self.success.append(_elem19)
94 ashish 3300 
          iprot.readListEnd()
3301 
        else:
3302 
          iprot.skip(ftype)
3303 
      elif fid == 1:
3304 
        if ftype == TType.STRUCT:
3305 
          self.ex = TransactionServiceException()
3306 
          self.ex.read(iprot)
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
3318 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3319 
    if self.success != None:
3320 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3321 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3322 
      for iter20 in self.success:
3323 
        iter20.write(oprot)
94 ashish 3324 
      oprot.writeListEnd()
3325 
      oprot.writeFieldEnd()
3326 
    if self.ex != None:
3327 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3328 
      self.ex.write(oprot)
3329 
      oprot.writeFieldEnd()
3330 
    oprot.writeFieldStop()
3331 
    oprot.writeStructEnd()
3332 
 
3333 
  def __repr__(self):
3334 
    L = ['%s=%r' % (key, value)
3335 
      for key, value in self.__dict__.iteritems()]
3336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3337 
 
3338 
  def __eq__(self, other):
3339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3340 
 
3341 
  def __ne__(self, other):
3342 
    return not (self == other)
3343 
 
132 ashish 3344 
class getTransactionsForShoppingCartId_args:
3345 
  """
3346 
  Attributes:
3347 
   - shoppingCartId
3348 
  """
3349 
 
3350 
  thrift_spec = (
3351 
    None, # 0
3352 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
3353 
  )
3354 
 
3355 
  def __init__(self, shoppingCartId=None,):
3356 
    self.shoppingCartId = shoppingCartId
3357 
 
3358 
  def read(self, iprot):
3359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3361 
      return
3362 
    iprot.readStructBegin()
3363 
    while True:
3364 
      (fname, ftype, fid) = iprot.readFieldBegin()
3365 
      if ftype == TType.STOP:
3366 
        break
3367 
      if fid == 1:
3368 
        if ftype == TType.I64:
3369 
          self.shoppingCartId = iprot.readI64();
3370 
        else:
3371 
          iprot.skip(ftype)
3372 
      else:
3373 
        iprot.skip(ftype)
3374 
      iprot.readFieldEnd()
3375 
    iprot.readStructEnd()
3376 
 
3377 
  def write(self, oprot):
3378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3380 
      return
3381 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3382 
    if self.shoppingCartId != None:
3383 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
3384 
      oprot.writeI64(self.shoppingCartId)
3385 
      oprot.writeFieldEnd()
3386 
    oprot.writeFieldStop()
3387 
    oprot.writeStructEnd()
3388 
 
3389 
  def __repr__(self):
3390 
    L = ['%s=%r' % (key, value)
3391 
      for key, value in self.__dict__.iteritems()]
3392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3393 
 
3394 
  def __eq__(self, other):
3395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3396 
 
3397 
  def __ne__(self, other):
3398 
    return not (self == other)
3399 
 
3400 
class getTransactionsForShoppingCartId_result:
3401 
  """
3402 
  Attributes:
3403 
   - success
3404 
   - ex
3405 
  """
3406 
 
3407 
  thrift_spec = (
3408 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
3409 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3410 
  )
3411 
 
3412 
  def __init__(self, success=None, ex=None,):
3413 
    self.success = success
3414 
    self.ex = ex
3415 
 
3416 
  def read(self, iprot):
3417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3419 
      return
3420 
    iprot.readStructBegin()
3421 
    while True:
3422 
      (fname, ftype, fid) = iprot.readFieldBegin()
3423 
      if ftype == TType.STOP:
3424 
        break
3425 
      if fid == 0:
3426 
        if ftype == TType.LIST:
3427 
          self.success = []
685 chandransh 3428 
          (_etype24, _size21) = iprot.readListBegin()
3429 
          for _i25 in xrange(_size21):
3430 
            _elem26 = Transaction()
3431 
            _elem26.read(iprot)
3432 
            self.success.append(_elem26)
132 ashish 3433 
          iprot.readListEnd()
3434 
        else:
3435 
          iprot.skip(ftype)
3436 
      elif fid == 1:
3437 
        if ftype == TType.STRUCT:
3438 
          self.ex = TransactionServiceException()
3439 
          self.ex.read(iprot)
3440 
        else:
3441 
          iprot.skip(ftype)
3442 
      else:
3443 
        iprot.skip(ftype)
3444 
      iprot.readFieldEnd()
3445 
    iprot.readStructEnd()
3446 
 
3447 
  def write(self, oprot):
3448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3450 
      return
3451 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3452 
    if self.success != None:
3453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 3455 
      for iter27 in self.success:
3456 
        iter27.write(oprot)
132 ashish 3457 
      oprot.writeListEnd()
3458 
      oprot.writeFieldEnd()
3459 
    if self.ex != None:
3460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3461 
      self.ex.write(oprot)
3462 
      oprot.writeFieldEnd()
3463 
    oprot.writeFieldStop()
3464 
    oprot.writeStructEnd()
3465 
 
3466 
  def __repr__(self):
3467 
    L = ['%s=%r' % (key, value)
3468 
      for key, value in self.__dict__.iteritems()]
3469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3470 
 
3471 
  def __eq__(self, other):
3472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3473 
 
3474 
  def __ne__(self, other):
3475 
    return not (self == other)
3476 
 
94 ashish 3477 
class getTransactionStatus_args:
3478 
  """
3479 
  Attributes:
3480 
   - transactionId
3481 
  """
3482 
 
3483 
  thrift_spec = (
3484 
    None, # 0
3485 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3486 
  )
3487 
 
3488 
  def __init__(self, transactionId=None,):
3489 
    self.transactionId = transactionId
3490 
 
3491 
  def read(self, iprot):
3492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3494 
      return
3495 
    iprot.readStructBegin()
3496 
    while True:
3497 
      (fname, ftype, fid) = iprot.readFieldBegin()
3498 
      if ftype == TType.STOP:
3499 
        break
3500 
      if fid == 1:
3501 
        if ftype == TType.I64:
3502 
          self.transactionId = iprot.readI64();
3503 
        else:
3504 
          iprot.skip(ftype)
3505 
      else:
3506 
        iprot.skip(ftype)
3507 
      iprot.readFieldEnd()
3508 
    iprot.readStructEnd()
3509 
 
3510 
  def write(self, oprot):
3511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3513 
      return
3514 
    oprot.writeStructBegin('getTransactionStatus_args')
3515 
    if self.transactionId != None:
3516 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3517 
      oprot.writeI64(self.transactionId)
3518 
      oprot.writeFieldEnd()
3519 
    oprot.writeFieldStop()
3520 
    oprot.writeStructEnd()
3521 
 
3522 
  def __repr__(self):
3523 
    L = ['%s=%r' % (key, value)
3524 
      for key, value in self.__dict__.iteritems()]
3525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3526 
 
3527 
  def __eq__(self, other):
3528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3529 
 
3530 
  def __ne__(self, other):
3531 
    return not (self == other)
3532 
 
3533 
class getTransactionStatus_result:
3534 
  """
3535 
  Attributes:
3536 
   - success
3537 
   - ex
3538 
  """
3539 
 
3540 
  thrift_spec = (
3541 
    (0, TType.I32, 'success', None, None, ), # 0
3542 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3543 
  )
3544 
 
3545 
  def __init__(self, success=None, ex=None,):
3546 
    self.success = success
3547 
    self.ex = ex
3548 
 
3549 
  def read(self, iprot):
3550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3552 
      return
3553 
    iprot.readStructBegin()
3554 
    while True:
3555 
      (fname, ftype, fid) = iprot.readFieldBegin()
3556 
      if ftype == TType.STOP:
3557 
        break
3558 
      if fid == 0:
3559 
        if ftype == TType.I32:
3560 
          self.success = iprot.readI32();
3561 
        else:
3562 
          iprot.skip(ftype)
3563 
      elif fid == 1:
3564 
        if ftype == TType.STRUCT:
3565 
          self.ex = TransactionServiceException()
3566 
          self.ex.read(iprot)
3567 
        else:
3568 
          iprot.skip(ftype)
3569 
      else:
3570 
        iprot.skip(ftype)
3571 
      iprot.readFieldEnd()
3572 
    iprot.readStructEnd()
3573 
 
3574 
  def write(self, oprot):
3575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3577 
      return
3578 
    oprot.writeStructBegin('getTransactionStatus_result')
3579 
    if self.success != None:
3580 
      oprot.writeFieldBegin('success', TType.I32, 0)
3581 
      oprot.writeI32(self.success)
3582 
      oprot.writeFieldEnd()
3583 
    if self.ex != None:
3584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3585 
      self.ex.write(oprot)
3586 
      oprot.writeFieldEnd()
3587 
    oprot.writeFieldStop()
3588 
    oprot.writeStructEnd()
3589 
 
3590 
  def __repr__(self):
3591 
    L = ['%s=%r' % (key, value)
3592 
      for key, value in self.__dict__.iteritems()]
3593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3594 
 
3595 
  def __eq__(self, other):
3596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3597 
 
3598 
  def __ne__(self, other):
3599 
    return not (self == other)
3600 
 
3601 
class changeTransactionStatus_args:
3602 
  """
3603 
  Attributes:
3604 
   - transactionId
3605 
   - status
3606 
   - description
3607 
  """
3608 
 
3609 
  thrift_spec = (
3610 
    None, # 0
3611 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3612 
    (2, TType.I32, 'status', None, None, ), # 2
3613 
    (3, TType.STRING, 'description', None, None, ), # 3
3614 
  )
3615 
 
3616 
  def __init__(self, transactionId=None, status=None, description=None,):
3617 
    self.transactionId = transactionId
3618 
    self.status = status
3619 
    self.description = description
3620 
 
3621 
  def read(self, iprot):
3622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3624 
      return
3625 
    iprot.readStructBegin()
3626 
    while True:
3627 
      (fname, ftype, fid) = iprot.readFieldBegin()
3628 
      if ftype == TType.STOP:
3629 
        break
3630 
      if fid == 1:
3631 
        if ftype == TType.I64:
3632 
          self.transactionId = iprot.readI64();
3633 
        else:
3634 
          iprot.skip(ftype)
3635 
      elif fid == 2:
3636 
        if ftype == TType.I32:
3637 
          self.status = iprot.readI32();
3638 
        else:
3639 
          iprot.skip(ftype)
3640 
      elif fid == 3:
3641 
        if ftype == TType.STRING:
3642 
          self.description = iprot.readString();
3643 
        else:
3644 
          iprot.skip(ftype)
3645 
      else:
3646 
        iprot.skip(ftype)
3647 
      iprot.readFieldEnd()
3648 
    iprot.readStructEnd()
3649 
 
3650 
  def write(self, oprot):
3651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3653 
      return
3654 
    oprot.writeStructBegin('changeTransactionStatus_args')
3655 
    if self.transactionId != None:
3656 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3657 
      oprot.writeI64(self.transactionId)
3658 
      oprot.writeFieldEnd()
3659 
    if self.status != None:
3660 
      oprot.writeFieldBegin('status', TType.I32, 2)
3661 
      oprot.writeI32(self.status)
3662 
      oprot.writeFieldEnd()
3663 
    if self.description != None:
3664 
      oprot.writeFieldBegin('description', TType.STRING, 3)
3665 
      oprot.writeString(self.description)
3666 
      oprot.writeFieldEnd()
3667 
    oprot.writeFieldStop()
3668 
    oprot.writeStructEnd()
3669 
 
3670 
  def __repr__(self):
3671 
    L = ['%s=%r' % (key, value)
3672 
      for key, value in self.__dict__.iteritems()]
3673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3674 
 
3675 
  def __eq__(self, other):
3676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3677 
 
3678 
  def __ne__(self, other):
3679 
    return not (self == other)
3680 
 
3681 
class changeTransactionStatus_result:
3682 
  """
3683 
  Attributes:
3684 
   - success
3685 
   - ex
3686 
  """
3687 
 
3688 
  thrift_spec = (
3689 
    (0, TType.BOOL, 'success', None, None, ), # 0
3690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3691 
  )
3692 
 
3693 
  def __init__(self, success=None, ex=None,):
3694 
    self.success = success
3695 
    self.ex = ex
3696 
 
3697 
  def read(self, iprot):
3698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3700 
      return
3701 
    iprot.readStructBegin()
3702 
    while True:
3703 
      (fname, ftype, fid) = iprot.readFieldBegin()
3704 
      if ftype == TType.STOP:
3705 
        break
3706 
      if fid == 0:
3707 
        if ftype == TType.BOOL:
3708 
          self.success = iprot.readBool();
3709 
        else:
3710 
          iprot.skip(ftype)
3711 
      elif fid == 1:
3712 
        if ftype == TType.STRUCT:
3713 
          self.ex = TransactionServiceException()
3714 
          self.ex.read(iprot)
3715 
        else:
3716 
          iprot.skip(ftype)
3717 
      else:
3718 
        iprot.skip(ftype)
3719 
      iprot.readFieldEnd()
3720 
    iprot.readStructEnd()
3721 
 
3722 
  def write(self, oprot):
3723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3725 
      return
3726 
    oprot.writeStructBegin('changeTransactionStatus_result')
3727 
    if self.success != None:
3728 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3729 
      oprot.writeBool(self.success)
3730 
      oprot.writeFieldEnd()
3731 
    if self.ex != None:
3732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3733 
      self.ex.write(oprot)
3734 
      oprot.writeFieldEnd()
3735 
    oprot.writeFieldStop()
3736 
    oprot.writeStructEnd()
3737 
 
3738 
  def __repr__(self):
3739 
    L = ['%s=%r' % (key, value)
3740 
      for key, value in self.__dict__.iteritems()]
3741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3742 
 
3743 
  def __eq__(self, other):
3744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3745 
 
3746 
  def __ne__(self, other):
3747 
    return not (self == other)
3748 
 
1398 varun.gupt 3749 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 3750 
  """
3751 
  Attributes:
3752 
   - transactionId
3753 
  """
3754 
 
3755 
  thrift_spec = (
3756 
    None, # 0
3757 
    (1, TType.I64, 'transactionId', None, None, ), # 1
3758 
  )
3759 
 
3760 
  def __init__(self, transactionId=None,):
3761 
    self.transactionId = transactionId
3762 
 
3763 
  def read(self, iprot):
3764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3766 
      return
3767 
    iprot.readStructBegin()
3768 
    while True:
3769 
      (fname, ftype, fid) = iprot.readFieldBegin()
3770 
      if ftype == TType.STOP:
3771 
        break
3772 
      if fid == 1:
3773 
        if ftype == TType.I64:
3774 
          self.transactionId = iprot.readI64();
3775 
        else:
3776 
          iprot.skip(ftype)
3777 
      else:
3778 
        iprot.skip(ftype)
3779 
      iprot.readFieldEnd()
3780 
    iprot.readStructEnd()
3781 
 
3782 
  def write(self, oprot):
3783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3785 
      return
1398 varun.gupt 3786 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
1382 varun.gupt 3787 
    if self.transactionId != None:
3788 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
3789 
      oprot.writeI64(self.transactionId)
3790 
      oprot.writeFieldEnd()
3791 
    oprot.writeFieldStop()
3792 
    oprot.writeStructEnd()
3793 
 
3794 
  def __repr__(self):
3795 
    L = ['%s=%r' % (key, value)
3796 
      for key, value in self.__dict__.iteritems()]
3797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3798 
 
3799 
  def __eq__(self, other):
3800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3801 
 
3802 
  def __ne__(self, other):
3803 
    return not (self == other)
3804 
 
1398 varun.gupt 3805 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 3806 
  """
3807 
  Attributes:
3808 
   - success
3809 
   - ex
3810 
  """
3811 
 
3812 
  thrift_spec = (
3813 
    (0, TType.BOOL, 'success', None, None, ), # 0
3814 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3815 
  )
3816 
 
3817 
  def __init__(self, success=None, ex=None,):
3818 
    self.success = success
3819 
    self.ex = ex
3820 
 
3821 
  def read(self, iprot):
3822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3824 
      return
3825 
    iprot.readStructBegin()
3826 
    while True:
3827 
      (fname, ftype, fid) = iprot.readFieldBegin()
3828 
      if ftype == TType.STOP:
3829 
        break
3830 
      if fid == 0:
3831 
        if ftype == TType.BOOL:
3832 
          self.success = iprot.readBool();
3833 
        else:
3834 
          iprot.skip(ftype)
3835 
      elif fid == 1:
3836 
        if ftype == TType.STRUCT:
3837 
          self.ex = TransactionServiceException()
3838 
          self.ex.read(iprot)
3839 
        else:
3840 
          iprot.skip(ftype)
3841 
      else:
3842 
        iprot.skip(ftype)
3843 
      iprot.readFieldEnd()
3844 
    iprot.readStructEnd()
3845 
 
3846 
  def write(self, oprot):
3847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3849 
      return
1398 varun.gupt 3850 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
1382 varun.gupt 3851 
    if self.success != None:
3852 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
3853 
      oprot.writeBool(self.success)
3854 
      oprot.writeFieldEnd()
3855 
    if self.ex != None:
3856 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
3857 
      self.ex.write(oprot)
3858 
      oprot.writeFieldEnd()
3859 
    oprot.writeFieldStop()
3860 
    oprot.writeStructEnd()
3861 
 
3862 
  def __repr__(self):
3863 
    L = ['%s=%r' % (key, value)
3864 
      for key, value in self.__dict__.iteritems()]
3865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3866 
 
3867 
  def __eq__(self, other):
3868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3869 
 
3870 
  def __ne__(self, other):
3871 
    return not (self == other)
3872 
 
483 rajveer 3873 
class getAllOrders_args:
94 ashish 3874 
  """
3875 
  Attributes:
483 rajveer 3876 
   - status
3877 
   - from_date
3878 
   - to_date
3879 
   - warehouse_id
94 ashish 3880 
  """
3881 
 
3882 
  thrift_spec = (
3883 
    None, # 0
483 rajveer 3884 
    (1, TType.I32, 'status', None, None, ), # 1
3885 
    (2, TType.I64, 'from_date', None, None, ), # 2
3886 
    (3, TType.I64, 'to_date', None, None, ), # 3
3887 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 3888 
  )
3889 
 
483 rajveer 3890 
  def __init__(self, status=None, from_date=None, to_date=None, warehouse_id=None,):
3891 
    self.status = status
3892 
    self.from_date = from_date
3893 
    self.to_date = to_date
3894 
    self.warehouse_id = warehouse_id
94 ashish 3895 
 
3896 
  def read(self, iprot):
3897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3899 
      return
3900 
    iprot.readStructBegin()
3901 
    while True:
3902 
      (fname, ftype, fid) = iprot.readFieldBegin()
3903 
      if ftype == TType.STOP:
3904 
        break
3905 
      if fid == 1:
483 rajveer 3906 
        if ftype == TType.I32:
3907 
          self.status = iprot.readI32();
94 ashish 3908 
        else:
3909 
          iprot.skip(ftype)
483 rajveer 3910 
      elif fid == 2:
3911 
        if ftype == TType.I64:
3912 
          self.from_date = iprot.readI64();
94 ashish 3913 
        else:
3914 
          iprot.skip(ftype)
483 rajveer 3915 
      elif fid == 3:
3916 
        if ftype == TType.I64:
3917 
          self.to_date = iprot.readI64();
94 ashish 3918 
        else:
3919 
          iprot.skip(ftype)
483 rajveer 3920 
      elif fid == 4:
94 ashish 3921 
        if ftype == TType.I64:
483 rajveer 3922 
          self.warehouse_id = iprot.readI64();
94 ashish 3923 
        else:
3924 
          iprot.skip(ftype)
3925 
      else:
3926 
        iprot.skip(ftype)
3927 
      iprot.readFieldEnd()
3928 
    iprot.readStructEnd()
3929 
 
3930 
  def write(self, oprot):
3931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3933 
      return
483 rajveer 3934 
    oprot.writeStructBegin('getAllOrders_args')
3935 
    if self.status != None:
3936 
      oprot.writeFieldBegin('status', TType.I32, 1)
3937 
      oprot.writeI32(self.status)
94 ashish 3938 
      oprot.writeFieldEnd()
483 rajveer 3939 
    if self.from_date != None:
3940 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
3941 
      oprot.writeI64(self.from_date)
94 ashish 3942 
      oprot.writeFieldEnd()
483 rajveer 3943 
    if self.to_date != None:
3944 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
3945 
      oprot.writeI64(self.to_date)
94 ashish 3946 
      oprot.writeFieldEnd()
483 rajveer 3947 
    if self.warehouse_id != None:
3948 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
3949 
      oprot.writeI64(self.warehouse_id)
94 ashish 3950 
      oprot.writeFieldEnd()
3951 
    oprot.writeFieldStop()
3952 
    oprot.writeStructEnd()
3953 
 
3954 
  def __repr__(self):
3955 
    L = ['%s=%r' % (key, value)
3956 
      for key, value in self.__dict__.iteritems()]
3957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3958 
 
3959 
  def __eq__(self, other):
3960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3961 
 
3962 
  def __ne__(self, other):
3963 
    return not (self == other)
3964 
 
483 rajveer 3965 
class getAllOrders_result:
94 ashish 3966 
  """
3967 
  Attributes:
3968 
   - success
3969 
   - ex
3970 
  """
3971 
 
3972 
  thrift_spec = (
483 rajveer 3973 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 3974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
3975 
  )
3976 
 
3977 
  def __init__(self, success=None, ex=None,):
3978 
    self.success = success
3979 
    self.ex = ex
3980 
 
3981 
  def read(self, iprot):
3982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3984 
      return
3985 
    iprot.readStructBegin()
3986 
    while True:
3987 
      (fname, ftype, fid) = iprot.readFieldBegin()
3988 
      if ftype == TType.STOP:
3989 
        break
3990 
      if fid == 0:
483 rajveer 3991 
        if ftype == TType.LIST:
3992 
          self.success = []
685 chandransh 3993 
          (_etype31, _size28) = iprot.readListBegin()
3994 
          for _i32 in xrange(_size28):
3995 
            _elem33 = Order()
3996 
            _elem33.read(iprot)
3997 
            self.success.append(_elem33)
483 rajveer 3998 
          iprot.readListEnd()
94 ashish 3999 
        else:
4000 
          iprot.skip(ftype)
4001 
      elif fid == 1:
4002 
        if ftype == TType.STRUCT:
4003 
          self.ex = TransactionServiceException()
4004 
          self.ex.read(iprot)
4005 
        else:
4006 
          iprot.skip(ftype)
4007 
      else:
4008 
        iprot.skip(ftype)
4009 
      iprot.readFieldEnd()
4010 
    iprot.readStructEnd()
4011 
 
4012 
  def write(self, oprot):
4013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4015 
      return
483 rajveer 4016 
    oprot.writeStructBegin('getAllOrders_result')
94 ashish 4017 
    if self.success != None:
483 rajveer 4018 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4019 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
685 chandransh 4020 
      for iter34 in self.success:
4021 
        iter34.write(oprot)
483 rajveer 4022 
      oprot.writeListEnd()
94 ashish 4023 
      oprot.writeFieldEnd()
4024 
    if self.ex != None:
4025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4026 
      self.ex.write(oprot)
4027 
      oprot.writeFieldEnd()
4028 
    oprot.writeFieldStop()
4029 
    oprot.writeStructEnd()
4030 
 
4031 
  def __repr__(self):
4032 
    L = ['%s=%r' % (key, value)
4033 
      for key, value in self.__dict__.iteritems()]
4034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4035 
 
4036 
  def __eq__(self, other):
4037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4038 
 
4039 
  def __ne__(self, other):
4040 
    return not (self == other)
4041 
 
999 varun.gupt 4042 
class getOrdersByBillingDate_args:
4043 
  """
4044 
  Attributes:
4045 
   - status
4046 
   - start_billing_date
4047 
   - end_billing_date
4048 
   - warehouse_id
4049 
  """
4050 
 
4051 
  thrift_spec = (
4052 
    None, # 0
4053 
    (1, TType.I32, 'status', None, None, ), # 1
4054 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
4055 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
4056 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
4057 
  )
4058 
 
4059 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
4060 
    self.status = status
4061 
    self.start_billing_date = start_billing_date
4062 
    self.end_billing_date = end_billing_date
4063 
    self.warehouse_id = warehouse_id
4064 
 
4065 
  def read(self, iprot):
4066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4068 
      return
4069 
    iprot.readStructBegin()
4070 
    while True:
4071 
      (fname, ftype, fid) = iprot.readFieldBegin()
4072 
      if ftype == TType.STOP:
4073 
        break
4074 
      if fid == 1:
4075 
        if ftype == TType.I32:
4076 
          self.status = iprot.readI32();
4077 
        else:
4078 
          iprot.skip(ftype)
4079 
      elif fid == 2:
4080 
        if ftype == TType.I64:
4081 
          self.start_billing_date = iprot.readI64();
4082 
        else:
4083 
          iprot.skip(ftype)
4084 
      elif fid == 3:
4085 
        if ftype == TType.I64:
4086 
          self.end_billing_date = iprot.readI64();
4087 
        else:
4088 
          iprot.skip(ftype)
4089 
      elif fid == 4:
4090 
        if ftype == TType.I64:
4091 
          self.warehouse_id = iprot.readI64();
4092 
        else:
4093 
          iprot.skip(ftype)
4094 
      else:
4095 
        iprot.skip(ftype)
4096 
      iprot.readFieldEnd()
4097 
    iprot.readStructEnd()
4098 
 
4099 
  def write(self, oprot):
4100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4102 
      return
4103 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
4104 
    if self.status != None:
4105 
      oprot.writeFieldBegin('status', TType.I32, 1)
4106 
      oprot.writeI32(self.status)
4107 
      oprot.writeFieldEnd()
4108 
    if self.start_billing_date != None:
4109 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
4110 
      oprot.writeI64(self.start_billing_date)
4111 
      oprot.writeFieldEnd()
4112 
    if self.end_billing_date != None:
4113 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
4114 
      oprot.writeI64(self.end_billing_date)
4115 
      oprot.writeFieldEnd()
4116 
    if self.warehouse_id != None:
4117 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
4118 
      oprot.writeI64(self.warehouse_id)
4119 
      oprot.writeFieldEnd()
4120 
    oprot.writeFieldStop()
4121 
    oprot.writeStructEnd()
4122 
 
4123 
  def __repr__(self):
4124 
    L = ['%s=%r' % (key, value)
4125 
      for key, value in self.__dict__.iteritems()]
4126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4127 
 
4128 
  def __eq__(self, other):
4129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4130 
 
4131 
  def __ne__(self, other):
4132 
    return not (self == other)
4133 
 
4134 
class getOrdersByBillingDate_result:
4135 
  """
4136 
  Attributes:
4137 
   - success
4138 
   - ex
4139 
  """
4140 
 
4141 
  thrift_spec = (
4142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
4143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4144 
  )
4145 
 
4146 
  def __init__(self, success=None, ex=None,):
4147 
    self.success = success
4148 
    self.ex = ex
4149 
 
4150 
  def read(self, iprot):
4151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4153 
      return
4154 
    iprot.readStructBegin()
4155 
    while True:
4156 
      (fname, ftype, fid) = iprot.readFieldBegin()
4157 
      if ftype == TType.STOP:
4158 
        break
4159 
      if fid == 0:
4160 
        if ftype == TType.LIST:
4161 
          self.success = []
4162 
          (_etype38, _size35) = iprot.readListBegin()
4163 
          for _i39 in xrange(_size35):
4164 
            _elem40 = Order()
4165 
            _elem40.read(iprot)
4166 
            self.success.append(_elem40)
4167 
          iprot.readListEnd()
4168 
        else:
4169 
          iprot.skip(ftype)
4170 
      elif fid == 1:
4171 
        if ftype == TType.STRUCT:
4172 
          self.ex = TransactionServiceException()
4173 
          self.ex.read(iprot)
4174 
        else:
4175 
          iprot.skip(ftype)
4176 
      else:
4177 
        iprot.skip(ftype)
4178 
      iprot.readFieldEnd()
4179 
    iprot.readStructEnd()
4180 
 
4181 
  def write(self, oprot):
4182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4184 
      return
4185 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
4186 
    if self.success != None:
4187 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4188 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
4189 
      for iter41 in self.success:
4190 
        iter41.write(oprot)
4191 
      oprot.writeListEnd()
4192 
      oprot.writeFieldEnd()
4193 
    if self.ex != None:
4194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4195 
      self.ex.write(oprot)
4196 
      oprot.writeFieldEnd()
4197 
    oprot.writeFieldStop()
4198 
    oprot.writeStructEnd()
4199 
 
4200 
  def __repr__(self):
4201 
    L = ['%s=%r' % (key, value)
4202 
      for key, value in self.__dict__.iteritems()]
4203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4204 
 
4205 
  def __eq__(self, other):
4206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4207 
 
4208 
  def __ne__(self, other):
4209 
    return not (self == other)
4210 
 
1382 varun.gupt 4211 
class getReturnableOrdersForCustomer_args:
4212 
  """
4213 
  Attributes:
4214 
   - customer_id
4215 
   - limit
4216 
  """
4217 
 
4218 
  thrift_spec = (
4219 
    None, # 0
4220 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4221 
    (2, TType.I64, 'limit', None, None, ), # 2
4222 
  )
4223 
 
4224 
  def __init__(self, customer_id=None, limit=None,):
4225 
    self.customer_id = customer_id
4226 
    self.limit = limit
4227 
 
4228 
  def read(self, iprot):
4229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4231 
      return
4232 
    iprot.readStructBegin()
4233 
    while True:
4234 
      (fname, ftype, fid) = iprot.readFieldBegin()
4235 
      if ftype == TType.STOP:
4236 
        break
4237 
      if fid == 1:
4238 
        if ftype == TType.I64:
4239 
          self.customer_id = iprot.readI64();
4240 
        else:
4241 
          iprot.skip(ftype)
4242 
      elif fid == 2:
4243 
        if ftype == TType.I64:
4244 
          self.limit = iprot.readI64();
4245 
        else:
4246 
          iprot.skip(ftype)
4247 
      else:
4248 
        iprot.skip(ftype)
4249 
      iprot.readFieldEnd()
4250 
    iprot.readStructEnd()
4251 
 
4252 
  def write(self, oprot):
4253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4255 
      return
4256 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
4257 
    if self.customer_id != None:
4258 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4259 
      oprot.writeI64(self.customer_id)
4260 
      oprot.writeFieldEnd()
4261 
    if self.limit != None:
4262 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4263 
      oprot.writeI64(self.limit)
4264 
      oprot.writeFieldEnd()
4265 
    oprot.writeFieldStop()
4266 
    oprot.writeStructEnd()
4267 
 
4268 
  def __repr__(self):
4269 
    L = ['%s=%r' % (key, value)
4270 
      for key, value in self.__dict__.iteritems()]
4271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4272 
 
4273 
  def __eq__(self, other):
4274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4275 
 
4276 
  def __ne__(self, other):
4277 
    return not (self == other)
4278 
 
4279 
class getReturnableOrdersForCustomer_result:
4280 
  """
4281 
  Attributes:
4282 
   - success
4283 
   - ex
4284 
  """
4285 
 
4286 
  thrift_spec = (
4287 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4289 
  )
4290 
 
4291 
  def __init__(self, success=None, ex=None,):
4292 
    self.success = success
4293 
    self.ex = ex
4294 
 
4295 
  def read(self, iprot):
4296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4298 
      return
4299 
    iprot.readStructBegin()
4300 
    while True:
4301 
      (fname, ftype, fid) = iprot.readFieldBegin()
4302 
      if ftype == TType.STOP:
4303 
        break
4304 
      if fid == 0:
4305 
        if ftype == TType.LIST:
4306 
          self.success = []
4307 
          (_etype45, _size42) = iprot.readListBegin()
4308 
          for _i46 in xrange(_size42):
4309 
            _elem47 = iprot.readI64();
4310 
            self.success.append(_elem47)
4311 
          iprot.readListEnd()
4312 
        else:
4313 
          iprot.skip(ftype)
4314 
      elif fid == 1:
4315 
        if ftype == TType.STRUCT:
4316 
          self.ex = TransactionServiceException()
4317 
          self.ex.read(iprot)
4318 
        else:
4319 
          iprot.skip(ftype)
4320 
      else:
4321 
        iprot.skip(ftype)
4322 
      iprot.readFieldEnd()
4323 
    iprot.readStructEnd()
4324 
 
4325 
  def write(self, oprot):
4326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4328 
      return
4329 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
4330 
    if self.success != None:
4331 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4332 
      oprot.writeListBegin(TType.I64, len(self.success))
4333 
      for iter48 in self.success:
4334 
        oprot.writeI64(iter48)
4335 
      oprot.writeListEnd()
4336 
      oprot.writeFieldEnd()
4337 
    if self.ex != None:
4338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4339 
      self.ex.write(oprot)
4340 
      oprot.writeFieldEnd()
4341 
    oprot.writeFieldStop()
4342 
    oprot.writeStructEnd()
4343 
 
4344 
  def __repr__(self):
4345 
    L = ['%s=%r' % (key, value)
4346 
      for key, value in self.__dict__.iteritems()]
4347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4348 
 
4349 
  def __eq__(self, other):
4350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4351 
 
4352 
  def __ne__(self, other):
4353 
    return not (self == other)
4354 
 
4355 
class getCancellableOrdersForCustomer_args:
4356 
  """
4357 
  Attributes:
4358 
   - customer_id
4359 
   - limit
4360 
  """
4361 
 
4362 
  thrift_spec = (
4363 
    None, # 0
4364 
    (1, TType.I64, 'customer_id', None, None, ), # 1
4365 
    (2, TType.I64, 'limit', None, None, ), # 2
4366 
  )
4367 
 
4368 
  def __init__(self, customer_id=None, limit=None,):
4369 
    self.customer_id = customer_id
4370 
    self.limit = limit
4371 
 
4372 
  def read(self, iprot):
4373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4375 
      return
4376 
    iprot.readStructBegin()
4377 
    while True:
4378 
      (fname, ftype, fid) = iprot.readFieldBegin()
4379 
      if ftype == TType.STOP:
4380 
        break
4381 
      if fid == 1:
4382 
        if ftype == TType.I64:
4383 
          self.customer_id = iprot.readI64();
4384 
        else:
4385 
          iprot.skip(ftype)
4386 
      elif fid == 2:
4387 
        if ftype == TType.I64:
4388 
          self.limit = iprot.readI64();
4389 
        else:
4390 
          iprot.skip(ftype)
4391 
      else:
4392 
        iprot.skip(ftype)
4393 
      iprot.readFieldEnd()
4394 
    iprot.readStructEnd()
4395 
 
4396 
  def write(self, oprot):
4397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4399 
      return
4400 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
4401 
    if self.customer_id != None:
4402 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
4403 
      oprot.writeI64(self.customer_id)
4404 
      oprot.writeFieldEnd()
4405 
    if self.limit != None:
4406 
      oprot.writeFieldBegin('limit', TType.I64, 2)
4407 
      oprot.writeI64(self.limit)
4408 
      oprot.writeFieldEnd()
4409 
    oprot.writeFieldStop()
4410 
    oprot.writeStructEnd()
4411 
 
4412 
  def __repr__(self):
4413 
    L = ['%s=%r' % (key, value)
4414 
      for key, value in self.__dict__.iteritems()]
4415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4416 
 
4417 
  def __eq__(self, other):
4418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4419 
 
4420 
  def __ne__(self, other):
4421 
    return not (self == other)
4422 
 
4423 
class getCancellableOrdersForCustomer_result:
4424 
  """
4425 
  Attributes:
4426 
   - success
4427 
   - ex
4428 
  """
4429 
 
4430 
  thrift_spec = (
4431 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
4432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4433 
  )
4434 
 
4435 
  def __init__(self, success=None, ex=None,):
4436 
    self.success = success
4437 
    self.ex = ex
4438 
 
4439 
  def read(self, iprot):
4440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4442 
      return
4443 
    iprot.readStructBegin()
4444 
    while True:
4445 
      (fname, ftype, fid) = iprot.readFieldBegin()
4446 
      if ftype == TType.STOP:
4447 
        break
4448 
      if fid == 0:
4449 
        if ftype == TType.LIST:
4450 
          self.success = []
4451 
          (_etype52, _size49) = iprot.readListBegin()
4452 
          for _i53 in xrange(_size49):
4453 
            _elem54 = iprot.readI64();
4454 
            self.success.append(_elem54)
4455 
          iprot.readListEnd()
4456 
        else:
4457 
          iprot.skip(ftype)
4458 
      elif fid == 1:
4459 
        if ftype == TType.STRUCT:
4460 
          self.ex = TransactionServiceException()
4461 
          self.ex.read(iprot)
4462 
        else:
4463 
          iprot.skip(ftype)
4464 
      else:
4465 
        iprot.skip(ftype)
4466 
      iprot.readFieldEnd()
4467 
    iprot.readStructEnd()
4468 
 
4469 
  def write(self, oprot):
4470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4472 
      return
4473 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
4474 
    if self.success != None:
4475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
4476 
      oprot.writeListBegin(TType.I64, len(self.success))
4477 
      for iter55 in self.success:
4478 
        oprot.writeI64(iter55)
4479 
      oprot.writeListEnd()
4480 
      oprot.writeFieldEnd()
4481 
    if self.ex != None:
4482 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4483 
      self.ex.write(oprot)
4484 
      oprot.writeFieldEnd()
4485 
    oprot.writeFieldStop()
4486 
    oprot.writeStructEnd()
4487 
 
4488 
  def __repr__(self):
4489 
    L = ['%s=%r' % (key, value)
4490 
      for key, value in self.__dict__.iteritems()]
4491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4492 
 
4493 
  def __eq__(self, other):
4494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4495 
 
4496 
  def __ne__(self, other):
4497 
    return not (self == other)
4498 
 
483 rajveer 4499 
class changeOrderStatus_args:
94 ashish 4500 
  """
4501 
  Attributes:
483 rajveer 4502 
   - orderId
4503 
   - status
4504 
   - description
94 ashish 4505 
  """
4506 
 
4507 
  thrift_spec = (
4508 
    None, # 0
483 rajveer 4509 
    (1, TType.I64, 'orderId', None, None, ), # 1
4510 
    (2, TType.I32, 'status', None, None, ), # 2
4511 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 4512 
  )
4513 
 
483 rajveer 4514 
  def __init__(self, orderId=None, status=None, description=None,):
4515 
    self.orderId = orderId
4516 
    self.status = status
4517 
    self.description = description
94 ashish 4518 
 
4519 
  def read(self, iprot):
4520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4522 
      return
4523 
    iprot.readStructBegin()
4524 
    while True:
4525 
      (fname, ftype, fid) = iprot.readFieldBegin()
4526 
      if ftype == TType.STOP:
4527 
        break
4528 
      if fid == 1:
4529 
        if ftype == TType.I64:
483 rajveer 4530 
          self.orderId = iprot.readI64();
94 ashish 4531 
        else:
4532 
          iprot.skip(ftype)
4533 
      elif fid == 2:
483 rajveer 4534 
        if ftype == TType.I32:
4535 
          self.status = iprot.readI32();
94 ashish 4536 
        else:
4537 
          iprot.skip(ftype)
483 rajveer 4538 
      elif fid == 3:
4539 
        if ftype == TType.STRING:
4540 
          self.description = iprot.readString();
4541 
        else:
4542 
          iprot.skip(ftype)
94 ashish 4543 
      else:
4544 
        iprot.skip(ftype)
4545 
      iprot.readFieldEnd()
4546 
    iprot.readStructEnd()
4547 
 
4548 
  def write(self, oprot):
4549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4551 
      return
483 rajveer 4552 
    oprot.writeStructBegin('changeOrderStatus_args')
4553 
    if self.orderId != None:
4554 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4555 
      oprot.writeI64(self.orderId)
94 ashish 4556 
      oprot.writeFieldEnd()
483 rajveer 4557 
    if self.status != None:
4558 
      oprot.writeFieldBegin('status', TType.I32, 2)
4559 
      oprot.writeI32(self.status)
94 ashish 4560 
      oprot.writeFieldEnd()
483 rajveer 4561 
    if self.description != None:
4562 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4563 
      oprot.writeString(self.description)
4564 
      oprot.writeFieldEnd()
94 ashish 4565 
    oprot.writeFieldStop()
4566 
    oprot.writeStructEnd()
4567 
 
4568 
  def __repr__(self):
4569 
    L = ['%s=%r' % (key, value)
4570 
      for key, value in self.__dict__.iteritems()]
4571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4572 
 
4573 
  def __eq__(self, other):
4574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4575 
 
4576 
  def __ne__(self, other):
4577 
    return not (self == other)
4578 
 
483 rajveer 4579 
class changeOrderStatus_result:
94 ashish 4580 
  """
4581 
  Attributes:
4582 
   - success
4583 
   - ex
4584 
  """
4585 
 
4586 
  thrift_spec = (
4587 
    (0, TType.BOOL, 'success', None, None, ), # 0
4588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4589 
  )
4590 
 
4591 
  def __init__(self, success=None, ex=None,):
4592 
    self.success = success
4593 
    self.ex = ex
4594 
 
4595 
  def read(self, iprot):
4596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4598 
      return
4599 
    iprot.readStructBegin()
4600 
    while True:
4601 
      (fname, ftype, fid) = iprot.readFieldBegin()
4602 
      if ftype == TType.STOP:
4603 
        break
4604 
      if fid == 0:
4605 
        if ftype == TType.BOOL:
4606 
          self.success = iprot.readBool();
4607 
        else:
4608 
          iprot.skip(ftype)
4609 
      elif fid == 1:
4610 
        if ftype == TType.STRUCT:
4611 
          self.ex = TransactionServiceException()
4612 
          self.ex.read(iprot)
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
483 rajveer 4624 
    oprot.writeStructBegin('changeOrderStatus_result')
94 ashish 4625 
    if self.success != None:
4626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4627 
      oprot.writeBool(self.success)
4628 
      oprot.writeFieldEnd()
4629 
    if self.ex != None:
4630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4631 
      self.ex.write(oprot)
4632 
      oprot.writeFieldEnd()
4633 
    oprot.writeFieldStop()
4634 
    oprot.writeStructEnd()
4635 
 
4636 
  def __repr__(self):
4637 
    L = ['%s=%r' % (key, value)
4638 
      for key, value in self.__dict__.iteritems()]
4639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4640 
 
4641 
  def __eq__(self, other):
4642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4643 
 
4644 
  def __ne__(self, other):
4645 
    return not (self == other)
4646 
 
494 rajveer 4647 
class addBillingDetails_args:
4648 
  """
4649 
  Attributes:
4650 
   - orderId
4651 
   - invoice_number
4652 
   - billed_by
4653 
  """
4654 
 
4655 
  thrift_spec = (
4656 
    None, # 0
4657 
    (1, TType.I64, 'orderId', None, None, ), # 1
4658 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
1149 chandransh 4659 
    (3, TType.STRING, 'billed_by', None, None, ), # 3
494 rajveer 4660 
  )
4661 
 
1149 chandransh 4662 
  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
494 rajveer 4663 
    self.orderId = orderId
4664 
    self.invoice_number = invoice_number
4665 
    self.billed_by = billed_by
4666 
 
4667 
  def read(self, iprot):
4668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4670 
      return
4671 
    iprot.readStructBegin()
4672 
    while True:
4673 
      (fname, ftype, fid) = iprot.readFieldBegin()
4674 
      if ftype == TType.STOP:
4675 
        break
4676 
      if fid == 1:
4677 
        if ftype == TType.I64:
4678 
          self.orderId = iprot.readI64();
4679 
        else:
4680 
          iprot.skip(ftype)
4681 
      elif fid == 2:
4682 
        if ftype == TType.STRING:
4683 
          self.invoice_number = iprot.readString();
4684 
        else:
4685 
          iprot.skip(ftype)
4686 
      elif fid == 3:
4687 
        if ftype == TType.STRING:
4688 
          self.billed_by = iprot.readString();
4689 
        else:
4690 
          iprot.skip(ftype)
4691 
      else:
4692 
        iprot.skip(ftype)
4693 
      iprot.readFieldEnd()
4694 
    iprot.readStructEnd()
4695 
 
4696 
  def write(self, oprot):
4697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4699 
      return
4700 
    oprot.writeStructBegin('addBillingDetails_args')
4701 
    if self.orderId != None:
4702 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4703 
      oprot.writeI64(self.orderId)
4704 
      oprot.writeFieldEnd()
4705 
    if self.invoice_number != None:
4706 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
4707 
      oprot.writeString(self.invoice_number)
4708 
      oprot.writeFieldEnd()
4709 
    if self.billed_by != None:
1149 chandransh 4710 
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
494 rajveer 4711 
      oprot.writeString(self.billed_by)
4712 
      oprot.writeFieldEnd()
4713 
    oprot.writeFieldStop()
4714 
    oprot.writeStructEnd()
4715 
 
4716 
  def __repr__(self):
4717 
    L = ['%s=%r' % (key, value)
4718 
      for key, value in self.__dict__.iteritems()]
4719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4720 
 
4721 
  def __eq__(self, other):
4722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4723 
 
4724 
  def __ne__(self, other):
4725 
    return not (self == other)
4726 
 
4727 
class addBillingDetails_result:
4728 
  """
4729 
  Attributes:
4730 
   - success
4731 
   - ex
4732 
  """
4733 
 
4734 
  thrift_spec = (
4735 
    (0, TType.BOOL, 'success', None, None, ), # 0
4736 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4737 
  )
4738 
 
4739 
  def __init__(self, success=None, ex=None,):
4740 
    self.success = success
4741 
    self.ex = ex
4742 
 
4743 
  def read(self, iprot):
4744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4746 
      return
4747 
    iprot.readStructBegin()
4748 
    while True:
4749 
      (fname, ftype, fid) = iprot.readFieldBegin()
4750 
      if ftype == TType.STOP:
4751 
        break
4752 
      if fid == 0:
4753 
        if ftype == TType.BOOL:
4754 
          self.success = iprot.readBool();
4755 
        else:
4756 
          iprot.skip(ftype)
4757 
      elif fid == 1:
4758 
        if ftype == TType.STRUCT:
4759 
          self.ex = TransactionServiceException()
4760 
          self.ex.read(iprot)
4761 
        else:
4762 
          iprot.skip(ftype)
4763 
      else:
4764 
        iprot.skip(ftype)
4765 
      iprot.readFieldEnd()
4766 
    iprot.readStructEnd()
4767 
 
4768 
  def write(self, oprot):
4769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4771 
      return
4772 
    oprot.writeStructBegin('addBillingDetails_result')
4773 
    if self.success != None:
4774 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4775 
      oprot.writeBool(self.success)
4776 
      oprot.writeFieldEnd()
4777 
    if self.ex != None:
4778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4779 
      self.ex.write(oprot)
4780 
      oprot.writeFieldEnd()
4781 
    oprot.writeFieldStop()
4782 
    oprot.writeStructEnd()
4783 
 
4784 
  def __repr__(self):
4785 
    L = ['%s=%r' % (key, value)
4786 
      for key, value in self.__dict__.iteritems()]
4787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4788 
 
4789 
  def __eq__(self, other):
4790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4791 
 
4792 
  def __ne__(self, other):
4793 
    return not (self == other)
4794 
 
1149 chandransh 4795 
class addJacketNumber_args:
4796 
  """
4797 
  Attributes:
4798 
   - orderId
4799 
   - jacketNumber
4800 
  """
4801 
 
4802 
  thrift_spec = (
4803 
    None, # 0
4804 
    (1, TType.I64, 'orderId', None, None, ), # 1
4805 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
4806 
  )
4807 
 
4808 
  def __init__(self, orderId=None, jacketNumber=None,):
4809 
    self.orderId = orderId
4810 
    self.jacketNumber = jacketNumber
4811 
 
4812 
  def read(self, iprot):
4813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4815 
      return
4816 
    iprot.readStructBegin()
4817 
    while True:
4818 
      (fname, ftype, fid) = iprot.readFieldBegin()
4819 
      if ftype == TType.STOP:
4820 
        break
4821 
      if fid == 1:
4822 
        if ftype == TType.I64:
4823 
          self.orderId = iprot.readI64();
4824 
        else:
4825 
          iprot.skip(ftype)
4826 
      elif fid == 2:
4827 
        if ftype == TType.I64:
4828 
          self.jacketNumber = iprot.readI64();
4829 
        else:
4830 
          iprot.skip(ftype)
4831 
      else:
4832 
        iprot.skip(ftype)
4833 
      iprot.readFieldEnd()
4834 
    iprot.readStructEnd()
4835 
 
4836 
  def write(self, oprot):
4837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4839 
      return
4840 
    oprot.writeStructBegin('addJacketNumber_args')
4841 
    if self.orderId != None:
4842 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4843 
      oprot.writeI64(self.orderId)
4844 
      oprot.writeFieldEnd()
4845 
    if self.jacketNumber != None:
4846 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
4847 
      oprot.writeI64(self.jacketNumber)
4848 
      oprot.writeFieldEnd()
4849 
    oprot.writeFieldStop()
4850 
    oprot.writeStructEnd()
4851 
 
4852 
  def __repr__(self):
4853 
    L = ['%s=%r' % (key, value)
4854 
      for key, value in self.__dict__.iteritems()]
4855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4856 
 
4857 
  def __eq__(self, other):
4858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4859 
 
4860 
  def __ne__(self, other):
4861 
    return not (self == other)
4862 
 
4863 
class addJacketNumber_result:
4864 
  """
4865 
  Attributes:
4866 
   - success
4867 
   - ex
4868 
  """
4869 
 
4870 
  thrift_spec = (
4871 
    (0, TType.BOOL, 'success', None, None, ), # 0
4872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4873 
  )
4874 
 
4875 
  def __init__(self, success=None, ex=None,):
4876 
    self.success = success
4877 
    self.ex = ex
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 == 0:
4889 
        if ftype == TType.BOOL:
4890 
          self.success = iprot.readBool();
4891 
        else:
4892 
          iprot.skip(ftype)
4893 
      elif fid == 1:
4894 
        if ftype == TType.STRUCT:
4895 
          self.ex = TransactionServiceException()
4896 
          self.ex.read(iprot)
4897 
        else:
4898 
          iprot.skip(ftype)
4899 
      else:
4900 
        iprot.skip(ftype)
4901 
      iprot.readFieldEnd()
4902 
    iprot.readStructEnd()
4903 
 
4904 
  def write(self, oprot):
4905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4907 
      return
4908 
    oprot.writeStructBegin('addJacketNumber_result')
4909 
    if self.success != None:
4910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4911 
      oprot.writeBool(self.success)
4912 
      oprot.writeFieldEnd()
4913 
    if self.ex != None:
4914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
4915 
      self.ex.write(oprot)
4916 
      oprot.writeFieldEnd()
4917 
    oprot.writeFieldStop()
4918 
    oprot.writeStructEnd()
4919 
 
4920 
  def __repr__(self):
4921 
    L = ['%s=%r' % (key, value)
4922 
      for key, value in self.__dict__.iteritems()]
4923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4924 
 
4925 
  def __eq__(self, other):
4926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4927 
 
4928 
  def __ne__(self, other):
4929 
    return not (self == other)
4930 
 
921 rajveer 4931 
class acceptOrder_args:
4932 
  """
4933 
  Attributes:
4934 
   - orderId
4935 
  """
4936 
 
4937 
  thrift_spec = (
4938 
    None, # 0
4939 
    (1, TType.I64, 'orderId', None, None, ), # 1
4940 
  )
4941 
 
4942 
  def __init__(self, orderId=None,):
4943 
    self.orderId = orderId
4944 
 
4945 
  def read(self, iprot):
4946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4948 
      return
4949 
    iprot.readStructBegin()
4950 
    while True:
4951 
      (fname, ftype, fid) = iprot.readFieldBegin()
4952 
      if ftype == TType.STOP:
4953 
        break
4954 
      if fid == 1:
4955 
        if ftype == TType.I64:
4956 
          self.orderId = iprot.readI64();
4957 
        else:
4958 
          iprot.skip(ftype)
4959 
      else:
4960 
        iprot.skip(ftype)
4961 
      iprot.readFieldEnd()
4962 
    iprot.readStructEnd()
4963 
 
4964 
  def write(self, oprot):
4965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4967 
      return
4968 
    oprot.writeStructBegin('acceptOrder_args')
4969 
    if self.orderId != None:
4970 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
4971 
      oprot.writeI64(self.orderId)
4972 
      oprot.writeFieldEnd()
4973 
    oprot.writeFieldStop()
4974 
    oprot.writeStructEnd()
4975 
 
4976 
  def __repr__(self):
4977 
    L = ['%s=%r' % (key, value)
4978 
      for key, value in self.__dict__.iteritems()]
4979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4980 
 
4981 
  def __eq__(self, other):
4982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4983 
 
4984 
  def __ne__(self, other):
4985 
    return not (self == other)
4986 
 
4987 
class acceptOrder_result:
4988 
  """
4989 
  Attributes:
4990 
   - success
4991 
   - ex
4992 
  """
4993 
 
4994 
  thrift_spec = (
4995 
    (0, TType.BOOL, 'success', None, None, ), # 0
4996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
4997 
  )
4998 
 
4999 
  def __init__(self, success=None, ex=None,):
5000 
    self.success = success
5001 
    self.ex = ex
5002 
 
5003 
  def read(self, iprot):
5004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5006 
      return
5007 
    iprot.readStructBegin()
5008 
    while True:
5009 
      (fname, ftype, fid) = iprot.readFieldBegin()
5010 
      if ftype == TType.STOP:
5011 
        break
5012 
      if fid == 0:
5013 
        if ftype == TType.BOOL:
5014 
          self.success = iprot.readBool();
5015 
        else:
5016 
          iprot.skip(ftype)
5017 
      elif fid == 1:
5018 
        if ftype == TType.STRUCT:
5019 
          self.ex = TransactionServiceException()
5020 
          self.ex.read(iprot)
5021 
        else:
5022 
          iprot.skip(ftype)
5023 
      else:
5024 
        iprot.skip(ftype)
5025 
      iprot.readFieldEnd()
5026 
    iprot.readStructEnd()
5027 
 
5028 
  def write(self, oprot):
5029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5031 
      return
5032 
    oprot.writeStructBegin('acceptOrder_result')
5033 
    if self.success != None:
5034 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5035 
      oprot.writeBool(self.success)
5036 
      oprot.writeFieldEnd()
5037 
    if self.ex != None:
5038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5039 
      self.ex.write(oprot)
5040 
      oprot.writeFieldEnd()
5041 
    oprot.writeFieldStop()
5042 
    oprot.writeStructEnd()
5043 
 
5044 
  def __repr__(self):
5045 
    L = ['%s=%r' % (key, value)
5046 
      for key, value in self.__dict__.iteritems()]
5047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5048 
 
5049 
  def __eq__(self, other):
5050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5051 
 
5052 
  def __ne__(self, other):
5053 
    return not (self == other)
5054 
 
5055 
class billOrder_args:
5056 
  """
5057 
  Attributes:
5058 
   - orderId
5059 
  """
5060 
 
5061 
  thrift_spec = (
5062 
    None, # 0
5063 
    (1, TType.I64, 'orderId', None, None, ), # 1
5064 
  )
5065 
 
5066 
  def __init__(self, orderId=None,):
5067 
    self.orderId = orderId
5068 
 
5069 
  def read(self, iprot):
5070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5072 
      return
5073 
    iprot.readStructBegin()
5074 
    while True:
5075 
      (fname, ftype, fid) = iprot.readFieldBegin()
5076 
      if ftype == TType.STOP:
5077 
        break
5078 
      if fid == 1:
5079 
        if ftype == TType.I64:
5080 
          self.orderId = iprot.readI64();
5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      else:
5084 
        iprot.skip(ftype)
5085 
      iprot.readFieldEnd()
5086 
    iprot.readStructEnd()
5087 
 
5088 
  def write(self, oprot):
5089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5091 
      return
5092 
    oprot.writeStructBegin('billOrder_args')
5093 
    if self.orderId != None:
5094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5095 
      oprot.writeI64(self.orderId)
5096 
      oprot.writeFieldEnd()
5097 
    oprot.writeFieldStop()
5098 
    oprot.writeStructEnd()
5099 
 
5100 
  def __repr__(self):
5101 
    L = ['%s=%r' % (key, value)
5102 
      for key, value in self.__dict__.iteritems()]
5103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5104 
 
5105 
  def __eq__(self, other):
5106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5107 
 
5108 
  def __ne__(self, other):
5109 
    return not (self == other)
5110 
 
5111 
class billOrder_result:
5112 
  """
5113 
  Attributes:
5114 
   - success
5115 
   - ex
5116 
  """
5117 
 
5118 
  thrift_spec = (
5119 
    (0, TType.BOOL, 'success', None, None, ), # 0
5120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5121 
  )
5122 
 
5123 
  def __init__(self, success=None, ex=None,):
5124 
    self.success = success
5125 
    self.ex = ex
5126 
 
5127 
  def read(self, iprot):
5128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5130 
      return
5131 
    iprot.readStructBegin()
5132 
    while True:
5133 
      (fname, ftype, fid) = iprot.readFieldBegin()
5134 
      if ftype == TType.STOP:
5135 
        break
5136 
      if fid == 0:
5137 
        if ftype == TType.BOOL:
5138 
          self.success = iprot.readBool();
5139 
        else:
5140 
          iprot.skip(ftype)
5141 
      elif fid == 1:
5142 
        if ftype == TType.STRUCT:
5143 
          self.ex = TransactionServiceException()
5144 
          self.ex.read(iprot)
5145 
        else:
5146 
          iprot.skip(ftype)
5147 
      else:
5148 
        iprot.skip(ftype)
5149 
      iprot.readFieldEnd()
5150 
    iprot.readStructEnd()
5151 
 
5152 
  def write(self, oprot):
5153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5155 
      return
5156 
    oprot.writeStructBegin('billOrder_result')
5157 
    if self.success != None:
5158 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5159 
      oprot.writeBool(self.success)
5160 
      oprot.writeFieldEnd()
5161 
    if self.ex != None:
5162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5163 
      self.ex.write(oprot)
5164 
      oprot.writeFieldEnd()
5165 
    oprot.writeFieldStop()
5166 
    oprot.writeStructEnd()
5167 
 
5168 
  def __repr__(self):
5169 
    L = ['%s=%r' % (key, value)
5170 
      for key, value in self.__dict__.iteritems()]
5171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5172 
 
5173 
  def __eq__(self, other):
5174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5175 
 
5176 
  def __ne__(self, other):
5177 
    return not (self == other)
5178 
 
483 rajveer 5179 
class getOrdersForTransaction_args:
94 ashish 5180 
  """
5181 
  Attributes:
5182 
   - transactionId
1528 ankur.sing 5183 
   - customerId
94 ashish 5184 
  """
5185 
 
5186 
  thrift_spec = (
5187 
    None, # 0
5188 
    (1, TType.I64, 'transactionId', None, None, ), # 1
1528 ankur.sing 5189 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 5190 
  )
5191 
 
1528 ankur.sing 5192 
  def __init__(self, transactionId=None, customerId=None,):
94 ashish 5193 
    self.transactionId = transactionId
1528 ankur.sing 5194 
    self.customerId = customerId
94 ashish 5195 
 
5196 
  def read(self, iprot):
5197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5199 
      return
5200 
    iprot.readStructBegin()
5201 
    while True:
5202 
      (fname, ftype, fid) = iprot.readFieldBegin()
5203 
      if ftype == TType.STOP:
5204 
        break
5205 
      if fid == 1:
5206 
        if ftype == TType.I64:
5207 
          self.transactionId = iprot.readI64();
5208 
        else:
5209 
          iprot.skip(ftype)
1528 ankur.sing 5210 
      elif fid == 2:
5211 
        if ftype == TType.I64:
5212 
          self.customerId = iprot.readI64();
5213 
        else:
5214 
          iprot.skip(ftype)
94 ashish 5215 
      else:
5216 
        iprot.skip(ftype)
5217 
      iprot.readFieldEnd()
5218 
    iprot.readStructEnd()
5219 
 
5220 
  def write(self, oprot):
5221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5223 
      return
483 rajveer 5224 
    oprot.writeStructBegin('getOrdersForTransaction_args')
94 ashish 5225 
    if self.transactionId != None:
5226 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
5227 
      oprot.writeI64(self.transactionId)
5228 
      oprot.writeFieldEnd()
1528 ankur.sing 5229 
    if self.customerId != None:
5230 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5231 
      oprot.writeI64(self.customerId)
5232 
      oprot.writeFieldEnd()
94 ashish 5233 
    oprot.writeFieldStop()
5234 
    oprot.writeStructEnd()
5235 
 
5236 
  def __repr__(self):
5237 
    L = ['%s=%r' % (key, value)
5238 
      for key, value in self.__dict__.iteritems()]
5239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5240 
 
5241 
  def __eq__(self, other):
5242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5243 
 
5244 
  def __ne__(self, other):
5245 
    return not (self == other)
5246 
 
483 rajveer 5247 
class getOrdersForTransaction_result:
94 ashish 5248 
  """
5249 
  Attributes:
5250 
   - success
5251 
   - ex
5252 
  """
5253 
 
5254 
  thrift_spec = (
483 rajveer 5255 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5257 
  )
5258 
 
5259 
  def __init__(self, success=None, ex=None,):
5260 
    self.success = success
5261 
    self.ex = ex
5262 
 
5263 
  def read(self, iprot):
5264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5266 
      return
5267 
    iprot.readStructBegin()
5268 
    while True:
5269 
      (fname, ftype, fid) = iprot.readFieldBegin()
5270 
      if ftype == TType.STOP:
5271 
        break
5272 
      if fid == 0:
483 rajveer 5273 
        if ftype == TType.LIST:
5274 
          self.success = []
1382 varun.gupt 5275 
          (_etype59, _size56) = iprot.readListBegin()
5276 
          for _i60 in xrange(_size56):
5277 
            _elem61 = Order()
5278 
            _elem61.read(iprot)
5279 
            self.success.append(_elem61)
483 rajveer 5280 
          iprot.readListEnd()
94 ashish 5281 
        else:
5282 
          iprot.skip(ftype)
5283 
      elif fid == 1:
5284 
        if ftype == TType.STRUCT:
5285 
          self.ex = TransactionServiceException()
5286 
          self.ex.read(iprot)
5287 
        else:
5288 
          iprot.skip(ftype)
5289 
      else:
5290 
        iprot.skip(ftype)
5291 
      iprot.readFieldEnd()
5292 
    iprot.readStructEnd()
5293 
 
5294 
  def write(self, oprot):
5295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5297 
      return
483 rajveer 5298 
    oprot.writeStructBegin('getOrdersForTransaction_result')
94 ashish 5299 
    if self.success != None:
483 rajveer 5300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5302 
      for iter62 in self.success:
5303 
        iter62.write(oprot)
483 rajveer 5304 
      oprot.writeListEnd()
94 ashish 5305 
      oprot.writeFieldEnd()
5306 
    if self.ex != None:
5307 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5308 
      self.ex.write(oprot)
5309 
      oprot.writeFieldEnd()
5310 
    oprot.writeFieldStop()
5311 
    oprot.writeStructEnd()
5312 
 
5313 
  def __repr__(self):
5314 
    L = ['%s=%r' % (key, value)
5315 
      for key, value in self.__dict__.iteritems()]
5316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5317 
 
5318 
  def __eq__(self, other):
5319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5320 
 
5321 
  def __ne__(self, other):
5322 
    return not (self == other)
5323 
 
483 rajveer 5324 
class getOrdersForCustomer_args:
94 ashish 5325 
  """
5326 
  Attributes:
483 rajveer 5327 
   - customerId
5328 
   - from_date
5329 
   - to_date
5330 
   - status
94 ashish 5331 
  """
5332 
 
5333 
  thrift_spec = (
5334 
    None, # 0
483 rajveer 5335 
    (1, TType.I64, 'customerId', None, None, ), # 1
5336 
    (2, TType.I64, 'from_date', None, None, ), # 2
5337 
    (3, TType.I64, 'to_date', None, None, ), # 3
5338 
    (4, TType.I32, 'status', None, None, ), # 4
94 ashish 5339 
  )
5340 
 
483 rajveer 5341 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
5342 
    self.customerId = customerId
5343 
    self.from_date = from_date
5344 
    self.to_date = to_date
5345 
    self.status = status
94 ashish 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 == 1:
5357 
        if ftype == TType.I64:
483 rajveer 5358 
          self.customerId = iprot.readI64();
94 ashish 5359 
        else:
5360 
          iprot.skip(ftype)
5361 
      elif fid == 2:
5362 
        if ftype == TType.I64:
483 rajveer 5363 
          self.from_date = iprot.readI64();
94 ashish 5364 
        else:
5365 
          iprot.skip(ftype)
5366 
      elif fid == 3:
5367 
        if ftype == TType.I64:
483 rajveer 5368 
          self.to_date = iprot.readI64();
94 ashish 5369 
        else:
5370 
          iprot.skip(ftype)
483 rajveer 5371 
      elif fid == 4:
5372 
        if ftype == TType.I32:
5373 
          self.status = iprot.readI32();
5374 
        else:
5375 
          iprot.skip(ftype)
94 ashish 5376 
      else:
5377 
        iprot.skip(ftype)
5378 
      iprot.readFieldEnd()
5379 
    iprot.readStructEnd()
5380 
 
5381 
  def write(self, oprot):
5382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5384 
      return
483 rajveer 5385 
    oprot.writeStructBegin('getOrdersForCustomer_args')
5386 
    if self.customerId != None:
5387 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
5388 
      oprot.writeI64(self.customerId)
94 ashish 5389 
      oprot.writeFieldEnd()
483 rajveer 5390 
    if self.from_date != None:
5391 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
5392 
      oprot.writeI64(self.from_date)
94 ashish 5393 
      oprot.writeFieldEnd()
483 rajveer 5394 
    if self.to_date != None:
5395 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
5396 
      oprot.writeI64(self.to_date)
94 ashish 5397 
      oprot.writeFieldEnd()
483 rajveer 5398 
    if self.status != None:
5399 
      oprot.writeFieldBegin('status', TType.I32, 4)
5400 
      oprot.writeI32(self.status)
5401 
      oprot.writeFieldEnd()
94 ashish 5402 
    oprot.writeFieldStop()
5403 
    oprot.writeStructEnd()
5404 
 
5405 
  def __repr__(self):
5406 
    L = ['%s=%r' % (key, value)
5407 
      for key, value in self.__dict__.iteritems()]
5408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5409 
 
5410 
  def __eq__(self, other):
5411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5412 
 
5413 
  def __ne__(self, other):
5414 
    return not (self == other)
5415 
 
483 rajveer 5416 
class getOrdersForCustomer_result:
94 ashish 5417 
  """
5418 
  Attributes:
5419 
   - success
5420 
   - ex
5421 
  """
5422 
 
5423 
  thrift_spec = (
483 rajveer 5424 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 5425 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5426 
  )
5427 
 
5428 
  def __init__(self, success=None, ex=None,):
5429 
    self.success = success
5430 
    self.ex = ex
5431 
 
5432 
  def read(self, iprot):
5433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5435 
      return
5436 
    iprot.readStructBegin()
5437 
    while True:
5438 
      (fname, ftype, fid) = iprot.readFieldBegin()
5439 
      if ftype == TType.STOP:
5440 
        break
5441 
      if fid == 0:
483 rajveer 5442 
        if ftype == TType.LIST:
5443 
          self.success = []
1382 varun.gupt 5444 
          (_etype66, _size63) = iprot.readListBegin()
5445 
          for _i67 in xrange(_size63):
5446 
            _elem68 = Order()
5447 
            _elem68.read(iprot)
5448 
            self.success.append(_elem68)
483 rajveer 5449 
          iprot.readListEnd()
94 ashish 5450 
        else:
5451 
          iprot.skip(ftype)
5452 
      elif fid == 1:
5453 
        if ftype == TType.STRUCT:
5454 
          self.ex = TransactionServiceException()
5455 
          self.ex.read(iprot)
5456 
        else:
5457 
          iprot.skip(ftype)
5458 
      else:
5459 
        iprot.skip(ftype)
5460 
      iprot.readFieldEnd()
5461 
    iprot.readStructEnd()
5462 
 
5463 
  def write(self, oprot):
5464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5466 
      return
483 rajveer 5467 
    oprot.writeStructBegin('getOrdersForCustomer_result')
94 ashish 5468 
    if self.success != None:
483 rajveer 5469 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5470 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5471 
      for iter69 in self.success:
5472 
        iter69.write(oprot)
483 rajveer 5473 
      oprot.writeListEnd()
94 ashish 5474 
      oprot.writeFieldEnd()
5475 
    if self.ex != None:
5476 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5477 
      self.ex.write(oprot)
5478 
      oprot.writeFieldEnd()
5479 
    oprot.writeFieldStop()
5480 
    oprot.writeStructEnd()
5481 
 
5482 
  def __repr__(self):
5483 
    L = ['%s=%r' % (key, value)
5484 
      for key, value in self.__dict__.iteritems()]
5485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5486 
 
5487 
  def __eq__(self, other):
5488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5489 
 
5490 
  def __ne__(self, other):
5491 
    return not (self == other)
5492 
 
483 rajveer 5493 
class createOrder_args:
94 ashish 5494 
  """
5495 
  Attributes:
483 rajveer 5496 
   - order
94 ashish 5497 
  """
5498 
 
5499 
  thrift_spec = (
5500 
    None, # 0
483 rajveer 5501 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
94 ashish 5502 
  )
5503 
 
483 rajveer 5504 
  def __init__(self, order=None,):
5505 
    self.order = order
94 ashish 5506 
 
5507 
  def read(self, iprot):
5508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5510 
      return
5511 
    iprot.readStructBegin()
5512 
    while True:
5513 
      (fname, ftype, fid) = iprot.readFieldBegin()
5514 
      if ftype == TType.STOP:
5515 
        break
5516 
      if fid == 1:
483 rajveer 5517 
        if ftype == TType.STRUCT:
5518 
          self.order = Order()
5519 
          self.order.read(iprot)
94 ashish 5520 
        else:
5521 
          iprot.skip(ftype)
5522 
      else:
5523 
        iprot.skip(ftype)
5524 
      iprot.readFieldEnd()
5525 
    iprot.readStructEnd()
5526 
 
5527 
  def write(self, oprot):
5528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5530 
      return
483 rajveer 5531 
    oprot.writeStructBegin('createOrder_args')
5532 
    if self.order != None:
5533 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
5534 
      self.order.write(oprot)
94 ashish 5535 
      oprot.writeFieldEnd()
5536 
    oprot.writeFieldStop()
5537 
    oprot.writeStructEnd()
5538 
 
5539 
  def __repr__(self):
5540 
    L = ['%s=%r' % (key, value)
5541 
      for key, value in self.__dict__.iteritems()]
5542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5543 
 
5544 
  def __eq__(self, other):
5545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5546 
 
5547 
  def __ne__(self, other):
5548 
    return not (self == other)
5549 
 
483 rajveer 5550 
class createOrder_result:
94 ashish 5551 
  """
5552 
  Attributes:
5553 
   - success
5554 
   - ex
5555 
  """
5556 
 
5557 
  thrift_spec = (
483 rajveer 5558 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 5559 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5560 
  )
5561 
 
5562 
  def __init__(self, success=None, ex=None,):
5563 
    self.success = success
5564 
    self.ex = ex
5565 
 
5566 
  def read(self, iprot):
5567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5569 
      return
5570 
    iprot.readStructBegin()
5571 
    while True:
5572 
      (fname, ftype, fid) = iprot.readFieldBegin()
5573 
      if ftype == TType.STOP:
5574 
        break
5575 
      if fid == 0:
483 rajveer 5576 
        if ftype == TType.I64:
5577 
          self.success = iprot.readI64();
94 ashish 5578 
        else:
5579 
          iprot.skip(ftype)
5580 
      elif fid == 1:
5581 
        if ftype == TType.STRUCT:
5582 
          self.ex = TransactionServiceException()
5583 
          self.ex.read(iprot)
5584 
        else:
5585 
          iprot.skip(ftype)
5586 
      else:
5587 
        iprot.skip(ftype)
5588 
      iprot.readFieldEnd()
5589 
    iprot.readStructEnd()
5590 
 
5591 
  def write(self, oprot):
5592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5594 
      return
483 rajveer 5595 
    oprot.writeStructBegin('createOrder_result')
94 ashish 5596 
    if self.success != None:
483 rajveer 5597 
      oprot.writeFieldBegin('success', TType.I64, 0)
5598 
      oprot.writeI64(self.success)
94 ashish 5599 
      oprot.writeFieldEnd()
5600 
    if self.ex != None:
5601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5602 
      self.ex.write(oprot)
5603 
      oprot.writeFieldEnd()
5604 
    oprot.writeFieldStop()
5605 
    oprot.writeStructEnd()
5606 
 
5607 
  def __repr__(self):
5608 
    L = ['%s=%r' % (key, value)
5609 
      for key, value in self.__dict__.iteritems()]
5610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5611 
 
5612 
  def __eq__(self, other):
5613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5614 
 
5615 
  def __ne__(self, other):
5616 
    return not (self == other)
5617 
 
483 rajveer 5618 
class getOrder_args:
94 ashish 5619 
  """
5620 
  Attributes:
483 rajveer 5621 
   - id
94 ashish 5622 
  """
5623 
 
5624 
  thrift_spec = (
5625 
    None, # 0
483 rajveer 5626 
    (1, TType.I64, 'id', None, None, ), # 1
94 ashish 5627 
  )
5628 
 
483 rajveer 5629 
  def __init__(self, id=None,):
5630 
    self.id = id
94 ashish 5631 
 
5632 
  def read(self, iprot):
5633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5635 
      return
5636 
    iprot.readStructBegin()
5637 
    while True:
5638 
      (fname, ftype, fid) = iprot.readFieldBegin()
5639 
      if ftype == TType.STOP:
5640 
        break
5641 
      if fid == 1:
5642 
        if ftype == TType.I64:
483 rajveer 5643 
          self.id = iprot.readI64();
94 ashish 5644 
        else:
5645 
          iprot.skip(ftype)
5646 
      else:
5647 
        iprot.skip(ftype)
5648 
      iprot.readFieldEnd()
5649 
    iprot.readStructEnd()
5650 
 
5651 
  def write(self, oprot):
5652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5654 
      return
483 rajveer 5655 
    oprot.writeStructBegin('getOrder_args')
5656 
    if self.id != None:
5657 
      oprot.writeFieldBegin('id', TType.I64, 1)
5658 
      oprot.writeI64(self.id)
94 ashish 5659 
      oprot.writeFieldEnd()
5660 
    oprot.writeFieldStop()
5661 
    oprot.writeStructEnd()
5662 
 
5663 
  def __repr__(self):
5664 
    L = ['%s=%r' % (key, value)
5665 
      for key, value in self.__dict__.iteritems()]
5666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5667 
 
5668 
  def __eq__(self, other):
5669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5670 
 
5671 
  def __ne__(self, other):
5672 
    return not (self == other)
5673 
 
483 rajveer 5674 
class getOrder_result:
94 ashish 5675 
  """
5676 
  Attributes:
5677 
   - success
5678 
   - ex
5679 
  """
5680 
 
5681 
  thrift_spec = (
483 rajveer 5682 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 5683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5684 
  )
5685 
 
5686 
  def __init__(self, success=None, ex=None,):
5687 
    self.success = success
5688 
    self.ex = ex
5689 
 
5690 
  def read(self, iprot):
5691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5693 
      return
5694 
    iprot.readStructBegin()
5695 
    while True:
5696 
      (fname, ftype, fid) = iprot.readFieldBegin()
5697 
      if ftype == TType.STOP:
5698 
        break
5699 
      if fid == 0:
483 rajveer 5700 
        if ftype == TType.STRUCT:
5701 
          self.success = Order()
5702 
          self.success.read(iprot)
94 ashish 5703 
        else:
5704 
          iprot.skip(ftype)
5705 
      elif fid == 1:
5706 
        if ftype == TType.STRUCT:
5707 
          self.ex = TransactionServiceException()
5708 
          self.ex.read(iprot)
5709 
        else:
5710 
          iprot.skip(ftype)
5711 
      else:
5712 
        iprot.skip(ftype)
5713 
      iprot.readFieldEnd()
5714 
    iprot.readStructEnd()
5715 
 
5716 
  def write(self, oprot):
5717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5719 
      return
483 rajveer 5720 
    oprot.writeStructBegin('getOrder_result')
94 ashish 5721 
    if self.success != None:
483 rajveer 5722 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5723 
      self.success.write(oprot)
94 ashish 5724 
      oprot.writeFieldEnd()
5725 
    if self.ex != None:
5726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5727 
      self.ex.write(oprot)
5728 
      oprot.writeFieldEnd()
5729 
    oprot.writeFieldStop()
5730 
    oprot.writeStructEnd()
5731 
 
5732 
  def __repr__(self):
5733 
    L = ['%s=%r' % (key, value)
5734 
      for key, value in self.__dict__.iteritems()]
5735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5736 
 
5737 
  def __eq__(self, other):
5738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5739 
 
5740 
  def __ne__(self, other):
5741 
    return not (self == other)
5742 
 
483 rajveer 5743 
class getLineItemsForOrder_args:
94 ashish 5744 
  """
5745 
  Attributes:
483 rajveer 5746 
   - orderId
94 ashish 5747 
  """
5748 
 
5749 
  thrift_spec = (
5750 
    None, # 0
483 rajveer 5751 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 5752 
  )
5753 
 
483 rajveer 5754 
  def __init__(self, orderId=None,):
5755 
    self.orderId = orderId
94 ashish 5756 
 
5757 
  def read(self, iprot):
5758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5760 
      return
5761 
    iprot.readStructBegin()
5762 
    while True:
5763 
      (fname, ftype, fid) = iprot.readFieldBegin()
5764 
      if ftype == TType.STOP:
5765 
        break
5766 
      if fid == 1:
5767 
        if ftype == TType.I64:
483 rajveer 5768 
          self.orderId = iprot.readI64();
94 ashish 5769 
        else:
5770 
          iprot.skip(ftype)
5771 
      else:
5772 
        iprot.skip(ftype)
5773 
      iprot.readFieldEnd()
5774 
    iprot.readStructEnd()
5775 
 
5776 
  def write(self, oprot):
5777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5779 
      return
483 rajveer 5780 
    oprot.writeStructBegin('getLineItemsForOrder_args')
5781 
    if self.orderId != None:
5782 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5783 
      oprot.writeI64(self.orderId)
94 ashish 5784 
      oprot.writeFieldEnd()
5785 
    oprot.writeFieldStop()
5786 
    oprot.writeStructEnd()
5787 
 
5788 
  def __repr__(self):
5789 
    L = ['%s=%r' % (key, value)
5790 
      for key, value in self.__dict__.iteritems()]
5791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5792 
 
5793 
  def __eq__(self, other):
5794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5795 
 
5796 
  def __ne__(self, other):
5797 
    return not (self == other)
5798 
 
483 rajveer 5799 
class getLineItemsForOrder_result:
94 ashish 5800 
  """
5801 
  Attributes:
5802 
   - success
5803 
   - ex
5804 
  """
5805 
 
5806 
  thrift_spec = (
483 rajveer 5807 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 5808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5809 
  )
5810 
 
5811 
  def __init__(self, success=None, ex=None,):
5812 
    self.success = success
5813 
    self.ex = ex
5814 
 
5815 
  def read(self, iprot):
5816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5818 
      return
5819 
    iprot.readStructBegin()
5820 
    while True:
5821 
      (fname, ftype, fid) = iprot.readFieldBegin()
5822 
      if ftype == TType.STOP:
5823 
        break
5824 
      if fid == 0:
483 rajveer 5825 
        if ftype == TType.LIST:
5826 
          self.success = []
1382 varun.gupt 5827 
          (_etype73, _size70) = iprot.readListBegin()
5828 
          for _i74 in xrange(_size70):
5829 
            _elem75 = LineItem()
5830 
            _elem75.read(iprot)
5831 
            self.success.append(_elem75)
483 rajveer 5832 
          iprot.readListEnd()
94 ashish 5833 
        else:
5834 
          iprot.skip(ftype)
5835 
      elif fid == 1:
5836 
        if ftype == TType.STRUCT:
5837 
          self.ex = TransactionServiceException()
5838 
          self.ex.read(iprot)
5839 
        else:
5840 
          iprot.skip(ftype)
5841 
      else:
5842 
        iprot.skip(ftype)
5843 
      iprot.readFieldEnd()
5844 
    iprot.readStructEnd()
5845 
 
5846 
  def write(self, oprot):
5847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5849 
      return
483 rajveer 5850 
    oprot.writeStructBegin('getLineItemsForOrder_result')
94 ashish 5851 
    if self.success != None:
483 rajveer 5852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 5854 
      for iter76 in self.success:
5855 
        iter76.write(oprot)
483 rajveer 5856 
      oprot.writeListEnd()
94 ashish 5857 
      oprot.writeFieldEnd()
5858 
    if self.ex != None:
5859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5860 
      self.ex.write(oprot)
5861 
      oprot.writeFieldEnd()
5862 
    oprot.writeFieldStop()
5863 
    oprot.writeStructEnd()
5864 
 
5865 
  def __repr__(self):
5866 
    L = ['%s=%r' % (key, value)
5867 
      for key, value in self.__dict__.iteritems()]
5868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5869 
 
5870 
  def __eq__(self, other):
5871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5872 
 
5873 
  def __ne__(self, other):
5874 
    return not (self == other)
5875 
 
1528 ankur.sing 5876 
class getOrderForCustomer_args:
5877 
  """
5878 
  Attributes:
5879 
   - orderId
5880 
   - customerId
5881 
  """
5882 
 
5883 
  thrift_spec = (
5884 
    None, # 0
5885 
    (1, TType.I64, 'orderId', None, None, ), # 1
5886 
    (2, TType.I64, 'customerId', None, None, ), # 2
5887 
  )
5888 
 
5889 
  def __init__(self, orderId=None, customerId=None,):
5890 
    self.orderId = orderId
5891 
    self.customerId = customerId
5892 
 
5893 
  def read(self, iprot):
5894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5896 
      return
5897 
    iprot.readStructBegin()
5898 
    while True:
5899 
      (fname, ftype, fid) = iprot.readFieldBegin()
5900 
      if ftype == TType.STOP:
5901 
        break
5902 
      if fid == 1:
5903 
        if ftype == TType.I64:
5904 
          self.orderId = iprot.readI64();
5905 
        else:
5906 
          iprot.skip(ftype)
5907 
      elif fid == 2:
5908 
        if ftype == TType.I64:
5909 
          self.customerId = iprot.readI64();
5910 
        else:
5911 
          iprot.skip(ftype)
5912 
      else:
5913 
        iprot.skip(ftype)
5914 
      iprot.readFieldEnd()
5915 
    iprot.readStructEnd()
5916 
 
5917 
  def write(self, oprot):
5918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5920 
      return
5921 
    oprot.writeStructBegin('getOrderForCustomer_args')
5922 
    if self.orderId != None:
5923 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
5924 
      oprot.writeI64(self.orderId)
5925 
      oprot.writeFieldEnd()
5926 
    if self.customerId != None:
5927 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
5928 
      oprot.writeI64(self.customerId)
5929 
      oprot.writeFieldEnd()
5930 
    oprot.writeFieldStop()
5931 
    oprot.writeStructEnd()
5932 
 
5933 
  def __repr__(self):
5934 
    L = ['%s=%r' % (key, value)
5935 
      for key, value in self.__dict__.iteritems()]
5936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5937 
 
5938 
  def __eq__(self, other):
5939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5940 
 
5941 
  def __ne__(self, other):
5942 
    return not (self == other)
5943 
 
5944 
class getOrderForCustomer_result:
5945 
  """
5946 
  Attributes:
5947 
   - success
5948 
   - ex
5949 
  """
5950 
 
5951 
  thrift_spec = (
5952 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
5953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
5954 
  )
5955 
 
5956 
  def __init__(self, success=None, ex=None,):
5957 
    self.success = success
5958 
    self.ex = ex
5959 
 
5960 
  def read(self, iprot):
5961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5963 
      return
5964 
    iprot.readStructBegin()
5965 
    while True:
5966 
      (fname, ftype, fid) = iprot.readFieldBegin()
5967 
      if ftype == TType.STOP:
5968 
        break
5969 
      if fid == 0:
5970 
        if ftype == TType.STRUCT:
5971 
          self.success = Order()
5972 
          self.success.read(iprot)
5973 
        else:
5974 
          iprot.skip(ftype)
5975 
      elif fid == 1:
5976 
        if ftype == TType.STRUCT:
5977 
          self.ex = TransactionServiceException()
5978 
          self.ex.read(iprot)
5979 
        else:
5980 
          iprot.skip(ftype)
5981 
      else:
5982 
        iprot.skip(ftype)
5983 
      iprot.readFieldEnd()
5984 
    iprot.readStructEnd()
5985 
 
5986 
  def write(self, oprot):
5987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5989 
      return
5990 
    oprot.writeStructBegin('getOrderForCustomer_result')
5991 
    if self.success != None:
5992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5993 
      self.success.write(oprot)
5994 
      oprot.writeFieldEnd()
5995 
    if self.ex != None:
5996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
5997 
      self.ex.write(oprot)
5998 
      oprot.writeFieldEnd()
5999 
    oprot.writeFieldStop()
6000 
    oprot.writeStructEnd()
6001 
 
6002 
  def __repr__(self):
6003 
    L = ['%s=%r' % (key, value)
6004 
      for key, value in self.__dict__.iteritems()]
6005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6006 
 
6007 
  def __eq__(self, other):
6008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6009 
 
6010 
  def __ne__(self, other):
6011 
    return not (self == other)
6012 
 
1220 chandransh 6013 
class batchOrders_args:
6014 
  """
6015 
  Attributes:
6016 
   - warehouseId
6017 
  """
6018 
 
6019 
  thrift_spec = (
6020 
    None, # 0
6021 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6022 
  )
6023 
 
6024 
  def __init__(self, warehouseId=None,):
6025 
    self.warehouseId = warehouseId
6026 
 
6027 
  def read(self, iprot):
6028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6030 
      return
6031 
    iprot.readStructBegin()
6032 
    while True:
6033 
      (fname, ftype, fid) = iprot.readFieldBegin()
6034 
      if ftype == TType.STOP:
6035 
        break
6036 
      if fid == 1:
6037 
        if ftype == TType.I64:
6038 
          self.warehouseId = iprot.readI64();
6039 
        else:
6040 
          iprot.skip(ftype)
6041 
      else:
6042 
        iprot.skip(ftype)
6043 
      iprot.readFieldEnd()
6044 
    iprot.readStructEnd()
6045 
 
6046 
  def write(self, oprot):
6047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6049 
      return
6050 
    oprot.writeStructBegin('batchOrders_args')
6051 
    if self.warehouseId != None:
6052 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
6053 
      oprot.writeI64(self.warehouseId)
6054 
      oprot.writeFieldEnd()
6055 
    oprot.writeFieldStop()
6056 
    oprot.writeStructEnd()
6057 
 
6058 
  def __repr__(self):
6059 
    L = ['%s=%r' % (key, value)
6060 
      for key, value in self.__dict__.iteritems()]
6061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6062 
 
6063 
  def __eq__(self, other):
6064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6065 
 
6066 
  def __ne__(self, other):
6067 
    return not (self == other)
6068 
 
6069 
class batchOrders_result:
6070 
  """
6071 
  Attributes:
6072 
   - success
6073 
   - ex
6074 
  """
6075 
 
6076 
  thrift_spec = (
6077 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6079 
  )
6080 
 
6081 
  def __init__(self, success=None, ex=None,):
6082 
    self.success = success
6083 
    self.ex = ex
6084 
 
6085 
  def read(self, iprot):
6086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6088 
      return
6089 
    iprot.readStructBegin()
6090 
    while True:
6091 
      (fname, ftype, fid) = iprot.readFieldBegin()
6092 
      if ftype == TType.STOP:
6093 
        break
6094 
      if fid == 0:
6095 
        if ftype == TType.LIST:
6096 
          self.success = []
1382 varun.gupt 6097 
          (_etype80, _size77) = iprot.readListBegin()
6098 
          for _i81 in xrange(_size77):
6099 
            _elem82 = Order()
6100 
            _elem82.read(iprot)
6101 
            self.success.append(_elem82)
1220 chandransh 6102 
          iprot.readListEnd()
6103 
        else:
6104 
          iprot.skip(ftype)
6105 
      elif fid == 1:
6106 
        if ftype == TType.STRUCT:
6107 
          self.ex = TransactionServiceException()
6108 
          self.ex.read(iprot)
6109 
        else:
6110 
          iprot.skip(ftype)
6111 
      else:
6112 
        iprot.skip(ftype)
6113 
      iprot.readFieldEnd()
6114 
    iprot.readStructEnd()
6115 
 
6116 
  def write(self, oprot):
6117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6119 
      return
6120 
    oprot.writeStructBegin('batchOrders_result')
6121 
    if self.success != None:
6122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 6124 
      for iter83 in self.success:
6125 
        iter83.write(oprot)
1220 chandransh 6126 
      oprot.writeListEnd()
6127 
      oprot.writeFieldEnd()
6128 
    if self.ex != None:
6129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6130 
      self.ex.write(oprot)
6131 
      oprot.writeFieldEnd()
6132 
    oprot.writeFieldStop()
6133 
    oprot.writeStructEnd()
6134 
 
6135 
  def __repr__(self):
6136 
    L = ['%s=%r' % (key, value)
6137 
      for key, value in self.__dict__.iteritems()]
6138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6139 
 
6140 
  def __eq__(self, other):
6141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6142 
 
6143 
  def __ne__(self, other):
6144 
    return not (self == other)
6145 
 
1208 chandransh 6146 
class markOrderAsOutOfStock_args:
6147 
  """
6148 
  Attributes:
6149 
   - orderId
6150 
  """
6151 
 
6152 
  thrift_spec = (
6153 
    None, # 0
6154 
    (1, TType.I64, 'orderId', None, None, ), # 1
6155 
  )
6156 
 
6157 
  def __init__(self, orderId=None,):
6158 
    self.orderId = orderId
6159 
 
6160 
  def read(self, iprot):
6161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6163 
      return
6164 
    iprot.readStructBegin()
6165 
    while True:
6166 
      (fname, ftype, fid) = iprot.readFieldBegin()
6167 
      if ftype == TType.STOP:
6168 
        break
6169 
      if fid == 1:
6170 
        if ftype == TType.I64:
6171 
          self.orderId = iprot.readI64();
6172 
        else:
6173 
          iprot.skip(ftype)
6174 
      else:
6175 
        iprot.skip(ftype)
6176 
      iprot.readFieldEnd()
6177 
    iprot.readStructEnd()
6178 
 
6179 
  def write(self, oprot):
6180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6182 
      return
6183 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
6184 
    if self.orderId != None:
6185 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
6186 
      oprot.writeI64(self.orderId)
6187 
      oprot.writeFieldEnd()
6188 
    oprot.writeFieldStop()
6189 
    oprot.writeStructEnd()
6190 
 
6191 
  def __repr__(self):
6192 
    L = ['%s=%r' % (key, value)
6193 
      for key, value in self.__dict__.iteritems()]
6194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6195 
 
6196 
  def __eq__(self, other):
6197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6198 
 
6199 
  def __ne__(self, other):
6200 
    return not (self == other)
6201 
 
6202 
class markOrderAsOutOfStock_result:
6203 
  """
6204 
  Attributes:
6205 
   - success
6206 
   - ex
6207 
  """
6208 
 
6209 
  thrift_spec = (
6210 
    (0, TType.BOOL, 'success', None, None, ), # 0
6211 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6212 
  )
6213 
 
6214 
  def __init__(self, success=None, ex=None,):
6215 
    self.success = success
6216 
    self.ex = ex
6217 
 
6218 
  def read(self, iprot):
6219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6221 
      return
6222 
    iprot.readStructBegin()
6223 
    while True:
6224 
      (fname, ftype, fid) = iprot.readFieldBegin()
6225 
      if ftype == TType.STOP:
6226 
        break
6227 
      if fid == 0:
6228 
        if ftype == TType.BOOL:
6229 
          self.success = iprot.readBool();
6230 
        else:
6231 
          iprot.skip(ftype)
6232 
      elif fid == 1:
6233 
        if ftype == TType.STRUCT:
6234 
          self.ex = TransactionServiceException()
6235 
          self.ex.read(iprot)
6236 
        else:
6237 
          iprot.skip(ftype)
6238 
      else:
6239 
        iprot.skip(ftype)
6240 
      iprot.readFieldEnd()
6241 
    iprot.readStructEnd()
6242 
 
6243 
  def write(self, oprot):
6244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6246 
      return
6247 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
6248 
    if self.success != None:
6249 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6250 
      oprot.writeBool(self.success)
6251 
      oprot.writeFieldEnd()
6252 
    if self.ex != None:
6253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6254 
      self.ex.write(oprot)
6255 
      oprot.writeFieldEnd()
6256 
    oprot.writeFieldStop()
6257 
    oprot.writeStructEnd()
6258 
 
6259 
  def __repr__(self):
6260 
    L = ['%s=%r' % (key, value)
6261 
      for key, value in self.__dict__.iteritems()]
6262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6263 
 
6264 
  def __eq__(self, other):
6265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6266 
 
6267 
  def __ne__(self, other):
6268 
    return not (self == other)
6269 
 
759 chandransh 6270 
class markOrdersAsManifested_args:
6271 
  """
6272 
  Attributes:
6273 
   - warehouseId
6274 
   - providerId
6275 
  """
6276 
 
6277 
  thrift_spec = (
6278 
    None, # 0
6279 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
6280 
    (2, TType.I64, 'providerId', None, None, ), # 2
6281 
  )
6282 
 
6283 
  def __init__(self, warehouseId=None, providerId=None,):
6284 
    self.warehouseId = warehouseId
6285 
    self.providerId = providerId
6286 
 
6287 
  def read(self, iprot):
6288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6290 
      return
6291 
    iprot.readStructBegin()
6292 
    while True:
6293 
      (fname, ftype, fid) = iprot.readFieldBegin()
6294 
      if ftype == TType.STOP:
6295 
        break
6296 
      if fid == 1:
6297 
        if ftype == TType.I64:
6298 
          self.warehouseId = iprot.readI64();
6299 
        else:
6300 
          iprot.skip(ftype)
6301 
      elif fid == 2:
6302 
        if ftype == TType.I64:
6303 
          self.providerId = iprot.readI64();
6304 
        else:
6305 
          iprot.skip(ftype)
6306 
      else:
6307 
        iprot.skip(ftype)
6308 
      iprot.readFieldEnd()
6309 
    iprot.readStructEnd()
6310 
 
6311 
  def write(self, oprot):
6312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6314 
      return
6315 
    oprot.writeStructBegin('markOrdersAsManifested_args')
6316 
    if self.warehouseId != None:
6317 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
6318 
      oprot.writeI64(self.warehouseId)
6319 
      oprot.writeFieldEnd()
6320 
    if self.providerId != None:
6321 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
6322 
      oprot.writeI64(self.providerId)
6323 
      oprot.writeFieldEnd()
6324 
    oprot.writeFieldStop()
6325 
    oprot.writeStructEnd()
6326 
 
6327 
  def __repr__(self):
6328 
    L = ['%s=%r' % (key, value)
6329 
      for key, value in self.__dict__.iteritems()]
6330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6331 
 
6332 
  def __eq__(self, other):
6333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6334 
 
6335 
  def __ne__(self, other):
6336 
    return not (self == other)
6337 
 
6338 
class markOrdersAsManifested_result:
6339 
  """
6340 
  Attributes:
6341 
   - success
6342 
   - ex
6343 
  """
6344 
 
6345 
  thrift_spec = (
6346 
    (0, TType.BOOL, 'success', None, None, ), # 0
6347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6348 
  )
6349 
 
6350 
  def __init__(self, success=None, ex=None,):
6351 
    self.success = success
6352 
    self.ex = ex
6353 
 
6354 
  def read(self, iprot):
6355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6357 
      return
6358 
    iprot.readStructBegin()
6359 
    while True:
6360 
      (fname, ftype, fid) = iprot.readFieldBegin()
6361 
      if ftype == TType.STOP:
6362 
        break
6363 
      if fid == 0:
6364 
        if ftype == TType.BOOL:
6365 
          self.success = iprot.readBool();
6366 
        else:
6367 
          iprot.skip(ftype)
6368 
      elif fid == 1:
6369 
        if ftype == TType.STRUCT:
6370 
          self.ex = TransactionServiceException()
6371 
          self.ex.read(iprot)
6372 
        else:
6373 
          iprot.skip(ftype)
6374 
      else:
6375 
        iprot.skip(ftype)
6376 
      iprot.readFieldEnd()
6377 
    iprot.readStructEnd()
6378 
 
6379 
  def write(self, oprot):
6380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6382 
      return
6383 
    oprot.writeStructBegin('markOrdersAsManifested_result')
6384 
    if self.success != None:
6385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6386 
      oprot.writeBool(self.success)
6387 
      oprot.writeFieldEnd()
6388 
    if self.ex != None:
6389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6390 
      self.ex.write(oprot)
6391 
      oprot.writeFieldEnd()
6392 
    oprot.writeFieldStop()
6393 
    oprot.writeStructEnd()
6394 
 
6395 
  def __repr__(self):
6396 
    L = ['%s=%r' % (key, value)
6397 
      for key, value in self.__dict__.iteritems()]
6398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6399 
 
6400 
  def __eq__(self, other):
6401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6402 
 
6403 
  def __ne__(self, other):
6404 
    return not (self == other)
6405 
 
1113 chandransh 6406 
class markOrdersAsPickedUp_args:
6407 
  """
6408 
  Attributes:
6409 
   - providerId
6410 
   - pickupDetails
6411 
  """
6412 
 
6413 
  thrift_spec = (
6414 
    None, # 0
6415 
    (1, TType.I64, 'providerId', None, None, ), # 1
1246 chandransh 6416 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
1113 chandransh 6417 
  )
6418 
 
6419 
  def __init__(self, providerId=None, pickupDetails=None,):
6420 
    self.providerId = providerId
6421 
    self.pickupDetails = pickupDetails
6422 
 
6423 
  def read(self, iprot):
6424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6426 
      return
6427 
    iprot.readStructBegin()
6428 
    while True:
6429 
      (fname, ftype, fid) = iprot.readFieldBegin()
6430 
      if ftype == TType.STOP:
6431 
        break
6432 
      if fid == 1:
6433 
        if ftype == TType.I64:
6434 
          self.providerId = iprot.readI64();
6435 
        else:
6436 
          iprot.skip(ftype)
6437 
      elif fid == 2:
6438 
        if ftype == TType.MAP:
6439 
          self.pickupDetails = {}
1382 varun.gupt 6440 
          (_ktype85, _vtype86, _size84 ) = iprot.readMapBegin()
6441 
          for _i88 in xrange(_size84):
6442 
            _key89 = iprot.readString();
6443 
            _val90 = iprot.readString();
6444 
            self.pickupDetails[_key89] = _val90
1113 chandransh 6445 
          iprot.readMapEnd()
6446 
        else:
6447 
          iprot.skip(ftype)
6448 
      else:
6449 
        iprot.skip(ftype)
6450 
      iprot.readFieldEnd()
6451 
    iprot.readStructEnd()
6452 
 
6453 
  def write(self, oprot):
6454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6456 
      return
6457 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
6458 
    if self.providerId != None:
6459 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6460 
      oprot.writeI64(self.providerId)
6461 
      oprot.writeFieldEnd()
6462 
    if self.pickupDetails != None:
6463 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
1246 chandransh 6464 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
1382 varun.gupt 6465 
      for kiter91,viter92 in self.pickupDetails.items():
6466 
        oprot.writeString(kiter91)
6467 
        oprot.writeString(viter92)
1113 chandransh 6468 
      oprot.writeMapEnd()
6469 
      oprot.writeFieldEnd()
6470 
    oprot.writeFieldStop()
6471 
    oprot.writeStructEnd()
6472 
 
6473 
  def __repr__(self):
6474 
    L = ['%s=%r' % (key, value)
6475 
      for key, value in self.__dict__.iteritems()]
6476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6477 
 
6478 
  def __eq__(self, other):
6479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6480 
 
6481 
  def __ne__(self, other):
6482 
    return not (self == other)
6483 
 
6484 
class markOrdersAsPickedUp_result:
6485 
  """
6486 
  Attributes:
6487 
   - success
6488 
   - ex
6489 
  """
6490 
 
6491 
  thrift_spec = (
6492 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
6493 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6494 
  )
6495 
 
6496 
  def __init__(self, success=None, ex=None,):
6497 
    self.success = success
6498 
    self.ex = ex
6499 
 
6500 
  def read(self, iprot):
6501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6503 
      return
6504 
    iprot.readStructBegin()
6505 
    while True:
6506 
      (fname, ftype, fid) = iprot.readFieldBegin()
6507 
      if ftype == TType.STOP:
6508 
        break
6509 
      if fid == 0:
6510 
        if ftype == TType.LIST:
6511 
          self.success = []
1382 varun.gupt 6512 
          (_etype96, _size93) = iprot.readListBegin()
6513 
          for _i97 in xrange(_size93):
6514 
            _elem98 = Order()
6515 
            _elem98.read(iprot)
6516 
            self.success.append(_elem98)
1113 chandransh 6517 
          iprot.readListEnd()
6518 
        else:
6519 
          iprot.skip(ftype)
6520 
      elif fid == 1:
6521 
        if ftype == TType.STRUCT:
6522 
          self.ex = TransactionServiceException()
6523 
          self.ex.read(iprot)
6524 
        else:
6525 
          iprot.skip(ftype)
6526 
      else:
6527 
        iprot.skip(ftype)
6528 
      iprot.readFieldEnd()
6529 
    iprot.readStructEnd()
6530 
 
6531 
  def write(self, oprot):
6532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6534 
      return
6535 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
6536 
    if self.success != None:
6537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1382 varun.gupt 6539 
      for iter99 in self.success:
6540 
        iter99.write(oprot)
1113 chandransh 6541 
      oprot.writeListEnd()
6542 
      oprot.writeFieldEnd()
6543 
    if self.ex != None:
6544 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6545 
      self.ex.write(oprot)
6546 
      oprot.writeFieldEnd()
6547 
    oprot.writeFieldStop()
6548 
    oprot.writeStructEnd()
6549 
 
6550 
  def __repr__(self):
6551 
    L = ['%s=%r' % (key, value)
6552 
      for key, value in self.__dict__.iteritems()]
6553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6554 
 
6555 
  def __eq__(self, other):
6556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6557 
 
6558 
  def __ne__(self, other):
6559 
    return not (self == other)
6560 
 
1132 chandransh 6561 
class markOrdersAsDelivered_args:
6562 
  """
6563 
  Attributes:
6564 
   - providerId
6565 
   - deliveredOrders
6566 
  """
6567 
 
6568 
  thrift_spec = (
6569 
    None, # 0
6570 
    (1, TType.I64, 'providerId', None, None, ), # 1
6571 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6572 
  )
6573 
 
6574 
  def __init__(self, providerId=None, deliveredOrders=None,):
6575 
    self.providerId = providerId
6576 
    self.deliveredOrders = deliveredOrders
6577 
 
6578 
  def read(self, iprot):
6579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6581 
      return
6582 
    iprot.readStructBegin()
6583 
    while True:
6584 
      (fname, ftype, fid) = iprot.readFieldBegin()
6585 
      if ftype == TType.STOP:
6586 
        break
6587 
      if fid == 1:
6588 
        if ftype == TType.I64:
6589 
          self.providerId = iprot.readI64();
6590 
        else:
6591 
          iprot.skip(ftype)
6592 
      elif fid == 2:
6593 
        if ftype == TType.MAP:
6594 
          self.deliveredOrders = {}
1382 varun.gupt 6595 
          (_ktype101, _vtype102, _size100 ) = iprot.readMapBegin()
6596 
          for _i104 in xrange(_size100):
6597 
            _key105 = iprot.readString();
6598 
            _val106 = iprot.readString();
6599 
            self.deliveredOrders[_key105] = _val106
1132 chandransh 6600 
          iprot.readMapEnd()
6601 
        else:
6602 
          iprot.skip(ftype)
6603 
      else:
6604 
        iprot.skip(ftype)
6605 
      iprot.readFieldEnd()
6606 
    iprot.readStructEnd()
6607 
 
6608 
  def write(self, oprot):
6609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6611 
      return
6612 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
6613 
    if self.providerId != None:
6614 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6615 
      oprot.writeI64(self.providerId)
6616 
      oprot.writeFieldEnd()
6617 
    if self.deliveredOrders != None:
6618 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
6619 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
1382 varun.gupt 6620 
      for kiter107,viter108 in self.deliveredOrders.items():
6621 
        oprot.writeString(kiter107)
6622 
        oprot.writeString(viter108)
1132 chandransh 6623 
      oprot.writeMapEnd()
6624 
      oprot.writeFieldEnd()
6625 
    oprot.writeFieldStop()
6626 
    oprot.writeStructEnd()
6627 
 
6628 
  def __repr__(self):
6629 
    L = ['%s=%r' % (key, value)
6630 
      for key, value in self.__dict__.iteritems()]
6631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6632 
 
6633 
  def __eq__(self, other):
6634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6635 
 
6636 
  def __ne__(self, other):
6637 
    return not (self == other)
6638 
 
6639 
class markOrdersAsDelivered_result:
6640 
  """
6641 
  Attributes:
6642 
   - ex
6643 
  """
6644 
 
6645 
  thrift_spec = (
6646 
    None, # 0
6647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6648 
  )
6649 
 
6650 
  def __init__(self, ex=None,):
6651 
    self.ex = ex
6652 
 
6653 
  def read(self, iprot):
6654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6656 
      return
6657 
    iprot.readStructBegin()
6658 
    while True:
6659 
      (fname, ftype, fid) = iprot.readFieldBegin()
6660 
      if ftype == TType.STOP:
6661 
        break
6662 
      if fid == 1:
6663 
        if ftype == TType.STRUCT:
6664 
          self.ex = TransactionServiceException()
6665 
          self.ex.read(iprot)
6666 
        else:
6667 
          iprot.skip(ftype)
6668 
      else:
6669 
        iprot.skip(ftype)
6670 
      iprot.readFieldEnd()
6671 
    iprot.readStructEnd()
6672 
 
6673 
  def write(self, oprot):
6674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6676 
      return
6677 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
6678 
    if self.ex != None:
6679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6680 
      self.ex.write(oprot)
6681 
      oprot.writeFieldEnd()
6682 
    oprot.writeFieldStop()
6683 
    oprot.writeStructEnd()
6684 
 
6685 
  def __repr__(self):
6686 
    L = ['%s=%r' % (key, value)
6687 
      for key, value in self.__dict__.iteritems()]
6688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6689 
 
6690 
  def __eq__(self, other):
6691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6692 
 
6693 
  def __ne__(self, other):
6694 
    return not (self == other)
6695 
 
1135 chandransh 6696 
class markOrdersAsFailed_args:
6697 
  """
6698 
  Attributes:
6699 
   - providerId
6700 
   - returnedOrders
6701 
  """
6702 
 
6703 
  thrift_spec = (
6704 
    None, # 0
6705 
    (1, TType.I64, 'providerId', None, None, ), # 1
6706 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6707 
  )
6708 
 
6709 
  def __init__(self, providerId=None, returnedOrders=None,):
6710 
    self.providerId = providerId
6711 
    self.returnedOrders = returnedOrders
6712 
 
6713 
  def read(self, iprot):
6714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6716 
      return
6717 
    iprot.readStructBegin()
6718 
    while True:
6719 
      (fname, ftype, fid) = iprot.readFieldBegin()
6720 
      if ftype == TType.STOP:
6721 
        break
6722 
      if fid == 1:
6723 
        if ftype == TType.I64:
6724 
          self.providerId = iprot.readI64();
6725 
        else:
6726 
          iprot.skip(ftype)
6727 
      elif fid == 2:
6728 
        if ftype == TType.MAP:
6729 
          self.returnedOrders = {}
1382 varun.gupt 6730 
          (_ktype110, _vtype111, _size109 ) = iprot.readMapBegin()
6731 
          for _i113 in xrange(_size109):
6732 
            _key114 = iprot.readString();
6733 
            _val115 = iprot.readString();
6734 
            self.returnedOrders[_key114] = _val115
1135 chandransh 6735 
          iprot.readMapEnd()
6736 
        else:
6737 
          iprot.skip(ftype)
6738 
      else:
6739 
        iprot.skip(ftype)
6740 
      iprot.readFieldEnd()
6741 
    iprot.readStructEnd()
6742 
 
6743 
  def write(self, oprot):
6744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6746 
      return
6747 
    oprot.writeStructBegin('markOrdersAsFailed_args')
6748 
    if self.providerId != None:
6749 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6750 
      oprot.writeI64(self.providerId)
6751 
      oprot.writeFieldEnd()
6752 
    if self.returnedOrders != None:
6753 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
6754 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
1382 varun.gupt 6755 
      for kiter116,viter117 in self.returnedOrders.items():
6756 
        oprot.writeString(kiter116)
6757 
        oprot.writeString(viter117)
1135 chandransh 6758 
      oprot.writeMapEnd()
6759 
      oprot.writeFieldEnd()
6760 
    oprot.writeFieldStop()
6761 
    oprot.writeStructEnd()
6762 
 
6763 
  def __repr__(self):
6764 
    L = ['%s=%r' % (key, value)
6765 
      for key, value in self.__dict__.iteritems()]
6766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6767 
 
6768 
  def __eq__(self, other):
6769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6770 
 
6771 
  def __ne__(self, other):
6772 
    return not (self == other)
6773 
 
6774 
class markOrdersAsFailed_result:
6775 
  """
6776 
  Attributes:
6777 
   - ex
6778 
  """
6779 
 
6780 
  thrift_spec = (
6781 
    None, # 0
6782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6783 
  )
6784 
 
6785 
  def __init__(self, ex=None,):
6786 
    self.ex = ex
6787 
 
6788 
  def read(self, iprot):
6789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6791 
      return
6792 
    iprot.readStructBegin()
6793 
    while True:
6794 
      (fname, ftype, fid) = iprot.readFieldBegin()
6795 
      if ftype == TType.STOP:
6796 
        break
6797 
      if fid == 1:
6798 
        if ftype == TType.STRUCT:
6799 
          self.ex = TransactionServiceException()
6800 
          self.ex.read(iprot)
6801 
        else:
6802 
          iprot.skip(ftype)
6803 
      else:
6804 
        iprot.skip(ftype)
6805 
      iprot.readFieldEnd()
6806 
    iprot.readStructEnd()
6807 
 
6808 
  def write(self, oprot):
6809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6811 
      return
6812 
    oprot.writeStructBegin('markOrdersAsFailed_result')
6813 
    if self.ex != None:
6814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6815 
      self.ex.write(oprot)
6816 
      oprot.writeFieldEnd()
6817 
    oprot.writeFieldStop()
6818 
    oprot.writeStructEnd()
6819 
 
6820 
  def __repr__(self):
6821 
    L = ['%s=%r' % (key, value)
6822 
      for key, value in self.__dict__.iteritems()]
6823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6824 
 
6825 
  def __eq__(self, other):
6826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6827 
 
6828 
  def __ne__(self, other):
6829 
    return not (self == other)
6830 
 
1246 chandransh 6831 
class updateNonDeliveryReason_args:
6832 
  """
6833 
  Attributes:
6834 
   - providerId
6835 
   - undeliveredOrders
6836 
  """
6837 
 
6838 
  thrift_spec = (
6839 
    None, # 0
6840 
    (1, TType.I64, 'providerId', None, None, ), # 1
6841 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
6842 
  )
6843 
 
6844 
  def __init__(self, providerId=None, undeliveredOrders=None,):
6845 
    self.providerId = providerId
6846 
    self.undeliveredOrders = undeliveredOrders
6847 
 
6848 
  def read(self, iprot):
6849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6851 
      return
6852 
    iprot.readStructBegin()
6853 
    while True:
6854 
      (fname, ftype, fid) = iprot.readFieldBegin()
6855 
      if ftype == TType.STOP:
6856 
        break
6857 
      if fid == 1:
6858 
        if ftype == TType.I64:
6859 
          self.providerId = iprot.readI64();
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      elif fid == 2:
6863 
        if ftype == TType.MAP:
6864 
          self.undeliveredOrders = {}
1382 varun.gupt 6865 
          (_ktype119, _vtype120, _size118 ) = iprot.readMapBegin()
6866 
          for _i122 in xrange(_size118):
6867 
            _key123 = iprot.readString();
6868 
            _val124 = iprot.readString();
6869 
            self.undeliveredOrders[_key123] = _val124
1246 chandransh 6870 
          iprot.readMapEnd()
6871 
        else:
6872 
          iprot.skip(ftype)
6873 
      else:
6874 
        iprot.skip(ftype)
6875 
      iprot.readFieldEnd()
6876 
    iprot.readStructEnd()
6877 
 
6878 
  def write(self, oprot):
6879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6881 
      return
6882 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
6883 
    if self.providerId != None:
6884 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
6885 
      oprot.writeI64(self.providerId)
6886 
      oprot.writeFieldEnd()
6887 
    if self.undeliveredOrders != None:
6888 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
6889 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
1382 varun.gupt 6890 
      for kiter125,viter126 in self.undeliveredOrders.items():
6891 
        oprot.writeString(kiter125)
6892 
        oprot.writeString(viter126)
1246 chandransh 6893 
      oprot.writeMapEnd()
6894 
      oprot.writeFieldEnd()
6895 
    oprot.writeFieldStop()
6896 
    oprot.writeStructEnd()
6897 
 
6898 
  def __repr__(self):
6899 
    L = ['%s=%r' % (key, value)
6900 
      for key, value in self.__dict__.iteritems()]
6901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6902 
 
6903 
  def __eq__(self, other):
6904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6905 
 
6906 
  def __ne__(self, other):
6907 
    return not (self == other)
6908 
 
6909 
class updateNonDeliveryReason_result:
6910 
  """
6911 
  Attributes:
6912 
   - ex
6913 
  """
6914 
 
6915 
  thrift_spec = (
6916 
    None, # 0
6917 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
6918 
  )
6919 
 
6920 
  def __init__(self, ex=None,):
6921 
    self.ex = ex
6922 
 
6923 
  def read(self, iprot):
6924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6926 
      return
6927 
    iprot.readStructBegin()
6928 
    while True:
6929 
      (fname, ftype, fid) = iprot.readFieldBegin()
6930 
      if ftype == TType.STOP:
6931 
        break
6932 
      if fid == 1:
6933 
        if ftype == TType.STRUCT:
6934 
          self.ex = TransactionServiceException()
6935 
          self.ex.read(iprot)
6936 
        else:
6937 
          iprot.skip(ftype)
6938 
      else:
6939 
        iprot.skip(ftype)
6940 
      iprot.readFieldEnd()
6941 
    iprot.readStructEnd()
6942 
 
6943 
  def write(self, oprot):
6944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6946 
      return
6947 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
6948 
    if self.ex != None:
6949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
6950 
      self.ex.write(oprot)
6951 
      oprot.writeFieldEnd()
6952 
    oprot.writeFieldStop()
6953 
    oprot.writeStructEnd()
6954 
 
6955 
  def __repr__(self):
6956 
    L = ['%s=%r' % (key, value)
6957 
      for key, value in self.__dict__.iteritems()]
6958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6959 
 
6960 
  def __eq__(self, other):
6961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6962 
 
6963 
  def __ne__(self, other):
6964 
    return not (self == other)
6965 
 
1408 ankur.sing 6966 
class getUndeliveredOrders_args:
6967 
  """
6968 
  Attributes:
6969 
   - providerId
6970 
   - warehouseId
6971 
  """
6972 
 
6973 
  thrift_spec = (
6974 
    None, # 0
6975 
    (1, TType.I64, 'providerId', None, None, ), # 1
6976 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
6977 
  )
6978 
 
6979 
  def __init__(self, providerId=None, warehouseId=None,):
6980 
    self.providerId = providerId
6981 
    self.warehouseId = warehouseId
6982 
 
6983 
  def read(self, iprot):
6984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6986 
      return
6987 
    iprot.readStructBegin()
6988 
    while True:
6989 
      (fname, ftype, fid) = iprot.readFieldBegin()
6990 
      if ftype == TType.STOP:
6991 
        break
6992 
      if fid == 1:
6993 
        if ftype == TType.I64:
6994 
          self.providerId = iprot.readI64();
6995 
        else:
6996 
          iprot.skip(ftype)
6997 
      elif fid == 2:
6998 
        if ftype == TType.I64:
6999 
          self.warehouseId = iprot.readI64();
7000 
        else:
7001 
          iprot.skip(ftype)
7002 
      else:
7003 
        iprot.skip(ftype)
7004 
      iprot.readFieldEnd()
7005 
    iprot.readStructEnd()
7006 
 
7007 
  def write(self, oprot):
7008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7010 
      return
7011 
    oprot.writeStructBegin('getUndeliveredOrders_args')
7012 
    if self.providerId != None:
7013 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
7014 
      oprot.writeI64(self.providerId)
7015 
      oprot.writeFieldEnd()
7016 
    if self.warehouseId != None:
7017 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
7018 
      oprot.writeI64(self.warehouseId)
7019 
      oprot.writeFieldEnd()
7020 
    oprot.writeFieldStop()
7021 
    oprot.writeStructEnd()
7022 
 
7023 
  def __repr__(self):
7024 
    L = ['%s=%r' % (key, value)
7025 
      for key, value in self.__dict__.iteritems()]
7026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7027 
 
7028 
  def __eq__(self, other):
7029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7030 
 
7031 
  def __ne__(self, other):
7032 
    return not (self == other)
7033 
 
7034 
class getUndeliveredOrders_result:
7035 
  """
7036 
  Attributes:
7037 
   - success
7038 
  """
7039 
 
7040 
  thrift_spec = (
7041 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7042 
  )
7043 
 
7044 
  def __init__(self, success=None,):
7045 
    self.success = success
7046 
 
7047 
  def read(self, iprot):
7048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7050 
      return
7051 
    iprot.readStructBegin()
7052 
    while True:
7053 
      (fname, ftype, fid) = iprot.readFieldBegin()
7054 
      if ftype == TType.STOP:
7055 
        break
7056 
      if fid == 0:
7057 
        if ftype == TType.LIST:
7058 
          self.success = []
7059 
          (_etype130, _size127) = iprot.readListBegin()
7060 
          for _i131 in xrange(_size127):
7061 
            _elem132 = Order()
7062 
            _elem132.read(iprot)
7063 
            self.success.append(_elem132)
7064 
          iprot.readListEnd()
7065 
        else:
7066 
          iprot.skip(ftype)
7067 
      else:
7068 
        iprot.skip(ftype)
7069 
      iprot.readFieldEnd()
7070 
    iprot.readStructEnd()
7071 
 
7072 
  def write(self, oprot):
7073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7075 
      return
7076 
    oprot.writeStructBegin('getUndeliveredOrders_result')
7077 
    if self.success != None:
7078 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7079 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7080 
      for iter133 in self.success:
7081 
        iter133.write(oprot)
7082 
      oprot.writeListEnd()
7083 
      oprot.writeFieldEnd()
7084 
    oprot.writeFieldStop()
7085 
    oprot.writeStructEnd()
7086 
 
7087 
  def __repr__(self):
7088 
    L = ['%s=%r' % (key, value)
7089 
      for key, value in self.__dict__.iteritems()]
7090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7091 
 
7092 
  def __eq__(self, other):
7093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7094 
 
7095 
  def __ne__(self, other):
7096 
    return not (self == other)
7097 
 
304 ashish 7098 
class getAlerts_args:
7099 
  """
7100 
  Attributes:
483 rajveer 7101 
   - orderId
304 ashish 7102 
   - valid
7103 
  """
94 ashish 7104 
 
304 ashish 7105 
  thrift_spec = (
7106 
    None, # 0
483 rajveer 7107 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 7108 
    (2, TType.BOOL, 'valid', None, None, ), # 2
7109 
  )
7110 
 
483 rajveer 7111 
  def __init__(self, orderId=None, valid=None,):
7112 
    self.orderId = orderId
304 ashish 7113 
    self.valid = valid
7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      if fid == 1:
7125 
        if ftype == TType.I64:
483 rajveer 7126 
          self.orderId = iprot.readI64();
304 ashish 7127 
        else:
7128 
          iprot.skip(ftype)
7129 
      elif fid == 2:
7130 
        if ftype == TType.BOOL:
7131 
          self.valid = iprot.readBool();
7132 
        else:
7133 
          iprot.skip(ftype)
7134 
      else:
7135 
        iprot.skip(ftype)
7136 
      iprot.readFieldEnd()
7137 
    iprot.readStructEnd()
7138 
 
7139 
  def write(self, oprot):
7140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7142 
      return
7143 
    oprot.writeStructBegin('getAlerts_args')
483 rajveer 7144 
    if self.orderId != None:
7145 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7146 
      oprot.writeI64(self.orderId)
304 ashish 7147 
      oprot.writeFieldEnd()
7148 
    if self.valid != None:
7149 
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
7150 
      oprot.writeBool(self.valid)
7151 
      oprot.writeFieldEnd()
7152 
    oprot.writeFieldStop()
7153 
    oprot.writeStructEnd()
7154 
 
7155 
  def __repr__(self):
7156 
    L = ['%s=%r' % (key, value)
7157 
      for key, value in self.__dict__.iteritems()]
7158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7159 
 
7160 
  def __eq__(self, other):
7161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7162 
 
7163 
  def __ne__(self, other):
7164 
    return not (self == other)
7165 
 
7166 
class getAlerts_result:
7167 
  """
7168 
  Attributes:
7169 
   - success
7170 
  """
7171 
 
7172 
  thrift_spec = (
7173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
7174 
  )
7175 
 
7176 
  def __init__(self, success=None,):
7177 
    self.success = success
7178 
 
7179 
  def read(self, iprot):
7180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7182 
      return
7183 
    iprot.readStructBegin()
7184 
    while True:
7185 
      (fname, ftype, fid) = iprot.readFieldBegin()
7186 
      if ftype == TType.STOP:
7187 
        break
7188 
      if fid == 0:
7189 
        if ftype == TType.LIST:
7190 
          self.success = []
1408 ankur.sing 7191 
          (_etype137, _size134) = iprot.readListBegin()
7192 
          for _i138 in xrange(_size134):
7193 
            _elem139 = Alert()
7194 
            _elem139.read(iprot)
7195 
            self.success.append(_elem139)
304 ashish 7196 
          iprot.readListEnd()
7197 
        else:
7198 
          iprot.skip(ftype)
7199 
      else:
7200 
        iprot.skip(ftype)
7201 
      iprot.readFieldEnd()
7202 
    iprot.readStructEnd()
7203 
 
7204 
  def write(self, oprot):
7205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7207 
      return
7208 
    oprot.writeStructBegin('getAlerts_result')
7209 
    if self.success != None:
7210 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7211 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1408 ankur.sing 7212 
      for iter140 in self.success:
7213 
        iter140.write(oprot)
304 ashish 7214 
      oprot.writeListEnd()
7215 
      oprot.writeFieldEnd()
7216 
    oprot.writeFieldStop()
7217 
    oprot.writeStructEnd()
7218 
 
7219 
  def __repr__(self):
7220 
    L = ['%s=%r' % (key, value)
7221 
      for key, value in self.__dict__.iteritems()]
7222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7223 
 
7224 
  def __eq__(self, other):
7225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7226 
 
7227 
  def __ne__(self, other):
7228 
    return not (self == other)
7229 
 
7230 
class setAlert_args:
7231 
  """
7232 
  Attributes:
483 rajveer 7233 
   - orderId
304 ashish 7234 
   - unset
7235 
   - type
7236 
   - comment
7237 
  """
7238 
 
7239 
  thrift_spec = (
7240 
    None, # 0
483 rajveer 7241 
    (1, TType.I64, 'orderId', None, None, ), # 1
304 ashish 7242 
    (2, TType.BOOL, 'unset', None, None, ), # 2
7243 
    (3, TType.I64, 'type', None, None, ), # 3
7244 
    (4, TType.STRING, 'comment', None, None, ), # 4
7245 
  )
7246 
 
483 rajveer 7247 
  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
7248 
    self.orderId = orderId
304 ashish 7249 
    self.unset = unset
7250 
    self.type = type
7251 
    self.comment = comment
7252 
 
7253 
  def read(self, iprot):
7254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7256 
      return
7257 
    iprot.readStructBegin()
7258 
    while True:
7259 
      (fname, ftype, fid) = iprot.readFieldBegin()
7260 
      if ftype == TType.STOP:
7261 
        break
7262 
      if fid == 1:
7263 
        if ftype == TType.I64:
483 rajveer 7264 
          self.orderId = iprot.readI64();
304 ashish 7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 2:
7268 
        if ftype == TType.BOOL:
7269 
          self.unset = iprot.readBool();
7270 
        else:
7271 
          iprot.skip(ftype)
7272 
      elif fid == 3:
7273 
        if ftype == TType.I64:
7274 
          self.type = iprot.readI64();
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      elif fid == 4:
7278 
        if ftype == TType.STRING:
7279 
          self.comment = iprot.readString();
7280 
        else:
7281 
          iprot.skip(ftype)
7282 
      else:
7283 
        iprot.skip(ftype)
7284 
      iprot.readFieldEnd()
7285 
    iprot.readStructEnd()
7286 
 
7287 
  def write(self, oprot):
7288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7290 
      return
7291 
    oprot.writeStructBegin('setAlert_args')
483 rajveer 7292 
    if self.orderId != None:
7293 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7294 
      oprot.writeI64(self.orderId)
304 ashish 7295 
      oprot.writeFieldEnd()
7296 
    if self.unset != None:
7297 
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
7298 
      oprot.writeBool(self.unset)
7299 
      oprot.writeFieldEnd()
7300 
    if self.type != None:
7301 
      oprot.writeFieldBegin('type', TType.I64, 3)
7302 
      oprot.writeI64(self.type)
7303 
      oprot.writeFieldEnd()
7304 
    if self.comment != None:
7305 
      oprot.writeFieldBegin('comment', TType.STRING, 4)
7306 
      oprot.writeString(self.comment)
7307 
      oprot.writeFieldEnd()
7308 
    oprot.writeFieldStop()
7309 
    oprot.writeStructEnd()
7310 
 
7311 
  def __repr__(self):
7312 
    L = ['%s=%r' % (key, value)
7313 
      for key, value in self.__dict__.iteritems()]
7314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7315 
 
7316 
  def __eq__(self, other):
7317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7318 
 
7319 
  def __ne__(self, other):
7320 
    return not (self == other)
7321 
 
7322 
class setAlert_result:
7323 
 
7324 
  thrift_spec = (
7325 
  )
7326 
 
7327 
  def read(self, iprot):
7328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7330 
      return
7331 
    iprot.readStructBegin()
7332 
    while True:
7333 
      (fname, ftype, fid) = iprot.readFieldBegin()
7334 
      if ftype == TType.STOP:
7335 
        break
7336 
      else:
7337 
        iprot.skip(ftype)
7338 
      iprot.readFieldEnd()
7339 
    iprot.readStructEnd()
7340 
 
7341 
  def write(self, oprot):
7342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7344 
      return
7345 
    oprot.writeStructBegin('setAlert_result')
7346 
    oprot.writeFieldStop()
7347 
    oprot.writeStructEnd()
7348 
 
7349 
  def __repr__(self):
7350 
    L = ['%s=%r' % (key, value)
7351 
      for key, value in self.__dict__.iteritems()]
7352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7353 
 
7354 
  def __eq__(self, other):
7355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7356 
 
7357 
  def __ne__(self, other):
7358 
    return not (self == other)
7359 
 
1596 ankur.sing 7360 
class getValidOrderCount_args:
304 ashish 7361 
 
1596 ankur.sing 7362 
  thrift_spec = (
7363 
  )
7364 
 
7365 
  def read(self, iprot):
7366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7368 
      return
7369 
    iprot.readStructBegin()
7370 
    while True:
7371 
      (fname, ftype, fid) = iprot.readFieldBegin()
7372 
      if ftype == TType.STOP:
7373 
        break
7374 
      else:
7375 
        iprot.skip(ftype)
7376 
      iprot.readFieldEnd()
7377 
    iprot.readStructEnd()
7378 
 
7379 
  def write(self, oprot):
7380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7382 
      return
7383 
    oprot.writeStructBegin('getValidOrderCount_args')
7384 
    oprot.writeFieldStop()
7385 
    oprot.writeStructEnd()
7386 
 
7387 
  def __repr__(self):
7388 
    L = ['%s=%r' % (key, value)
7389 
      for key, value in self.__dict__.iteritems()]
7390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7391 
 
7392 
  def __eq__(self, other):
7393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7394 
 
7395 
  def __ne__(self, other):
7396 
    return not (self == other)
7397 
 
7398 
class getValidOrderCount_result:
7399 
  """
7400 
  Attributes:
7401 
   - success
7402 
  """
7403 
 
7404 
  thrift_spec = (
7405 
    (0, TType.I64, 'success', None, None, ), # 0
7406 
  )
7407 
 
7408 
  def __init__(self, success=None,):
7409 
    self.success = success
7410 
 
7411 
  def read(self, iprot):
7412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7414 
      return
7415 
    iprot.readStructBegin()
7416 
    while True:
7417 
      (fname, ftype, fid) = iprot.readFieldBegin()
7418 
      if ftype == TType.STOP:
7419 
        break
7420 
      if fid == 0:
7421 
        if ftype == TType.I64:
7422 
          self.success = iprot.readI64();
7423 
        else:
7424 
          iprot.skip(ftype)
7425 
      else:
7426 
        iprot.skip(ftype)
7427 
      iprot.readFieldEnd()
7428 
    iprot.readStructEnd()
7429 
 
7430 
  def write(self, oprot):
7431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7433 
      return
7434 
    oprot.writeStructBegin('getValidOrderCount_result')
7435 
    if self.success != None:
7436 
      oprot.writeFieldBegin('success', TType.I64, 0)
7437 
      oprot.writeI64(self.success)
7438 
      oprot.writeFieldEnd()
7439 
    oprot.writeFieldStop()
7440 
    oprot.writeStructEnd()
7441 
 
7442 
  def __repr__(self):
7443 
    L = ['%s=%r' % (key, value)
7444 
      for key, value in self.__dict__.iteritems()]
7445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7446 
 
7447 
  def __eq__(self, other):
7448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7449 
 
7450 
  def __ne__(self, other):
7451 
    return not (self == other)
7452 
 
1627 ankur.sing 7453 
class getNoOfCustomersWithSuccessfulTransaction_args:
1596 ankur.sing 7454 
 
1627 ankur.sing 7455 
  thrift_spec = (
7456 
  )
7457 
 
7458 
  def read(self, iprot):
7459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7461 
      return
7462 
    iprot.readStructBegin()
7463 
    while True:
7464 
      (fname, ftype, fid) = iprot.readFieldBegin()
7465 
      if ftype == TType.STOP:
7466 
        break
7467 
      else:
7468 
        iprot.skip(ftype)
7469 
      iprot.readFieldEnd()
7470 
    iprot.readStructEnd()
7471 
 
7472 
  def write(self, oprot):
7473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7475 
      return
7476 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
7477 
    oprot.writeFieldStop()
7478 
    oprot.writeStructEnd()
7479 
 
7480 
  def __repr__(self):
7481 
    L = ['%s=%r' % (key, value)
7482 
      for key, value in self.__dict__.iteritems()]
7483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7484 
 
7485 
  def __eq__(self, other):
7486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7487 
 
7488 
  def __ne__(self, other):
7489 
    return not (self == other)
7490 
 
7491 
class getNoOfCustomersWithSuccessfulTransaction_result:
7492 
  """
7493 
  Attributes:
7494 
   - success
7495 
  """
7496 
 
7497 
  thrift_spec = (
7498 
    (0, TType.I64, 'success', None, None, ), # 0
7499 
  )
7500 
 
7501 
  def __init__(self, success=None,):
7502 
    self.success = success
7503 
 
7504 
  def read(self, iprot):
7505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7507 
      return
7508 
    iprot.readStructBegin()
7509 
    while True:
7510 
      (fname, ftype, fid) = iprot.readFieldBegin()
7511 
      if ftype == TType.STOP:
7512 
        break
7513 
      if fid == 0:
7514 
        if ftype == TType.I64:
7515 
          self.success = iprot.readI64();
7516 
        else:
7517 
          iprot.skip(ftype)
7518 
      else:
7519 
        iprot.skip(ftype)
7520 
      iprot.readFieldEnd()
7521 
    iprot.readStructEnd()
7522 
 
7523 
  def write(self, oprot):
7524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7526 
      return
7527 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
7528 
    if self.success != None:
7529 
      oprot.writeFieldBegin('success', TType.I64, 0)
7530 
      oprot.writeI64(self.success)
7531 
      oprot.writeFieldEnd()
7532 
    oprot.writeFieldStop()
7533 
    oprot.writeStructEnd()
7534 
 
7535 
  def __repr__(self):
7536 
    L = ['%s=%r' % (key, value)
7537 
      for key, value in self.__dict__.iteritems()]
7538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7539 
 
7540 
  def __eq__(self, other):
7541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7542 
 
7543 
  def __ne__(self, other):
7544 
    return not (self == other)
7545 
 
1731 ankur.sing 7546 
class getValidOrdersAmountRange_args:
1627 ankur.sing 7547 
 
7548 
  thrift_spec = (
7549 
  )
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      else:
7561 
        iprot.skip(ftype)
7562 
      iprot.readFieldEnd()
7563 
    iprot.readStructEnd()
7564 
 
7565 
  def write(self, oprot):
7566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7568 
      return
1731 ankur.sing 7569 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
1627 ankur.sing 7570 
    oprot.writeFieldStop()
7571 
    oprot.writeStructEnd()
7572 
 
7573 
  def __repr__(self):
7574 
    L = ['%s=%r' % (key, value)
7575 
      for key, value in self.__dict__.iteritems()]
7576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7577 
 
7578 
  def __eq__(self, other):
7579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7580 
 
7581 
  def __ne__(self, other):
7582 
    return not (self == other)
7583 
 
1731 ankur.sing 7584 
class getValidOrdersAmountRange_result:
1627 ankur.sing 7585 
  """
7586 
  Attributes:
7587 
   - success
7588 
  """
7589 
 
7590 
  thrift_spec = (
1731 ankur.sing 7591 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
1627 ankur.sing 7592 
  )
7593 
 
7594 
  def __init__(self, success=None,):
7595 
    self.success = success
7596 
 
7597 
  def read(self, iprot):
7598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7600 
      return
7601 
    iprot.readStructBegin()
7602 
    while True:
7603 
      (fname, ftype, fid) = iprot.readFieldBegin()
7604 
      if ftype == TType.STOP:
7605 
        break
7606 
      if fid == 0:
1731 ankur.sing 7607 
        if ftype == TType.LIST:
7608 
          self.success = []
7609 
          (_etype144, _size141) = iprot.readListBegin()
7610 
          for _i145 in xrange(_size141):
7611 
            _elem146 = iprot.readDouble();
7612 
            self.success.append(_elem146)
7613 
          iprot.readListEnd()
1627 ankur.sing 7614 
        else:
7615 
          iprot.skip(ftype)
7616 
      else:
7617 
        iprot.skip(ftype)
7618 
      iprot.readFieldEnd()
7619 
    iprot.readStructEnd()
7620 
 
7621 
  def write(self, oprot):
7622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7624 
      return
1731 ankur.sing 7625 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
1627 ankur.sing 7626 
    if self.success != None:
1731 ankur.sing 7627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7628 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
7629 
      for iter147 in self.success:
7630 
        oprot.writeDouble(iter147)
7631 
      oprot.writeListEnd()
1627 ankur.sing 7632 
      oprot.writeFieldEnd()
7633 
    oprot.writeFieldStop()
7634 
    oprot.writeStructEnd()
7635 
 
7636 
  def __repr__(self):
7637 
    L = ['%s=%r' % (key, value)
7638 
      for key, value in self.__dict__.iteritems()]
7639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7640 
 
7641 
  def __eq__(self, other):
7642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7643 
 
7644 
  def __ne__(self, other):
7645 
    return not (self == other)
7646 
 
1886 ankur.sing 7647 
class getValidOrders_args:
7648 
  """
7649 
  Attributes:
7650 
   - limit
7651 
  """
1627 ankur.sing 7652 
 
1886 ankur.sing 7653 
  thrift_spec = (
7654 
    None, # 0
7655 
    (1, TType.I64, 'limit', None, None, ), # 1
7656 
  )
7657 
 
7658 
  def __init__(self, limit=None,):
7659 
    self.limit = limit
7660 
 
7661 
  def read(self, iprot):
7662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7664 
      return
7665 
    iprot.readStructBegin()
7666 
    while True:
7667 
      (fname, ftype, fid) = iprot.readFieldBegin()
7668 
      if ftype == TType.STOP:
7669 
        break
7670 
      if fid == 1:
7671 
        if ftype == TType.I64:
7672 
          self.limit = iprot.readI64();
7673 
        else:
7674 
          iprot.skip(ftype)
7675 
      else:
7676 
        iprot.skip(ftype)
7677 
      iprot.readFieldEnd()
7678 
    iprot.readStructEnd()
7679 
 
7680 
  def write(self, oprot):
7681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7683 
      return
7684 
    oprot.writeStructBegin('getValidOrders_args')
7685 
    if self.limit != None:
7686 
      oprot.writeFieldBegin('limit', TType.I64, 1)
7687 
      oprot.writeI64(self.limit)
7688 
      oprot.writeFieldEnd()
7689 
    oprot.writeFieldStop()
7690 
    oprot.writeStructEnd()
7691 
 
7692 
  def __repr__(self):
7693 
    L = ['%s=%r' % (key, value)
7694 
      for key, value in self.__dict__.iteritems()]
7695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7696 
 
7697 
  def __eq__(self, other):
7698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7699 
 
7700 
  def __ne__(self, other):
7701 
    return not (self == other)
7702 
 
7703 
class getValidOrders_result:
7704 
  """
7705 
  Attributes:
7706 
   - success
7707 
  """
7708 
 
7709 
  thrift_spec = (
7710 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
7711 
  )
7712 
 
7713 
  def __init__(self, success=None,):
7714 
    self.success = success
7715 
 
7716 
  def read(self, iprot):
7717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7719 
      return
7720 
    iprot.readStructBegin()
7721 
    while True:
7722 
      (fname, ftype, fid) = iprot.readFieldBegin()
7723 
      if ftype == TType.STOP:
7724 
        break
7725 
      if fid == 0:
7726 
        if ftype == TType.LIST:
7727 
          self.success = []
7728 
          (_etype151, _size148) = iprot.readListBegin()
7729 
          for _i152 in xrange(_size148):
7730 
            _elem153 = Order()
7731 
            _elem153.read(iprot)
7732 
            self.success.append(_elem153)
7733 
          iprot.readListEnd()
7734 
        else:
7735 
          iprot.skip(ftype)
7736 
      else:
7737 
        iprot.skip(ftype)
7738 
      iprot.readFieldEnd()
7739 
    iprot.readStructEnd()
7740 
 
7741 
  def write(self, oprot):
7742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7744 
      return
7745 
    oprot.writeStructBegin('getValidOrders_result')
7746 
    if self.success != None:
7747 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7748 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7749 
      for iter154 in self.success:
7750 
        iter154.write(oprot)
7751 
      oprot.writeListEnd()
7752 
      oprot.writeFieldEnd()
7753 
    oprot.writeFieldStop()
7754 
    oprot.writeStructEnd()
7755 
 
7756 
  def __repr__(self):
7757 
    L = ['%s=%r' % (key, value)
7758 
      for key, value in self.__dict__.iteritems()]
7759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7760 
 
7761 
  def __eq__(self, other):
7762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7763 
 
7764 
  def __ne__(self, other):
7765 
    return not (self == other)
7766 
 
2536 chandransh 7767 
class toggleDOAFlag_args:
7768 
  """
7769 
  Attributes:
7770 
   - orderId
7771 
  """
1886 ankur.sing 7772 
 
2536 chandransh 7773 
  thrift_spec = (
7774 
    None, # 0
7775 
    (1, TType.I64, 'orderId', None, None, ), # 1
7776 
  )
7777 
 
7778 
  def __init__(self, orderId=None,):
7779 
    self.orderId = orderId
7780 
 
7781 
  def read(self, iprot):
7782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7784 
      return
7785 
    iprot.readStructBegin()
7786 
    while True:
7787 
      (fname, ftype, fid) = iprot.readFieldBegin()
7788 
      if ftype == TType.STOP:
7789 
        break
7790 
      if fid == 1:
7791 
        if ftype == TType.I64:
7792 
          self.orderId = iprot.readI64();
7793 
        else:
7794 
          iprot.skip(ftype)
7795 
      else:
7796 
        iprot.skip(ftype)
7797 
      iprot.readFieldEnd()
7798 
    iprot.readStructEnd()
7799 
 
7800 
  def write(self, oprot):
7801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7803 
      return
7804 
    oprot.writeStructBegin('toggleDOAFlag_args')
7805 
    if self.orderId != None:
7806 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7807 
      oprot.writeI64(self.orderId)
7808 
      oprot.writeFieldEnd()
7809 
    oprot.writeFieldStop()
7810 
    oprot.writeStructEnd()
7811 
 
7812 
  def __repr__(self):
7813 
    L = ['%s=%r' % (key, value)
7814 
      for key, value in self.__dict__.iteritems()]
7815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7816 
 
7817 
  def __eq__(self, other):
7818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7819 
 
7820 
  def __ne__(self, other):
7821 
    return not (self == other)
7822 
 
7823 
class toggleDOAFlag_result:
7824 
  """
7825 
  Attributes:
7826 
   - success
7827 
   - ex
7828 
  """
7829 
 
7830 
  thrift_spec = (
7831 
    (0, TType.BOOL, 'success', None, None, ), # 0
7832 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7833 
  )
7834 
 
7835 
  def __init__(self, success=None, ex=None,):
7836 
    self.success = success
7837 
    self.ex = ex
7838 
 
7839 
  def read(self, iprot):
7840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7842 
      return
7843 
    iprot.readStructBegin()
7844 
    while True:
7845 
      (fname, ftype, fid) = iprot.readFieldBegin()
7846 
      if ftype == TType.STOP:
7847 
        break
7848 
      if fid == 0:
7849 
        if ftype == TType.BOOL:
7850 
          self.success = iprot.readBool();
7851 
        else:
7852 
          iprot.skip(ftype)
7853 
      elif fid == 1:
7854 
        if ftype == TType.STRUCT:
7855 
          self.ex = TransactionServiceException()
7856 
          self.ex.read(iprot)
7857 
        else:
7858 
          iprot.skip(ftype)
7859 
      else:
7860 
        iprot.skip(ftype)
7861 
      iprot.readFieldEnd()
7862 
    iprot.readStructEnd()
7863 
 
7864 
  def write(self, oprot):
7865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7867 
      return
7868 
    oprot.writeStructBegin('toggleDOAFlag_result')
7869 
    if self.success != None:
7870 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7871 
      oprot.writeBool(self.success)
7872 
      oprot.writeFieldEnd()
7873 
    if self.ex != None:
7874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7875 
      self.ex.write(oprot)
7876 
      oprot.writeFieldEnd()
7877 
    oprot.writeFieldStop()
7878 
    oprot.writeStructEnd()
7879 
 
7880 
  def __repr__(self):
7881 
    L = ['%s=%r' % (key, value)
7882 
      for key, value in self.__dict__.iteritems()]
7883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7884 
 
7885 
  def __eq__(self, other):
7886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7887 
 
7888 
  def __ne__(self, other):
7889 
    return not (self == other)
7890 
 
7891 
class requestPickupNumber_args:
7892 
  """
7893 
  Attributes:
7894 
   - orderId
7895 
  """
7896 
 
7897 
  thrift_spec = (
7898 
    None, # 0
7899 
    (1, TType.I64, 'orderId', None, None, ), # 1
7900 
  )
7901 
 
7902 
  def __init__(self, orderId=None,):
7903 
    self.orderId = orderId
7904 
 
7905 
  def read(self, iprot):
7906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7908 
      return
7909 
    iprot.readStructBegin()
7910 
    while True:
7911 
      (fname, ftype, fid) = iprot.readFieldBegin()
7912 
      if ftype == TType.STOP:
7913 
        break
7914 
      if fid == 1:
7915 
        if ftype == TType.I64:
7916 
          self.orderId = iprot.readI64();
7917 
        else:
7918 
          iprot.skip(ftype)
7919 
      else:
7920 
        iprot.skip(ftype)
7921 
      iprot.readFieldEnd()
7922 
    iprot.readStructEnd()
7923 
 
7924 
  def write(self, oprot):
7925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7927 
      return
7928 
    oprot.writeStructBegin('requestPickupNumber_args')
7929 
    if self.orderId != None:
7930 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
7931 
      oprot.writeI64(self.orderId)
7932 
      oprot.writeFieldEnd()
7933 
    oprot.writeFieldStop()
7934 
    oprot.writeStructEnd()
7935 
 
7936 
  def __repr__(self):
7937 
    L = ['%s=%r' % (key, value)
7938 
      for key, value in self.__dict__.iteritems()]
7939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7940 
 
7941 
  def __eq__(self, other):
7942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7943 
 
7944 
  def __ne__(self, other):
7945 
    return not (self == other)
7946 
 
7947 
class requestPickupNumber_result:
7948 
  """
7949 
  Attributes:
7950 
   - success
7951 
   - ex
7952 
  """
7953 
 
7954 
  thrift_spec = (
7955 
    (0, TType.BOOL, 'success', None, None, ), # 0
7956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
7957 
  )
7958 
 
7959 
  def __init__(self, success=None, ex=None,):
7960 
    self.success = success
7961 
    self.ex = ex
7962 
 
7963 
  def read(self, iprot):
7964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7966 
      return
7967 
    iprot.readStructBegin()
7968 
    while True:
7969 
      (fname, ftype, fid) = iprot.readFieldBegin()
7970 
      if ftype == TType.STOP:
7971 
        break
7972 
      if fid == 0:
7973 
        if ftype == TType.BOOL:
7974 
          self.success = iprot.readBool();
7975 
        else:
7976 
          iprot.skip(ftype)
7977 
      elif fid == 1:
7978 
        if ftype == TType.STRUCT:
7979 
          self.ex = TransactionServiceException()
7980 
          self.ex.read(iprot)
7981 
        else:
7982 
          iprot.skip(ftype)
7983 
      else:
7984 
        iprot.skip(ftype)
7985 
      iprot.readFieldEnd()
7986 
    iprot.readStructEnd()
7987 
 
7988 
  def write(self, oprot):
7989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7991 
      return
7992 
    oprot.writeStructBegin('requestPickupNumber_result')
7993 
    if self.success != None:
7994 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
7995 
      oprot.writeBool(self.success)
7996 
      oprot.writeFieldEnd()
7997 
    if self.ex != None:
7998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
7999 
      self.ex.write(oprot)
8000 
      oprot.writeFieldEnd()
8001 
    oprot.writeFieldStop()
8002 
    oprot.writeStructEnd()
8003 
 
8004 
  def __repr__(self):
8005 
    L = ['%s=%r' % (key, value)
8006 
      for key, value in self.__dict__.iteritems()]
8007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8008 
 
8009 
  def __eq__(self, other):
8010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8011 
 
8012 
  def __ne__(self, other):
8013 
    return not (self == other)
8014 
 
8015 
class authorizePickup_args:
8016 
  """
8017 
  Attributes:
8018 
   - orderId
8019 
   - pickupNumber
8020 
  """
8021 
 
8022 
  thrift_spec = (
8023 
    None, # 0
8024 
    (1, TType.I64, 'orderId', None, None, ), # 1
8025 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
8026 
  )
8027 
 
8028 
  def __init__(self, orderId=None, pickupNumber=None,):
8029 
    self.orderId = orderId
8030 
    self.pickupNumber = pickupNumber
8031 
 
8032 
  def read(self, iprot):
8033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8035 
      return
8036 
    iprot.readStructBegin()
8037 
    while True:
8038 
      (fname, ftype, fid) = iprot.readFieldBegin()
8039 
      if ftype == TType.STOP:
8040 
        break
8041 
      if fid == 1:
8042 
        if ftype == TType.I64:
8043 
          self.orderId = iprot.readI64();
8044 
        else:
8045 
          iprot.skip(ftype)
8046 
      elif fid == 2:
8047 
        if ftype == TType.STRING:
8048 
          self.pickupNumber = iprot.readString();
8049 
        else:
8050 
          iprot.skip(ftype)
8051 
      else:
8052 
        iprot.skip(ftype)
8053 
      iprot.readFieldEnd()
8054 
    iprot.readStructEnd()
8055 
 
8056 
  def write(self, oprot):
8057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8059 
      return
8060 
    oprot.writeStructBegin('authorizePickup_args')
8061 
    if self.orderId != None:
8062 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8063 
      oprot.writeI64(self.orderId)
8064 
      oprot.writeFieldEnd()
8065 
    if self.pickupNumber != None:
8066 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
8067 
      oprot.writeString(self.pickupNumber)
8068 
      oprot.writeFieldEnd()
8069 
    oprot.writeFieldStop()
8070 
    oprot.writeStructEnd()
8071 
 
8072 
  def __repr__(self):
8073 
    L = ['%s=%r' % (key, value)
8074 
      for key, value in self.__dict__.iteritems()]
8075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8076 
 
8077 
  def __eq__(self, other):
8078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8079 
 
8080 
  def __ne__(self, other):
8081 
    return not (self == other)
8082 
 
8083 
class authorizePickup_result:
8084 
  """
8085 
  Attributes:
8086 
   - success
8087 
   - ex
8088 
  """
8089 
 
8090 
  thrift_spec = (
8091 
    (0, TType.BOOL, 'success', None, None, ), # 0
8092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8093 
  )
8094 
 
8095 
  def __init__(self, success=None, ex=None,):
8096 
    self.success = success
8097 
    self.ex = ex
8098 
 
8099 
  def read(self, iprot):
8100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8102 
      return
8103 
    iprot.readStructBegin()
8104 
    while True:
8105 
      (fname, ftype, fid) = iprot.readFieldBegin()
8106 
      if ftype == TType.STOP:
8107 
        break
8108 
      if fid == 0:
8109 
        if ftype == TType.BOOL:
8110 
          self.success = iprot.readBool();
8111 
        else:
8112 
          iprot.skip(ftype)
8113 
      elif fid == 1:
8114 
        if ftype == TType.STRUCT:
8115 
          self.ex = TransactionServiceException()
8116 
          self.ex.read(iprot)
8117 
        else:
8118 
          iprot.skip(ftype)
8119 
      else:
8120 
        iprot.skip(ftype)
8121 
      iprot.readFieldEnd()
8122 
    iprot.readStructEnd()
8123 
 
8124 
  def write(self, oprot):
8125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8127 
      return
8128 
    oprot.writeStructBegin('authorizePickup_result')
8129 
    if self.success != None:
8130 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8131 
      oprot.writeBool(self.success)
8132 
      oprot.writeFieldEnd()
8133 
    if self.ex != None:
8134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8135 
      self.ex.write(oprot)
8136 
      oprot.writeFieldEnd()
8137 
    oprot.writeFieldStop()
8138 
    oprot.writeStructEnd()
8139 
 
8140 
  def __repr__(self):
8141 
    L = ['%s=%r' % (key, value)
8142 
      for key, value in self.__dict__.iteritems()]
8143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8144 
 
8145 
  def __eq__(self, other):
8146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8147 
 
8148 
  def __ne__(self, other):
8149 
    return not (self == other)
8150 
 
2616 chandransh 8151 
class receiveReturn_args:
2591 chandransh 8152 
  """
8153 
  Attributes:
8154 
   - orderId
8155 
  """
2536 chandransh 8156 
 
2591 chandransh 8157 
  thrift_spec = (
8158 
    None, # 0
8159 
    (1, TType.I64, 'orderId', None, None, ), # 1
8160 
  )
8161 
 
8162 
  def __init__(self, orderId=None,):
8163 
    self.orderId = orderId
8164 
 
8165 
  def read(self, iprot):
8166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8168 
      return
8169 
    iprot.readStructBegin()
8170 
    while True:
8171 
      (fname, ftype, fid) = iprot.readFieldBegin()
8172 
      if ftype == TType.STOP:
8173 
        break
8174 
      if fid == 1:
8175 
        if ftype == TType.I64:
8176 
          self.orderId = iprot.readI64();
8177 
        else:
8178 
          iprot.skip(ftype)
8179 
      else:
8180 
        iprot.skip(ftype)
8181 
      iprot.readFieldEnd()
8182 
    iprot.readStructEnd()
8183 
 
8184 
  def write(self, oprot):
8185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8187 
      return
2616 chandransh 8188 
    oprot.writeStructBegin('receiveReturn_args')
2591 chandransh 8189 
    if self.orderId != None:
8190 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8191 
      oprot.writeI64(self.orderId)
8192 
      oprot.writeFieldEnd()
8193 
    oprot.writeFieldStop()
8194 
    oprot.writeStructEnd()
8195 
 
8196 
  def __repr__(self):
8197 
    L = ['%s=%r' % (key, value)
8198 
      for key, value in self.__dict__.iteritems()]
8199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8200 
 
8201 
  def __eq__(self, other):
8202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8203 
 
8204 
  def __ne__(self, other):
8205 
    return not (self == other)
8206 
 
2616 chandransh 8207 
class receiveReturn_result:
2591 chandransh 8208 
  """
8209 
  Attributes:
8210 
   - success
8211 
   - ex
8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    (0, TType.BOOL, 'success', None, None, ), # 0
8216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8217 
  )
8218 
 
8219 
  def __init__(self, success=None, ex=None,):
8220 
    self.success = success
8221 
    self.ex = ex
8222 
 
8223 
  def read(self, iprot):
8224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8226 
      return
8227 
    iprot.readStructBegin()
8228 
    while True:
8229 
      (fname, ftype, fid) = iprot.readFieldBegin()
8230 
      if ftype == TType.STOP:
8231 
        break
8232 
      if fid == 0:
8233 
        if ftype == TType.BOOL:
8234 
          self.success = iprot.readBool();
8235 
        else:
8236 
          iprot.skip(ftype)
8237 
      elif fid == 1:
8238 
        if ftype == TType.STRUCT:
8239 
          self.ex = TransactionServiceException()
8240 
          self.ex.read(iprot)
8241 
        else:
8242 
          iprot.skip(ftype)
8243 
      else:
8244 
        iprot.skip(ftype)
8245 
      iprot.readFieldEnd()
8246 
    iprot.readStructEnd()
8247 
 
8248 
  def write(self, oprot):
8249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8251 
      return
2616 chandransh 8252 
    oprot.writeStructBegin('receiveReturn_result')
2591 chandransh 8253 
    if self.success != None:
8254 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8255 
      oprot.writeBool(self.success)
8256 
      oprot.writeFieldEnd()
8257 
    if self.ex != None:
8258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8259 
      self.ex.write(oprot)
8260 
      oprot.writeFieldEnd()
8261 
    oprot.writeFieldStop()
8262 
    oprot.writeStructEnd()
8263 
 
8264 
  def __repr__(self):
8265 
    L = ['%s=%r' % (key, value)
8266 
      for key, value in self.__dict__.iteritems()]
8267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8268 
 
8269 
  def __eq__(self, other):
8270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8271 
 
8272 
  def __ne__(self, other):
8273 
    return not (self == other)
8274 
 
8275 
class validateDoa_args:
8276 
  """
8277 
  Attributes:
8278 
   - orderId
8279 
   - isValid
8280 
  """
8281 
 
8282 
  thrift_spec = (
8283 
    None, # 0
8284 
    (1, TType.I64, 'orderId', None, None, ), # 1
8285 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
8286 
  )
8287 
 
8288 
  def __init__(self, orderId=None, isValid=None,):
8289 
    self.orderId = orderId
8290 
    self.isValid = isValid
8291 
 
8292 
  def read(self, iprot):
8293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8295 
      return
8296 
    iprot.readStructBegin()
8297 
    while True:
8298 
      (fname, ftype, fid) = iprot.readFieldBegin()
8299 
      if ftype == TType.STOP:
8300 
        break
8301 
      if fid == 1:
8302 
        if ftype == TType.I64:
8303 
          self.orderId = iprot.readI64();
8304 
        else:
8305 
          iprot.skip(ftype)
8306 
      elif fid == 2:
8307 
        if ftype == TType.BOOL:
8308 
          self.isValid = iprot.readBool();
8309 
        else:
8310 
          iprot.skip(ftype)
8311 
      else:
8312 
        iprot.skip(ftype)
8313 
      iprot.readFieldEnd()
8314 
    iprot.readStructEnd()
8315 
 
8316 
  def write(self, oprot):
8317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8319 
      return
8320 
    oprot.writeStructBegin('validateDoa_args')
8321 
    if self.orderId != None:
8322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8323 
      oprot.writeI64(self.orderId)
8324 
      oprot.writeFieldEnd()
8325 
    if self.isValid != None:
8326 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
8327 
      oprot.writeBool(self.isValid)
8328 
      oprot.writeFieldEnd()
8329 
    oprot.writeFieldStop()
8330 
    oprot.writeStructEnd()
8331 
 
8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
8343 
class validateDoa_result:
8344 
  """
8345 
  Attributes:
8346 
   - success
8347 
   - ex
8348 
  """
8349 
 
8350 
  thrift_spec = (
8351 
    (0, TType.BOOL, 'success', None, None, ), # 0
8352 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8353 
  )
8354 
 
8355 
  def __init__(self, success=None, ex=None,):
8356 
    self.success = success
8357 
    self.ex = ex
8358 
 
8359 
  def read(self, iprot):
8360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8362 
      return
8363 
    iprot.readStructBegin()
8364 
    while True:
8365 
      (fname, ftype, fid) = iprot.readFieldBegin()
8366 
      if ftype == TType.STOP:
8367 
        break
8368 
      if fid == 0:
8369 
        if ftype == TType.BOOL:
8370 
          self.success = iprot.readBool();
8371 
        else:
8372 
          iprot.skip(ftype)
8373 
      elif fid == 1:
8374 
        if ftype == TType.STRUCT:
8375 
          self.ex = TransactionServiceException()
8376 
          self.ex.read(iprot)
8377 
        else:
8378 
          iprot.skip(ftype)
8379 
      else:
8380 
        iprot.skip(ftype)
8381 
      iprot.readFieldEnd()
8382 
    iprot.readStructEnd()
8383 
 
8384 
  def write(self, oprot):
8385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8387 
      return
8388 
    oprot.writeStructBegin('validateDoa_result')
8389 
    if self.success != None:
8390 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8391 
      oprot.writeBool(self.success)
8392 
      oprot.writeFieldEnd()
8393 
    if self.ex != None:
8394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8395 
      self.ex.write(oprot)
8396 
      oprot.writeFieldEnd()
8397 
    oprot.writeFieldStop()
8398 
    oprot.writeStructEnd()
8399 
 
8400 
  def __repr__(self):
8401 
    L = ['%s=%r' % (key, value)
8402 
      for key, value in self.__dict__.iteritems()]
8403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8404 
 
8405 
  def __eq__(self, other):
8406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8407 
 
8408 
  def __ne__(self, other):
8409 
    return not (self == other)
8410 
 
2616 chandransh 8411 
class reshipOrder_args:
8412 
  """
8413 
  Attributes:
8414 
   - orderId
8415 
  """
2591 chandransh 8416 
 
2616 chandransh 8417 
  thrift_spec = (
8418 
    None, # 0
8419 
    (1, TType.I64, 'orderId', None, None, ), # 1
8420 
  )
8421 
 
8422 
  def __init__(self, orderId=None,):
8423 
    self.orderId = orderId
8424 
 
8425 
  def read(self, iprot):
8426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8428 
      return
8429 
    iprot.readStructBegin()
8430 
    while True:
8431 
      (fname, ftype, fid) = iprot.readFieldBegin()
8432 
      if ftype == TType.STOP:
8433 
        break
8434 
      if fid == 1:
8435 
        if ftype == TType.I64:
8436 
          self.orderId = iprot.readI64();
8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      else:
8440 
        iprot.skip(ftype)
8441 
      iprot.readFieldEnd()
8442 
    iprot.readStructEnd()
8443 
 
8444 
  def write(self, oprot):
8445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8447 
      return
8448 
    oprot.writeStructBegin('reshipOrder_args')
8449 
    if self.orderId != None:
8450 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8451 
      oprot.writeI64(self.orderId)
8452 
      oprot.writeFieldEnd()
8453 
    oprot.writeFieldStop()
8454 
    oprot.writeStructEnd()
8455 
 
8456 
  def __repr__(self):
8457 
    L = ['%s=%r' % (key, value)
8458 
      for key, value in self.__dict__.iteritems()]
8459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8460 
 
8461 
  def __eq__(self, other):
8462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8463 
 
8464 
  def __ne__(self, other):
8465 
    return not (self == other)
8466 
 
8467 
class reshipOrder_result:
8468 
  """
8469 
  Attributes:
8470 
   - success
8471 
   - ex
8472 
  """
8473 
 
8474 
  thrift_spec = (
8475 
    (0, TType.I64, 'success', None, None, ), # 0
8476 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8477 
  )
8478 
 
8479 
  def __init__(self, success=None, ex=None,):
8480 
    self.success = success
8481 
    self.ex = ex
8482 
 
8483 
  def read(self, iprot):
8484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8486 
      return
8487 
    iprot.readStructBegin()
8488 
    while True:
8489 
      (fname, ftype, fid) = iprot.readFieldBegin()
8490 
      if ftype == TType.STOP:
8491 
        break
8492 
      if fid == 0:
8493 
        if ftype == TType.I64:
8494 
          self.success = iprot.readI64();
8495 
        else:
8496 
          iprot.skip(ftype)
8497 
      elif fid == 1:
8498 
        if ftype == TType.STRUCT:
8499 
          self.ex = TransactionServiceException()
8500 
          self.ex.read(iprot)
8501 
        else:
8502 
          iprot.skip(ftype)
8503 
      else:
8504 
        iprot.skip(ftype)
8505 
      iprot.readFieldEnd()
8506 
    iprot.readStructEnd()
8507 
 
8508 
  def write(self, oprot):
8509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8511 
      return
8512 
    oprot.writeStructBegin('reshipOrder_result')
8513 
    if self.success != None:
8514 
      oprot.writeFieldBegin('success', TType.I64, 0)
8515 
      oprot.writeI64(self.success)
8516 
      oprot.writeFieldEnd()
8517 
    if self.ex != None:
8518 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8519 
      self.ex.write(oprot)
8520 
      oprot.writeFieldEnd()
8521 
    oprot.writeFieldStop()
8522 
    oprot.writeStructEnd()
8523 
 
8524 
  def __repr__(self):
8525 
    L = ['%s=%r' % (key, value)
8526 
      for key, value in self.__dict__.iteritems()]
8527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8528 
 
8529 
  def __eq__(self, other):
8530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8531 
 
8532 
  def __ne__(self, other):
8533 
    return not (self == other)
8534 
 
8535 
class refundOrder_args:
8536 
  """
8537 
  Attributes:
8538 
   - orderId
8539 
  """
8540 
 
8541 
  thrift_spec = (
8542 
    None, # 0
8543 
    (1, TType.I64, 'orderId', None, None, ), # 1
8544 
  )
8545 
 
8546 
  def __init__(self, orderId=None,):
8547 
    self.orderId = orderId
8548 
 
8549 
  def read(self, iprot):
8550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8552 
      return
8553 
    iprot.readStructBegin()
8554 
    while True:
8555 
      (fname, ftype, fid) = iprot.readFieldBegin()
8556 
      if ftype == TType.STOP:
8557 
        break
8558 
      if fid == 1:
8559 
        if ftype == TType.I64:
8560 
          self.orderId = iprot.readI64();
8561 
        else:
8562 
          iprot.skip(ftype)
8563 
      else:
8564 
        iprot.skip(ftype)
8565 
      iprot.readFieldEnd()
8566 
    iprot.readStructEnd()
8567 
 
8568 
  def write(self, oprot):
8569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8571 
      return
8572 
    oprot.writeStructBegin('refundOrder_args')
8573 
    if self.orderId != None:
8574 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
8575 
      oprot.writeI64(self.orderId)
8576 
      oprot.writeFieldEnd()
8577 
    oprot.writeFieldStop()
8578 
    oprot.writeStructEnd()
8579 
 
8580 
  def __repr__(self):
8581 
    L = ['%s=%r' % (key, value)
8582 
      for key, value in self.__dict__.iteritems()]
8583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8584 
 
8585 
  def __eq__(self, other):
8586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8587 
 
8588 
  def __ne__(self, other):
8589 
    return not (self == other)
8590 
 
8591 
class refundOrder_result:
8592 
  """
8593 
  Attributes:
8594 
   - success
8595 
   - ex
8596 
  """
8597 
 
8598 
  thrift_spec = (
8599 
    (0, TType.BOOL, 'success', None, None, ), # 0
8600 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8601 
  )
8602 
 
8603 
  def __init__(self, success=None, ex=None,):
8604 
    self.success = success
8605 
    self.ex = ex
8606 
 
8607 
  def read(self, iprot):
8608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8610 
      return
8611 
    iprot.readStructBegin()
8612 
    while True:
8613 
      (fname, ftype, fid) = iprot.readFieldBegin()
8614 
      if ftype == TType.STOP:
8615 
        break
8616 
      if fid == 0:
8617 
        if ftype == TType.BOOL:
8618 
          self.success = iprot.readBool();
8619 
        else:
8620 
          iprot.skip(ftype)
8621 
      elif fid == 1:
8622 
        if ftype == TType.STRUCT:
8623 
          self.ex = TransactionServiceException()
8624 
          self.ex.read(iprot)
8625 
        else:
8626 
          iprot.skip(ftype)
8627 
      else:
8628 
        iprot.skip(ftype)
8629 
      iprot.readFieldEnd()
8630 
    iprot.readStructEnd()
8631 
 
8632 
  def write(self, oprot):
8633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8635 
      return
8636 
    oprot.writeStructBegin('refundOrder_result')
8637 
    if self.success != None:
8638 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
8639 
      oprot.writeBool(self.success)
8640 
      oprot.writeFieldEnd()
8641 
    if self.ex != None:
8642 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8643 
      self.ex.write(oprot)
8644 
      oprot.writeFieldEnd()
8645 
    oprot.writeFieldStop()
8646 
    oprot.writeStructEnd()
8647 
 
8648 
  def __repr__(self):
8649 
    L = ['%s=%r' % (key, value)
8650 
      for key, value in self.__dict__.iteritems()]
8651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8652 
 
8653 
  def __eq__(self, other):
8654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8655 
 
8656 
  def __ne__(self, other):
8657 
    return not (self == other)
8658 
 
2690 chandransh 8659 
class getReturnOrders_args:
8660 
  """
8661 
  Attributes:
8662 
   - warehouseId
8663 
   - fromDate
8664 
   - toDate
8665 
  """
2616 chandransh 8666 
 
2690 chandransh 8667 
  thrift_spec = (
8668 
    None, # 0
8669 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
8670 
    (2, TType.I64, 'fromDate', None, None, ), # 2
8671 
    (3, TType.I64, 'toDate', None, None, ), # 3
8672 
  )
8673 
 
8674 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
8675 
    self.warehouseId = warehouseId
8676 
    self.fromDate = fromDate
8677 
    self.toDate = toDate
8678 
 
8679 
  def read(self, iprot):
8680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8682 
      return
8683 
    iprot.readStructBegin()
8684 
    while True:
8685 
      (fname, ftype, fid) = iprot.readFieldBegin()
8686 
      if ftype == TType.STOP:
8687 
        break
8688 
      if fid == 1:
8689 
        if ftype == TType.I64:
8690 
          self.warehouseId = iprot.readI64();
8691 
        else:
8692 
          iprot.skip(ftype)
8693 
      elif fid == 2:
8694 
        if ftype == TType.I64:
8695 
          self.fromDate = iprot.readI64();
8696 
        else:
8697 
          iprot.skip(ftype)
8698 
      elif fid == 3:
8699 
        if ftype == TType.I64:
8700 
          self.toDate = iprot.readI64();
8701 
        else:
8702 
          iprot.skip(ftype)
8703 
      else:
8704 
        iprot.skip(ftype)
8705 
      iprot.readFieldEnd()
8706 
    iprot.readStructEnd()
8707 
 
8708 
  def write(self, oprot):
8709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8711 
      return
8712 
    oprot.writeStructBegin('getReturnOrders_args')
8713 
    if self.warehouseId != None:
8714 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
8715 
      oprot.writeI64(self.warehouseId)
8716 
      oprot.writeFieldEnd()
8717 
    if self.fromDate != None:
8718 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
8719 
      oprot.writeI64(self.fromDate)
8720 
      oprot.writeFieldEnd()
8721 
    if self.toDate != None:
8722 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
8723 
      oprot.writeI64(self.toDate)
8724 
      oprot.writeFieldEnd()
8725 
    oprot.writeFieldStop()
8726 
    oprot.writeStructEnd()
8727 
 
8728 
  def __repr__(self):
8729 
    L = ['%s=%r' % (key, value)
8730 
      for key, value in self.__dict__.iteritems()]
8731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8732 
 
8733 
  def __eq__(self, other):
8734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8735 
 
8736 
  def __ne__(self, other):
8737 
    return not (self == other)
8738 
 
8739 
class getReturnOrders_result:
8740 
  """
8741 
  Attributes:
8742 
   - success
8743 
  """
8744 
 
8745 
  thrift_spec = (
8746 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
8747 
  )
8748 
 
8749 
  def __init__(self, success=None,):
8750 
    self.success = success
8751 
 
8752 
  def read(self, iprot):
8753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8755 
      return
8756 
    iprot.readStructBegin()
8757 
    while True:
8758 
      (fname, ftype, fid) = iprot.readFieldBegin()
8759 
      if ftype == TType.STOP:
8760 
        break
8761 
      if fid == 0:
8762 
        if ftype == TType.LIST:
8763 
          self.success = []
8764 
          (_etype158, _size155) = iprot.readListBegin()
8765 
          for _i159 in xrange(_size155):
8766 
            _elem160 = ReturnOrder()
8767 
            _elem160.read(iprot)
8768 
            self.success.append(_elem160)
8769 
          iprot.readListEnd()
8770 
        else:
8771 
          iprot.skip(ftype)
8772 
      else:
8773 
        iprot.skip(ftype)
8774 
      iprot.readFieldEnd()
8775 
    iprot.readStructEnd()
8776 
 
8777 
  def write(self, oprot):
8778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8780 
      return
8781 
    oprot.writeStructBegin('getReturnOrders_result')
8782 
    if self.success != None:
8783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8784 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8785 
      for iter161 in self.success:
8786 
        iter161.write(oprot)
8787 
      oprot.writeListEnd()
8788 
      oprot.writeFieldEnd()
8789 
    oprot.writeFieldStop()
8790 
    oprot.writeStructEnd()
8791 
 
8792 
  def __repr__(self):
8793 
    L = ['%s=%r' % (key, value)
8794 
      for key, value in self.__dict__.iteritems()]
8795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8796 
 
8797 
  def __eq__(self, other):
8798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8799 
 
8800 
  def __ne__(self, other):
8801 
    return not (self == other)
8802 
 
2700 chandransh 8803 
class getReturnOrder_args:
8804 
  """
8805 
  Attributes:
8806 
   - id
8807 
  """
8808 
 
8809 
  thrift_spec = (
8810 
    None, # 0
8811 
    (1, TType.I64, 'id', None, None, ), # 1
8812 
  )
8813 
 
8814 
  def __init__(self, id=None,):
8815 
    self.id = id
8816 
 
8817 
  def read(self, iprot):
8818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8820 
      return
8821 
    iprot.readStructBegin()
8822 
    while True:
8823 
      (fname, ftype, fid) = iprot.readFieldBegin()
8824 
      if ftype == TType.STOP:
8825 
        break
8826 
      if fid == 1:
8827 
        if ftype == TType.I64:
8828 
          self.id = iprot.readI64();
8829 
        else:
8830 
          iprot.skip(ftype)
8831 
      else:
8832 
        iprot.skip(ftype)
8833 
      iprot.readFieldEnd()
8834 
    iprot.readStructEnd()
8835 
 
8836 
  def write(self, oprot):
8837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8839 
      return
8840 
    oprot.writeStructBegin('getReturnOrder_args')
8841 
    if self.id != None:
8842 
      oprot.writeFieldBegin('id', TType.I64, 1)
8843 
      oprot.writeI64(self.id)
8844 
      oprot.writeFieldEnd()
8845 
    oprot.writeFieldStop()
8846 
    oprot.writeStructEnd()
8847 
 
8848 
  def __repr__(self):
8849 
    L = ['%s=%r' % (key, value)
8850 
      for key, value in self.__dict__.iteritems()]
8851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8852 
 
8853 
  def __eq__(self, other):
8854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8855 
 
8856 
  def __ne__(self, other):
8857 
    return not (self == other)
8858 
 
8859 
class getReturnOrder_result:
8860 
  """
8861 
  Attributes:
8862 
   - success
8863 
   - ex
8864 
  """
8865 
 
8866 
  thrift_spec = (
8867 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
8868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8869 
  )
8870 
 
8871 
  def __init__(self, success=None, ex=None,):
8872 
    self.success = success
8873 
    self.ex = ex
8874 
 
8875 
  def read(self, iprot):
8876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8878 
      return
8879 
    iprot.readStructBegin()
8880 
    while True:
8881 
      (fname, ftype, fid) = iprot.readFieldBegin()
8882 
      if ftype == TType.STOP:
8883 
        break
8884 
      if fid == 0:
8885 
        if ftype == TType.STRUCT:
8886 
          self.success = ReturnOrder()
8887 
          self.success.read(iprot)
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      elif fid == 1:
8891 
        if ftype == TType.STRUCT:
8892 
          self.ex = TransactionServiceException()
8893 
          self.ex.read(iprot)
8894 
        else:
8895 
          iprot.skip(ftype)
8896 
      else:
8897 
        iprot.skip(ftype)
8898 
      iprot.readFieldEnd()
8899 
    iprot.readStructEnd()
8900 
 
8901 
  def write(self, oprot):
8902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8904 
      return
8905 
    oprot.writeStructBegin('getReturnOrder_result')
8906 
    if self.success != None:
8907 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8908 
      self.success.write(oprot)
8909 
      oprot.writeFieldEnd()
8910 
    if self.ex != None:
8911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8912 
      self.ex.write(oprot)
8913 
      oprot.writeFieldEnd()
8914 
    oprot.writeFieldStop()
8915 
    oprot.writeStructEnd()
8916 
 
8917 
  def __repr__(self):
8918 
    L = ['%s=%r' % (key, value)
8919 
      for key, value in self.__dict__.iteritems()]
8920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8921 
 
8922 
  def __eq__(self, other):
8923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8924 
 
8925 
  def __ne__(self, other):
8926 
    return not (self == other)
8927 
 
2690 chandransh 8928 
class processReturn_args:
8929 
  """
8930 
  Attributes:
8931 
   - returnOrderId
8932 
  """
8933 
 
8934 
  thrift_spec = (
8935 
    None, # 0
8936 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
8937 
  )
8938 
 
8939 
  def __init__(self, returnOrderId=None,):
8940 
    self.returnOrderId = returnOrderId
8941 
 
8942 
  def read(self, iprot):
8943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8945 
      return
8946 
    iprot.readStructBegin()
8947 
    while True:
8948 
      (fname, ftype, fid) = iprot.readFieldBegin()
8949 
      if ftype == TType.STOP:
8950 
        break
8951 
      if fid == 1:
8952 
        if ftype == TType.I64:
8953 
          self.returnOrderId = iprot.readI64();
8954 
        else:
8955 
          iprot.skip(ftype)
8956 
      else:
8957 
        iprot.skip(ftype)
8958 
      iprot.readFieldEnd()
8959 
    iprot.readStructEnd()
8960 
 
8961 
  def write(self, oprot):
8962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8964 
      return
8965 
    oprot.writeStructBegin('processReturn_args')
8966 
    if self.returnOrderId != None:
8967 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
8968 
      oprot.writeI64(self.returnOrderId)
8969 
      oprot.writeFieldEnd()
8970 
    oprot.writeFieldStop()
8971 
    oprot.writeStructEnd()
8972 
 
8973 
  def __repr__(self):
8974 
    L = ['%s=%r' % (key, value)
8975 
      for key, value in self.__dict__.iteritems()]
8976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8977 
 
8978 
  def __eq__(self, other):
8979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8980 
 
8981 
  def __ne__(self, other):
8982 
    return not (self == other)
8983 
 
8984 
class processReturn_result:
8985 
  """
8986 
  Attributes:
8987 
   - ex
8988 
  """
8989 
 
8990 
  thrift_spec = (
8991 
    None, # 0
8992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8993 
  )
8994 
 
8995 
  def __init__(self, ex=None,):
8996 
    self.ex = ex
8997 
 
8998 
  def read(self, iprot):
8999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9001 
      return
9002 
    iprot.readStructBegin()
9003 
    while True:
9004 
      (fname, ftype, fid) = iprot.readFieldBegin()
9005 
      if ftype == TType.STOP:
9006 
        break
9007 
      if fid == 1:
9008 
        if ftype == TType.STRUCT:
9009 
          self.ex = TransactionServiceException()
9010 
          self.ex.read(iprot)
9011 
        else:
9012 
          iprot.skip(ftype)
9013 
      else:
9014 
        iprot.skip(ftype)
9015 
      iprot.readFieldEnd()
9016 
    iprot.readStructEnd()
9017 
 
9018 
  def write(self, oprot):
9019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9021 
      return
9022 
    oprot.writeStructBegin('processReturn_result')
9023 
    if self.ex != None:
9024 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9025 
      self.ex.write(oprot)
9026 
      oprot.writeFieldEnd()
9027 
    oprot.writeFieldStop()
9028 
    oprot.writeStructEnd()
9029 
 
9030 
  def __repr__(self):
9031 
    L = ['%s=%r' % (key, value)
9032 
      for key, value in self.__dict__.iteritems()]
9033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9034 
 
9035 
  def __eq__(self, other):
9036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9037 
 
9038 
  def __ne__(self, other):
9039 
    return not (self == other)
9040 
 
9041