Subversion Repositories SmartDukaan

Rev

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