Subversion Repositories SmartDukaan

Rev

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