WebSVN – SmartDukaan – Diff – //trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/order/TransactionService.java

      * @param toDate
      */
     public List<ReturnOrder> getReturnOrders(long warehouseId, long fromDate, long toDate) throws org.apache.thrift.TException;
     /**
+     * Get all return orders created between the from and to dates.
+     *
+     * @param onlyNotProcessed
+     * @param fromDate
+     * @param toDate
+     */
+    public List<ReturnOrder> getAllReturnOrders(boolean onlyNotProcessed, long fromDate, long toDate) throws org.apache.thrift.TException;
+    /**
      * Returns the ReturnOrder corresponding to the given id.
      * Throws an exception if the return order with the given id couldn't be found.
+     *
      * @param id
      */
+     *
      * @param orderIds
      */
     public List<Long> getReshippedOrderIds(List<Long> orderIds) throws TransactionServiceException, org.apache.thrift.TException;
-    public List<Order> getOrdersWhereVendorNotPaid(long vendorId) throws TransactionServiceException, org.apache.thrift.TException;
+    public List<Order> getBilledOrders(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo) throws TransactionServiceException, org.apache.thrift.TException;
     public Map<Long,Long> getStatusDistributionOfOrders(long startDate, long endDate) throws TransactionServiceException, org.apache.thrift.TException;
     public List<Long> getOrderIdsForStatus(long status, long startDatetime, long endDatetime) throws TransactionServiceException, org.apache.thrift.TException;
     public void refundOrder(long orderId, String refundedBy, String reason, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.refundOrder_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrders(long warehouseId, long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrders_call> resultHandler) throws org.apache.thrift.TException;
+    public void getAllReturnOrders(boolean onlyNotProcessed, long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getAllReturnOrders_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrder(long id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrder_call> resultHandler) throws org.apache.thrift.TException;
     public void processReturn(long returnOrderId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.processReturn_call> resultHandler) throws org.apache.thrift.TException;
     public void updateWeight(long orderId, double weight, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.updateWeight_call> resultHandler) throws org.apache.thrift.TException;
     public void getSettlementsByDate(long settlementDateFrom, long settlementDateTo, boolean isRefund, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getSettlementsByDate_call> resultHandler) throws org.apache.thrift.TException;
     public void getReshippedOrderIds(List<Long> orderIds, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReshippedOrderIds_call> resultHandler) throws org.apache.thrift.TException;
-    public void getOrdersWhereVendorNotPaid(long vendorId, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrdersWhereVendorNotPaid_call> resultHandler) throws org.apache.thrift.TException;
+    public void getBilledOrders(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getBilledOrders_call> resultHandler) throws org.apache.thrift.TException;
     public void getStatusDistributionOfOrders(long startDate, long endDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getStatusDistributionOfOrders_call> resultHandler) throws org.apache.thrift.TException;
     public void getOrderIdsForStatus(long status, long startDatetime, long endDatetime, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOrderIdsForStatus_call> resultHandler) throws org.apache.thrift.TException;
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
+    }
+    public List<ReturnOrder> getAllReturnOrders(boolean onlyNotProcessed, long fromDate, long toDate) throws org.apache.thrift.TException
+    {
+      send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate);
+      return recv_getAllReturnOrders();
+    }
+    public void send_getAllReturnOrders(boolean onlyNotProcessed, long fromDate, long toDate) throws org.apache.thrift.TException
+    {
+      getAllReturnOrders_args args = new getAllReturnOrders_args();
+      args.setOnlyNotProcessed(onlyNotProcessed);
+      args.setFromDate(fromDate);
+      args.setToDate(toDate);
+      sendBase("getAllReturnOrders", args);
+    }
+    public List<ReturnOrder> recv_getAllReturnOrders() throws org.apache.thrift.TException
+    {
+      getAllReturnOrders_result result = new getAllReturnOrders_result();
+      receiveBase(result, "getAllReturnOrders");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
+    }
     public ReturnOrder getReturnOrder(long id) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_getReturnOrder(id);
       return recv_getReturnOrder();
+    }
         throw result.ex;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
+    }
-    public List<Order> getOrdersWhereVendorNotPaid(long vendorId) throws TransactionServiceException, org.apache.thrift.TException
+    public List<Order> getBilledOrders(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo) throws TransactionServiceException, org.apache.thrift.TException
+    {
-      send_getOrdersWhereVendorNotPaid(vendorId);
+      send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo);
-      return recv_getOrdersWhereVendorNotPaid();
+      return recv_getBilledOrders();
+    }
-    public void send_getOrdersWhereVendorNotPaid(long vendorId) throws org.apache.thrift.TException
+    public void send_getBilledOrders(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo) throws org.apache.thrift.TException
+    {
-      getOrdersWhereVendorNotPaid_args args = new getOrdersWhereVendorNotPaid_args();
+      getBilledOrders_args args = new getBilledOrders_args();
       args.setVendorId(vendorId);
+      args.setOnlyVendorNotPaid(onlyVendorNotPaid);
+      args.setBillingDateFrom(billingDateFrom);
+      args.setBillingDateTo(billingDateTo);
-      sendBase("getOrdersWhereVendorNotPaid", args);
+      sendBase("getBilledOrders", args);
+    }
-    public List<Order> recv_getOrdersWhereVendorNotPaid() throws TransactionServiceException, org.apache.thrift.TException
+    public List<Order> recv_getBilledOrders() throws TransactionServiceException, org.apache.thrift.TException
+    {
-      getOrdersWhereVendorNotPaid_result result = new getOrdersWhereVendorNotPaid_result();
+      getBilledOrders_result result = new getBilledOrders_result();
-      receiveBase(result, "getOrdersWhereVendorNotPaid");
+      receiveBase(result, "getBilledOrders");
       if (result.isSetSuccess()) {
         return result.success;
+      }
       if (result.ex != null) {
         throw result.ex;
+      }
-      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getOrdersWhereVendorNotPaid failed: unknown result");
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
+    }
     public Map<Long,Long> getStatusDistributionOfOrders(long startDate, long endDate) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_getStatusDistributionOfOrders(startDate, endDate);
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getReturnOrders();
+      }
+    }
+    public void getAllReturnOrders(boolean onlyNotProcessed, long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<getAllReturnOrders_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      getAllReturnOrders_call method_call = new getAllReturnOrders_call(onlyNotProcessed, fromDate, toDate, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class getAllReturnOrders_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private boolean onlyNotProcessed;
+      private long fromDate;
+      private long toDate;
+      public getAllReturnOrders_call(boolean onlyNotProcessed, long fromDate, long toDate, org.apache.thrift.async.AsyncMethodCallback<getAllReturnOrders_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.onlyNotProcessed = onlyNotProcessed;
+        this.fromDate = fromDate;
+        this.toDate = toDate;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getAllReturnOrders", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        getAllReturnOrders_args args = new getAllReturnOrders_args();
+        args.setOnlyNotProcessed(onlyNotProcessed);
+        args.setFromDate(fromDate);
+        args.setToDate(toDate);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public List<ReturnOrder> getResult() throws org.apache.thrift.TException {
+        if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
+        org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_getAllReturnOrders();
+      }
+    }
     public void getReturnOrder(long id, org.apache.thrift.async.AsyncMethodCallback<getReturnOrder_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getReturnOrder_call method_call = new getReturnOrder_call(id, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getReshippedOrderIds();
+      }
+    }
-    public void getOrdersWhereVendorNotPaid(long vendorId, org.apache.thrift.async.AsyncMethodCallback<getOrdersWhereVendorNotPaid_call> resultHandler) throws org.apache.thrift.TException {
+    public void getBilledOrders(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo, org.apache.thrift.async.AsyncMethodCallback<getBilledOrders_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
-      getOrdersWhereVendorNotPaid_call method_call = new getOrdersWhereVendorNotPaid_call(vendorId, resultHandler, this, ___protocolFactory, ___transport);
+      getBilledOrders_call method_call = new getBilledOrders_call(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
+    }
-    public static class getOrdersWhereVendorNotPaid_call extends org.apache.thrift.async.TAsyncMethodCall {
+    public static class getBilledOrders_call extends org.apache.thrift.async.TAsyncMethodCall {
       private long vendorId;
+      private boolean onlyVendorNotPaid;
+      private long billingDateFrom;
+      private long billingDateTo;
-      public getOrdersWhereVendorNotPaid_call(long vendorId, org.apache.thrift.async.AsyncMethodCallback<getOrdersWhereVendorNotPaid_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
+      public getBilledOrders_call(long vendorId, boolean onlyVendorNotPaid, long billingDateFrom, long billingDateTo, org.apache.thrift.async.AsyncMethodCallback<getBilledOrders_call> resultHandler, org.apache.thrift.async.TAsyncClient client, org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.transport.TNonblockingTransport transport) throws org.apache.thrift.TException {
         super(client, protocolFactory, transport, resultHandler, false);
         this.vendorId = vendorId;
+        this.onlyVendorNotPaid = onlyVendorNotPaid;
+        this.billingDateFrom = billingDateFrom;
+        this.billingDateTo = billingDateTo;
+      }
       public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
-        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getOrdersWhereVendorNotPaid", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("getBilledOrders", org.apache.thrift.protocol.TMessageType.CALL, 0));
-        getOrdersWhereVendorNotPaid_args args = new getOrdersWhereVendorNotPaid_args();
+        getBilledOrders_args args = new getBilledOrders_args();
         args.setVendorId(vendorId);
+        args.setOnlyVendorNotPaid(onlyVendorNotPaid);
+        args.setBillingDateFrom(billingDateFrom);
+        args.setBillingDateTo(billingDateTo);
         args.write(prot);
         prot.writeMessageEnd();
+      }
       public List<Order> getResult() throws TransactionServiceException, org.apache.thrift.TException {
         if (getState() != org.apache.thrift.async.TAsyncMethodCall.State.RESPONSE_READ) {
           throw new IllegalStateException("Method call not finished!");
+        }
         org.apache.thrift.transport.TMemoryInputTransport memoryTransport = new org.apache.thrift.transport.TMemoryInputTransport(getFrameBuffer().array());
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
-        return (new Client(prot)).recv_getOrdersWhereVendorNotPaid();
+        return (new Client(prot)).recv_getBilledOrders();
+      }
+    }
     public void getStatusDistributionOfOrders(long startDate, long endDate, org.apache.thrift.async.AsyncMethodCallback<getStatusDistributionOfOrders_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       processMap.put("validateDoa", new validateDoa());
       processMap.put("validateReturnProduct", new validateReturnProduct());
       processMap.put("reshipOrder", new reshipOrder());
       processMap.put("refundOrder", new refundOrder());
       processMap.put("getReturnOrders", new getReturnOrders());
+      processMap.put("getAllReturnOrders", new getAllReturnOrders());
       processMap.put("getReturnOrder", new getReturnOrder());
       processMap.put("processReturn", new processReturn());
       processMap.put("updateWeight", new updateWeight());
       processMap.put("changeItem", new changeItem());
       processMap.put("shiftToWarehouse", new shiftToWarehouse());
       processMap.put("getEBSSettlementSummaries", new getEBSSettlementSummaries());
       processMap.put("markEBSSettlementUploaded", new markEBSSettlementUploaded());
       processMap.put("getEBSSettlementDate", new getEBSSettlementDate());
       processMap.put("getSettlementsByDate", new getSettlementsByDate());
       processMap.put("getReshippedOrderIds", new getReshippedOrderIds());
-      processMap.put("getOrdersWhereVendorNotPaid", new getOrdersWhereVendorNotPaid());
+      processMap.put("getBilledOrders", new getBilledOrders());
       processMap.put("getStatusDistributionOfOrders", new getStatusDistributionOfOrders());
       processMap.put("getOrderIdsForStatus", new getOrderIdsForStatus());
       processMap.put("updateCODAgent", new updateCODAgent());
       processMap.put("updateOrderAsPaidToVendor", new updateOrderAsPaidToVendor());
       processMap.put("updateOrderOnlyAsPaidToVendor", new updateOrderOnlyAsPaidToVendor());
         result.success = iface.getReturnOrders(args.warehouseId, args.fromDate, args.toDate);
         return result;
+      }
+    }
+    private static class getAllReturnOrders<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getAllReturnOrders_args> {
+      public getAllReturnOrders() {
+        super("getAllReturnOrders");
+      }
+      protected getAllReturnOrders_args getEmptyArgsInstance() {
+        return new getAllReturnOrders_args();
+      }
+      protected getAllReturnOrders_result getResult(I iface, getAllReturnOrders_args args) throws org.apache.thrift.TException {
+        getAllReturnOrders_result result = new getAllReturnOrders_result();
+        result.success = iface.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate);
+        return result;
+      }
+    }
     private static class getReturnOrder<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrder_args> {
       public getReturnOrder() {
         super("getReturnOrder");
+      }
+        }
         return result;
+      }
+    }
-    private static class getOrdersWhereVendorNotPaid<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getOrdersWhereVendorNotPaid_args> {
+    private static class getBilledOrders<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getBilledOrders_args> {
-      public getOrdersWhereVendorNotPaid() {
+      public getBilledOrders() {
-        super("getOrdersWhereVendorNotPaid");
+        super("getBilledOrders");
+      }
-      protected getOrdersWhereVendorNotPaid_args getEmptyArgsInstance() {
+      protected getBilledOrders_args getEmptyArgsInstance() {
-        return new getOrdersWhereVendorNotPaid_args();
+        return new getBilledOrders_args();
+      }
-      protected getOrdersWhereVendorNotPaid_result getResult(I iface, getOrdersWhereVendorNotPaid_args args) throws org.apache.thrift.TException {
+      protected getBilledOrders_result getResult(I iface, getBilledOrders_args args) throws org.apache.thrift.TException {
-        getOrdersWhereVendorNotPaid_result result = new getOrdersWhereVendorNotPaid_result();
+        getBilledOrders_result result = new getBilledOrders_result();
         try {
-          result.success = iface.getOrdersWhereVendorNotPaid(args.vendorId);
+          result.success = iface.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo);
         } catch (TransactionServiceException ex) {
           result.ex = ex;
+        }
         return result;
+      }
+      }
+    }
     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
       try {
-        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
-        __isset_bit_vector = new BitSet(1);
         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
       } catch (org.apache.thrift.TException te) {
         throw new java.io.IOException(te);
+      }
+    }
+      }
+    }
     private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
       try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
         read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
       } catch (org.apache.thrift.TException te) {
         throw new java.io.IOException(te);
+      }
+    }
+      }
+    }
+  }
+  public static class getAllReturnOrders_args implements org.apache.thrift.TBase<getAllReturnOrders_args, getAllReturnOrders_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllReturnOrders_args");
+    private static final org.apache.thrift.protocol.TField ONLY_NOT_PROCESSED_FIELD_DESC = new org.apache.thrift.protocol.TField("onlyNotProcessed", org.apache.thrift.protocol.TType.BOOL, (short)1);
+    private static final org.apache.thrift.protocol.TField FROM_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("fromDate", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField TO_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("toDate", org.apache.thrift.protocol.TType.I64, (short)3);
+    private boolean onlyNotProcessed; // required
+    private long fromDate; // required
+    private long toDate; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      ONLY_NOT_PROCESSED((short)1, "onlyNotProcessed"),
+      FROM_DATE((short)2, "fromDate"),
+      TO_DATE((short)3, "toDate");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // ONLY_NOT_PROCESSED
+            return ONLY_NOT_PROCESSED;
+          case 2: // FROM_DATE
+            return FROM_DATE;
+          case 3: // TO_DATE
+            return TO_DATE;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    private static final int __ONLYNOTPROCESSED_ISSET_ID = 0;
+    private static final int __FROMDATE_ISSET_ID = 1;
+    private static final int __TODATE_ISSET_ID = 2;
+    private BitSet __isset_bit_vector = new BitSet(3);
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.ONLY_NOT_PROCESSED, new org.apache.thrift.meta_data.FieldMetaData("onlyNotProcessed", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      tmpMap.put(_Fields.FROM_DATE, new org.apache.thrift.meta_data.FieldMetaData("fromDate", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.TO_DATE, new org.apache.thrift.meta_data.FieldMetaData("toDate", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllReturnOrders_args.class, metaDataMap);
+    }
+    public getAllReturnOrders_args() {
+    }
+    public getAllReturnOrders_args(
+      boolean onlyNotProcessed,
+      long fromDate,
+      long toDate)
+    {
+      this();
+      this.onlyNotProcessed = onlyNotProcessed;
+      setOnlyNotProcessedIsSet(true);
+      this.fromDate = fromDate;
+      setFromDateIsSet(true);
+      this.toDate = toDate;
+      setToDateIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAllReturnOrders_args(getAllReturnOrders_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.onlyNotProcessed = other.onlyNotProcessed;
+      this.fromDate = other.fromDate;
+      this.toDate = other.toDate;
+    }
+    public getAllReturnOrders_args deepCopy() {
+      return new getAllReturnOrders_args(this);
+    }
+    @Override
+    public void clear() {
+      setOnlyNotProcessedIsSet(false);
+      this.onlyNotProcessed = false;
+      setFromDateIsSet(false);
+      this.fromDate = 0;
+      setToDateIsSet(false);
+      this.toDate = 0;
+    }
+    public boolean isOnlyNotProcessed() {
+      return this.onlyNotProcessed;
+    }
+    public void setOnlyNotProcessed(boolean onlyNotProcessed) {
+      this.onlyNotProcessed = onlyNotProcessed;
+      setOnlyNotProcessedIsSet(true);
+    }
+    public void unsetOnlyNotProcessed() {
+      __isset_bit_vector.clear(__ONLYNOTPROCESSED_ISSET_ID);
+    }
+    /** Returns true if field onlyNotProcessed is set (has been assigned a value) and false otherwise */
+    public boolean isSetOnlyNotProcessed() {
+      return __isset_bit_vector.get(__ONLYNOTPROCESSED_ISSET_ID);
+    }
+    public void setOnlyNotProcessedIsSet(boolean value) {
+      __isset_bit_vector.set(__ONLYNOTPROCESSED_ISSET_ID, value);
+    }
+    public long getFromDate() {
+      return this.fromDate;
+    }
+    public void setFromDate(long fromDate) {
+      this.fromDate = fromDate;
+      setFromDateIsSet(true);
+    }
+    public void unsetFromDate() {
+      __isset_bit_vector.clear(__FROMDATE_ISSET_ID);
+    }
+    /** Returns true if field fromDate is set (has been assigned a value) and false otherwise */
+    public boolean isSetFromDate() {
+      return __isset_bit_vector.get(__FROMDATE_ISSET_ID);
+    }
+    public void setFromDateIsSet(boolean value) {
+      __isset_bit_vector.set(__FROMDATE_ISSET_ID, value);
+    }
+    public long getToDate() {
+      return this.toDate;
+    }
+    public void setToDate(long toDate) {
+      this.toDate = toDate;
+      setToDateIsSet(true);
+    }
+    public void unsetToDate() {
+      __isset_bit_vector.clear(__TODATE_ISSET_ID);
+    }
+    /** Returns true if field toDate is set (has been assigned a value) and false otherwise */
+    public boolean isSetToDate() {
+      return __isset_bit_vector.get(__TODATE_ISSET_ID);
+    }
+    public void setToDateIsSet(boolean value) {
+      __isset_bit_vector.set(__TODATE_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case ONLY_NOT_PROCESSED:
+        if (value == null) {
+          unsetOnlyNotProcessed();
+        } else {
+          setOnlyNotProcessed((Boolean)value);
+        }
+        break;
+      case FROM_DATE:
+        if (value == null) {
+          unsetFromDate();
+        } else {
+          setFromDate((Long)value);
+        }
+        break;
+      case TO_DATE:
+        if (value == null) {
+          unsetToDate();
+        } else {
+          setToDate((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case ONLY_NOT_PROCESSED:
+        return Boolean.valueOf(isOnlyNotProcessed());
+      case FROM_DATE:
+        return Long.valueOf(getFromDate());
+      case TO_DATE:
+        return Long.valueOf(getToDate());
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case ONLY_NOT_PROCESSED:
+        return isSetOnlyNotProcessed();
+      case FROM_DATE:
+        return isSetFromDate();
+      case TO_DATE:
+        return isSetToDate();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getAllReturnOrders_args)
+        return this.equals((getAllReturnOrders_args)that);
+      return false;
+    }
+    public boolean equals(getAllReturnOrders_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_onlyNotProcessed = true;
+      boolean that_present_onlyNotProcessed = true;
+      if (this_present_onlyNotProcessed || that_present_onlyNotProcessed) {
+        if (!(this_present_onlyNotProcessed && that_present_onlyNotProcessed))
+          return false;
+        if (this.onlyNotProcessed != that.onlyNotProcessed)
+          return false;
+      }
+      boolean this_present_fromDate = true;
+      boolean that_present_fromDate = true;
+      if (this_present_fromDate || that_present_fromDate) {
+        if (!(this_present_fromDate && that_present_fromDate))
+          return false;
+        if (this.fromDate != that.fromDate)
+          return false;
+      }
+      boolean this_present_toDate = true;
+      boolean that_present_toDate = true;
+      if (this_present_toDate || that_present_toDate) {
+        if (!(this_present_toDate && that_present_toDate))
+          return false;
+        if (this.toDate != that.toDate)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAllReturnOrders_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAllReturnOrders_args typedOther = (getAllReturnOrders_args)other;
+      lastComparison = Boolean.valueOf(isSetOnlyNotProcessed()).compareTo(typedOther.isSetOnlyNotProcessed());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOnlyNotProcessed()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.onlyNotProcessed, typedOther.onlyNotProcessed);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetFromDate()).compareTo(typedOther.isSetFromDate());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetFromDate()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.fromDate, typedOther.fromDate);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetToDate()).compareTo(typedOther.isSetToDate());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetToDate()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.toDate, typedOther.toDate);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 1: // ONLY_NOT_PROCESSED
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.onlyNotProcessed = iprot.readBool();
+              setOnlyNotProcessedIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // FROM_DATE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.fromDate = iprot.readI64();
+              setFromDateIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // TO_DATE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.toDate = iprot.readI64();
+              setToDateIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      validate();
+      oprot.writeStructBegin(STRUCT_DESC);
+      oprot.writeFieldBegin(ONLY_NOT_PROCESSED_FIELD_DESC);
+      oprot.writeBool(this.onlyNotProcessed);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(FROM_DATE_FIELD_DESC);
+      oprot.writeI64(this.fromDate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TO_DATE_FIELD_DESC);
+      oprot.writeI64(this.toDate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAllReturnOrders_args(");
+      boolean first = true;
+      sb.append("onlyNotProcessed:");
+      sb.append(this.onlyNotProcessed);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("fromDate:");
+      sb.append(this.fromDate);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("toDate:");
+      sb.append(this.toDate);
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        // it doesn't seem like you should have to do this, but java serialization is wacky, and doesn't call the default constructor.
+        __isset_bit_vector = new BitSet(1);
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
+  public static class getAllReturnOrders_result implements org.apache.thrift.TBase<getAllReturnOrders_result, getAllReturnOrders_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getAllReturnOrders_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
+    private List<ReturnOrder> success; // required
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements org.apache.thrift.TFieldIdEnum {
+      SUCCESS((short)0, "success");
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          default:
+            return null;
+        }
+      }
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+      private final short _thriftId;
+      private final String _fieldName;
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+    // isset id assignments
+    public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new org.apache.thrift.meta_data.FieldMetaData("success", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
+              new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, ReturnOrder.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getAllReturnOrders_result.class, metaDataMap);
+    }
+    public getAllReturnOrders_result() {
+    }
+    public getAllReturnOrders_result(
+      List<ReturnOrder> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public getAllReturnOrders_result(getAllReturnOrders_result other) {
+      if (other.isSetSuccess()) {
+        List<ReturnOrder> __this__success = new ArrayList<ReturnOrder>();
+        for (ReturnOrder other_element : other.success) {
+          __this__success.add(new ReturnOrder(other_element));
+        }
+        this.success = __this__success;
+      }
+    }
+    public getAllReturnOrders_result deepCopy() {
+      return new getAllReturnOrders_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public java.util.Iterator<ReturnOrder> getSuccessIterator() {
+      return (this.success == null) ? null : this.success.iterator();
+    }
+    public void addToSuccess(ReturnOrder elem) {
+      if (this.success == null) {
+        this.success = new ArrayList<ReturnOrder>();
+      }
+      this.success.add(elem);
+    }
+    public List<ReturnOrder> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(List<ReturnOrder> success) {
+      this.success = success;
+    }
+    public void unsetSuccess() {
+      this.success = null;
+    }
+    /** Returns true if field success is set (has been assigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return this.success != null;
+    }
+    public void setSuccessIsSet(boolean value) {
+      if (!value) {
+        this.success = null;
+      }
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((List<ReturnOrder>)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return getSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof getAllReturnOrders_result)
+        return this.equals((getAllReturnOrders_result)that);
+      return false;
+    }
+    public boolean equals(getAllReturnOrders_result that) {
+      if (that == null)
+        return false;
+      boolean this_present_success = true && this.isSetSuccess();
+      boolean that_present_success = true && that.isSetSuccess();
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (!this.success.equals(that.success))
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(getAllReturnOrders_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      getAllReturnOrders_result typedOther = (getAllReturnOrders_result)other;
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+    public void read(org.apache.thrift.protocol.TProtocol iprot) throws org.apache.thrift.TException {
+      org.apache.thrift.protocol.TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == org.apache.thrift.protocol.TType.STOP) {
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
+                org.apache.thrift.protocol.TList _list221 = iprot.readListBegin();
+                this.success = new ArrayList<ReturnOrder>(_list221.size);
+                for (int _i222 = 0; _i222 < _list221.size; ++_i222)
+                {
+                  ReturnOrder _elem223; // required
+                  _elem223 = new ReturnOrder();
+                  _elem223.read(iprot);
+                  this.success.add(_elem223);
+                }
+                iprot.readListEnd();
+              }
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+    public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
+          for (ReturnOrder _iter224 : this.success)
+          {
+            _iter224.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("getAllReturnOrders_result(");
+      boolean first = true;
+      sb.append("success:");
+      if (this.success == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.success);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+    public void validate() throws org.apache.thrift.TException {
+      // check for required fields
+    }
+    private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException {
+      try {
+        write(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(out)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+    private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, ClassNotFoundException {
+      try {
+        read(new org.apache.thrift.protocol.TCompactProtocol(new org.apache.thrift.transport.TIOStreamTransport(in)));
+      } catch (org.apache.thrift.TException te) {
+        throw new java.io.IOException(te);
+      }
+    }
+  }
   public static class getReturnOrder_args implements org.apache.thrift.TBase<getReturnOrder_args, getReturnOrder_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getReturnOrder_args");
     private static final org.apache.thrift.protocol.TField ID_FIELD_DESC = new org.apache.thrift.protocol.TField("id", org.apache.thrift.protocol.TType.I64, (short)1);
+        }
         switch (field.id) {
           case 1: // COLLECTED_AMOUNT_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map221 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map225 = iprot.readMapBegin();
-                this.collectedAmountMap = new HashMap<String,Double>(2*_map221.size);
+                this.collectedAmountMap = new HashMap<String,Double>(2*_map225.size);
-                for (int _i222 = 0; _i222 < _map221.size; ++_i222)
+                for (int _i226 = 0; _i226 < _map225.size; ++_i226)
+                {
-                  String _key223; // required
+                  String _key227; // required
-                  double _val224; // required
+                  double _val228; // required
-                  _key223 = iprot.readString();
+                  _key227 = iprot.readString();
-                  _val224 = iprot.readDouble();
+                  _val228 = iprot.readDouble();
-                  this.collectedAmountMap.put(_key223, _val224);
+                  this.collectedAmountMap.put(_key227, _val228);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.collectedAmountMap != null) {
         oprot.writeFieldBegin(COLLECTED_AMOUNT_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.DOUBLE, this.collectedAmountMap.size()));
-          for (Map.Entry<String, Double> _iter225 : this.collectedAmountMap.entrySet())
+          for (Map.Entry<String, Double> _iter229 : this.collectedAmountMap.entrySet())
+          {
-            oprot.writeString(_iter225.getKey());
+            oprot.writeString(_iter229.getKey());
-            oprot.writeDouble(_iter225.getValue());
+            oprot.writeDouble(_iter229.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map226 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map230 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map226.size);
+                this.success = new HashMap<String,String>(2*_map230.size);
-                for (int _i227 = 0; _i227 < _map226.size; ++_i227)
+                for (int _i231 = 0; _i231 < _map230.size; ++_i231)
+                {
-                  String _key228; // required
+                  String _key232; // required
-                  String _val229; // required
+                  String _val233; // required
-                  _key228 = iprot.readString();
+                  _key232 = iprot.readString();
-                  _val229 = iprot.readString();
+                  _val233 = iprot.readString();
-                  this.success.put(_key228, _val229);
+                  this.success.put(_key232, _val233);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (Map.Entry<String, String> _iter230 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter234 : this.success.entrySet())
+          {
-            oprot.writeString(_iter230.getKey());
+            oprot.writeString(_iter234.getKey());
-            oprot.writeString(_iter230.getValue());
+            oprot.writeString(_iter234.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list231 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list235 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list231.size);
+                this.success = new ArrayList<Long>(_list235.size);
-                for (int _i232 = 0; _i232 < _list231.size; ++_i232)
+                for (int _i236 = 0; _i236 < _list235.size; ++_i236)
+                {
-                  long _elem233; // required
+                  long _elem237; // required
-                  _elem233 = iprot.readI64();
+                  _elem237 = iprot.readI64();
-                  this.success.add(_elem233);
+                  this.success.add(_elem237);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter234 : this.success)
+          for (long _iter238 : this.success)
+          {
-            oprot.writeI64(_iter234);
+            oprot.writeI64(_iter238);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map235 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map239 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map235.size);
+                this.success = new HashMap<Long,Long>(2*_map239.size);
-                for (int _i236 = 0; _i236 < _map235.size; ++_i236)
+                for (int _i240 = 0; _i240 < _map239.size; ++_i240)
+                {
-                  long _key237; // required
+                  long _key241; // required
-                  long _val238; // required
+                  long _val242; // required
-                  _key237 = iprot.readI64();
+                  _key241 = iprot.readI64();
-                  _val238 = iprot.readI64();
+                  _val242 = iprot.readI64();
-                  this.success.put(_key237, _val238);
+                  this.success.put(_key241, _val242);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (Map.Entry<Long, Long> _iter239 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter243 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter239.getKey());
+            oprot.writeI64(_iter243.getKey());
-            oprot.writeI64(_iter239.getValue());
+            oprot.writeI64(_iter243.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // ITEM_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list240 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list244 = iprot.readListBegin();
-                this.itemIds = new ArrayList<Long>(_list240.size);
+                this.itemIds = new ArrayList<Long>(_list244.size);
-                for (int _i241 = 0; _i241 < _list240.size; ++_i241)
+                for (int _i245 = 0; _i245 < _list244.size; ++_i245)
+                {
-                  long _elem242; // required
+                  long _elem246; // required
-                  _elem242 = iprot.readI64();
+                  _elem246 = iprot.readI64();
-                  this.itemIds.add(_elem242);
+                  this.itemIds.add(_elem246);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.itemIds != null) {
         oprot.writeFieldBegin(ITEM_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.itemIds.size()));
-          for (long _iter243 : this.itemIds)
+          for (long _iter247 : this.itemIds)
+          {
-            oprot.writeI64(_iter243);
+            oprot.writeI64(_iter247);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list244 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list248 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list244.size);
+                this.success = new ArrayList<Order>(_list248.size);
-                for (int _i245 = 0; _i245 < _list244.size; ++_i245)
+                for (int _i249 = 0; _i249 < _list248.size; ++_i249)
+                {
-                  Order _elem246; // required
+                  Order _elem250; // required
-                  _elem246 = new Order();
+                  _elem250 = new Order();
-                  _elem246.read(iprot);
+                  _elem250.read(iprot);
-                  this.success.add(_elem246);
+                  this.success.add(_elem250);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter247 : this.success)
+          for (Order _iter251 : this.success)
+          {
-            _iter247.write(oprot);
+            _iter251.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map248 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map252 = iprot.readMapBegin();
-                this.success = new HashMap<Integer,TimeoutSummary>(2*_map248.size);
+                this.success = new HashMap<Integer,TimeoutSummary>(2*_map252.size);
-                for (int _i249 = 0; _i249 < _map248.size; ++_i249)
+                for (int _i253 = 0; _i253 < _map252.size; ++_i253)
+                {
-                  int _key250; // required
+                  int _key254; // required
-                  TimeoutSummary _val251; // required
+                  TimeoutSummary _val255; // required
-                  _key250 = iprot.readI32();
+                  _key254 = iprot.readI32();
-                  _val251 = new TimeoutSummary();
+                  _val255 = new TimeoutSummary();
-                  _val251.read(iprot);
+                  _val255.read(iprot);
-                  this.success.put(_key250, _val251);
+                  this.success.put(_key254, _val255);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I32, org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Map.Entry<Integer, TimeoutSummary> _iter252 : this.success.entrySet())
+          for (Map.Entry<Integer, TimeoutSummary> _iter256 : this.success.entrySet())
+          {
-            oprot.writeI32(_iter252.getKey());
+            oprot.writeI32(_iter256.getKey());
-            _iter252.getValue().write(oprot);
+            _iter256.getValue().write(oprot);
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 2: // ORDER_STATUS_LIST
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list253 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list257 = iprot.readListBegin();
-                this.order_status_list = new ArrayList<OrderStatus>(_list253.size);
+                this.order_status_list = new ArrayList<OrderStatus>(_list257.size);
-                for (int _i254 = 0; _i254 < _list253.size; ++_i254)
+                for (int _i258 = 0; _i258 < _list257.size; ++_i258)
+                {
-                  OrderStatus _elem255; // required
+                  OrderStatus _elem259; // required
-                  _elem255 = OrderStatus.findByValue(iprot.readI32());
+                  _elem259 = OrderStatus.findByValue(iprot.readI32());
-                  this.order_status_list.add(_elem255);
+                  this.order_status_list.add(_elem259);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.order_status_list != null) {
         oprot.writeFieldBegin(ORDER_STATUS_LIST_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.order_status_list.size()));
-          for (OrderStatus _iter256 : this.order_status_list)
+          for (OrderStatus _iter260 : this.order_status_list)
+          {
-            oprot.writeI32(_iter256.getValue());
+            oprot.writeI32(_iter260.getValue());
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list257 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list261 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list257.size);
+                this.success = new ArrayList<Order>(_list261.size);
-                for (int _i258 = 0; _i258 < _list257.size; ++_i258)
+                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
+                {
-                  Order _elem259; // required
+                  Order _elem263; // required
-                  _elem259 = new Order();
+                  _elem263 = new Order();
-                  _elem259.read(iprot);
+                  _elem263.read(iprot);
-                  this.success.add(_elem259);
+                  this.success.add(_elem263);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter260 : this.success)
+          for (Order _iter264 : this.success)
+          {
-            _iter260.write(oprot);
+            _iter264.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list261 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list261.size);
+                this.success = new ArrayList<Order>(_list265.size);
-                for (int _i262 = 0; _i262 < _list261.size; ++_i262)
+                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                {
-                  Order _elem263; // required
+                  Order _elem267; // required
-                  _elem263 = new Order();
+                  _elem267 = new Order();
-                  _elem263.read(iprot);
+                  _elem267.read(iprot);
-                  this.success.add(_elem263);
+                  this.success.add(_elem267);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter264 : this.success)
+          for (Order _iter268 : this.success)
+          {
-            _iter264.write(oprot);
+            _iter268.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list265 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list269 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list265.size);
+                this.success = new ArrayList<Order>(_list269.size);
-                for (int _i266 = 0; _i266 < _list265.size; ++_i266)
+                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+                {
-                  Order _elem267; // required
+                  Order _elem271; // required
-                  _elem267 = new Order();
+                  _elem271 = new Order();
-                  _elem267.read(iprot);
+                  _elem271.read(iprot);
-                  this.success.add(_elem267);
+                  this.success.add(_elem271);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter268 : this.success)
+          for (Order _iter272 : this.success)
+          {
-            _iter268.write(oprot);
+            _iter272.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list269 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list273 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list269.size);
+                this.success = new ArrayList<Order>(_list273.size);
-                for (int _i270 = 0; _i270 < _list269.size; ++_i270)
+                for (int _i274 = 0; _i274 < _list273.size; ++_i274)
+                {
-                  Order _elem271; // required
+                  Order _elem275; // required
-                  _elem271 = new Order();
+                  _elem275 = new Order();
-                  _elem271.read(iprot);
+                  _elem275.read(iprot);
-                  this.success.add(_elem271);
+                  this.success.add(_elem275);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter272 : this.success)
+          for (Order _iter276 : this.success)
+          {
-            _iter272.write(oprot);
+            _iter276.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // MAP_AWBAND_AMOUNT
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map273 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map277 = iprot.readMapBegin();
-                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map273.size);
+                this.mapAWBAndAmount = new HashMap<Long,Double>(2*_map277.size);
-                for (int _i274 = 0; _i274 < _map273.size; ++_i274)
+                for (int _i278 = 0; _i278 < _map277.size; ++_i278)
+                {
-                  long _key275; // required
+                  long _key279; // required
-                  double _val276; // required
+                  double _val280; // required
-                  _key275 = iprot.readI64();
+                  _key279 = iprot.readI64();
-                  _val276 = iprot.readDouble();
+                  _val280 = iprot.readDouble();
-                  this.mapAWBAndAmount.put(_key275, _val276);
+                  this.mapAWBAndAmount.put(_key279, _val280);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.mapAWBAndAmount != null) {
         oprot.writeFieldBegin(MAP_AWBAND_AMOUNT_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.DOUBLE, this.mapAWBAndAmount.size()));
-          for (Map.Entry<Long, Double> _iter277 : this.mapAWBAndAmount.entrySet())
+          for (Map.Entry<Long, Double> _iter281 : this.mapAWBAndAmount.entrySet())
+          {
-            oprot.writeI64(_iter277.getKey());
+            oprot.writeI64(_iter281.getKey());
-            oprot.writeDouble(_iter277.getValue());
+            oprot.writeDouble(_iter281.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map278 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map282 = iprot.readMapBegin();
-                this.success = new HashMap<Long,String>(2*_map278.size);
+                this.success = new HashMap<Long,String>(2*_map282.size);
-                for (int _i279 = 0; _i279 < _map278.size; ++_i279)
+                for (int _i283 = 0; _i283 < _map282.size; ++_i283)
+                {
-                  long _key280; // required
+                  long _key284; // required
-                  String _val281; // required
+                  String _val285; // required
-                  _key280 = iprot.readI64();
+                  _key284 = iprot.readI64();
-                  _val281 = iprot.readString();
+                  _val285 = iprot.readString();
-                  this.success.put(_key280, _val281);
+                  this.success.put(_key284, _val285);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.STRING, this.success.size()));
-          for (Map.Entry<Long, String> _iter282 : this.success.entrySet())
+          for (Map.Entry<Long, String> _iter286 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter282.getKey());
+            oprot.writeI64(_iter286.getKey());
-            oprot.writeString(_iter282.getValue());
+            oprot.writeString(_iter286.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list283 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list287 = iprot.readListBegin();
-                this.success = new ArrayList<PaymentSettlement>(_list283.size);
+                this.success = new ArrayList<PaymentSettlement>(_list287.size);
-                for (int _i284 = 0; _i284 < _list283.size; ++_i284)
+                for (int _i288 = 0; _i288 < _list287.size; ++_i288)
+                {
-                  PaymentSettlement _elem285; // required
+                  PaymentSettlement _elem289; // required
-                  _elem285 = new PaymentSettlement();
+                  _elem289 = new PaymentSettlement();
-                  _elem285.read(iprot);
+                  _elem289.read(iprot);
-                  this.success.add(_elem285);
+                  this.success.add(_elem289);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (PaymentSettlement _iter286 : this.success)
+          for (PaymentSettlement _iter290 : this.success)
+          {
-            _iter286.write(oprot);
+            _iter290.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list287 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list291 = iprot.readListBegin();
-                this.orderIds = new ArrayList<Long>(_list287.size);
+                this.orderIds = new ArrayList<Long>(_list291.size);
-                for (int _i288 = 0; _i288 < _list287.size; ++_i288)
+                for (int _i292 = 0; _i292 < _list291.size; ++_i292)
+                {
-                  long _elem289; // required
+                  long _elem293; // required
-                  _elem289 = iprot.readI64();
+                  _elem293 = iprot.readI64();
-                  this.orderIds.add(_elem289);
+                  this.orderIds.add(_elem293);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.orderIds != null) {
         oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.orderIds.size()));
-          for (long _iter290 : this.orderIds)
+          for (long _iter294 : this.orderIds)
+          {
-            oprot.writeI64(_iter290);
+            oprot.writeI64(_iter294);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list291 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list295 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list291.size);
+                this.success = new ArrayList<Long>(_list295.size);
-                for (int _i292 = 0; _i292 < _list291.size; ++_i292)
+                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                {
-                  long _elem293; // required
+                  long _elem297; // required
-                  _elem293 = iprot.readI64();
+                  _elem297 = iprot.readI64();
-                  this.success.add(_elem293);
+                  this.success.add(_elem297);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter294 : this.success)
+          for (long _iter298 : this.success)
+          {
-            oprot.writeI64(_iter294);
+            oprot.writeI64(_iter298);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+      }
+    }
+  }
-  public static class getOrdersWhereVendorNotPaid_args implements org.apache.thrift.TBase<getOrdersWhereVendorNotPaid_args, getOrdersWhereVendorNotPaid_args._Fields>, java.io.Serializable, Cloneable   {
+  public static class getBilledOrders_args implements org.apache.thrift.TBase<getBilledOrders_args, getBilledOrders_args._Fields>, java.io.Serializable, Cloneable   {
-    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersWhereVendorNotPaid_args");
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getBilledOrders_args");
     private static final org.apache.thrift.protocol.TField VENDOR_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("vendorId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField ONLY_VENDOR_NOT_PAID_FIELD_DESC = new org.apache.thrift.protocol.TField("onlyVendorNotPaid", org.apache.thrift.protocol.TType.BOOL, (short)2);
+    private static final org.apache.thrift.protocol.TField BILLING_DATE_FROM_FIELD_DESC = new org.apache.thrift.protocol.TField("billingDateFrom", org.apache.thrift.protocol.TType.I64, (short)3);
+    private static final org.apache.thrift.protocol.TField BILLING_DATE_TO_FIELD_DESC = new org.apache.thrift.protocol.TField("billingDateTo", org.apache.thrift.protocol.TType.I64, (short)4);
     private long vendorId; // required
+    private boolean onlyVendorNotPaid; // required
+    private long billingDateFrom; // required
+    private long billingDateTo; // required
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements org.apache.thrift.TFieldIdEnum {
-      VENDOR_ID((short)1, "vendorId");
+      VENDOR_ID((short)1, "vendorId"),
+      ONLY_VENDOR_NOT_PAID((short)2, "onlyVendorNotPaid"),
+      BILLING_DATE_FROM((short)3, "billingDateFrom"),
+      BILLING_DATE_TO((short)4, "billingDateTo");
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
         for (_Fields field : EnumSet.allOf(_Fields.class)) {
        */
       public static _Fields findByThriftId(int fieldId) {
         switch(fieldId) {
           case 1: // VENDOR_ID
             return VENDOR_ID;
+          case 2: // ONLY_VENDOR_NOT_PAID
+            return ONLY_VENDOR_NOT_PAID;
+          case 3: // BILLING_DATE_FROM
+            return BILLING_DATE_FROM;
+          case 4: // BILLING_DATE_TO
+            return BILLING_DATE_TO;
           default:
             return null;
+        }
+      }
+      }
+    }
     // isset id assignments
     private static final int __VENDORID_ISSET_ID = 0;
+    private static final int __ONLYVENDORNOTPAID_ISSET_ID = 1;
+    private static final int __BILLINGDATEFROM_ISSET_ID = 2;
+    private static final int __BILLINGDATETO_ISSET_ID = 3;
-    private BitSet __isset_bit_vector = new BitSet(1);
+    private BitSet __isset_bit_vector = new BitSet(4);
     public static final Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> metaDataMap;
     static {
       Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields, org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
       tmpMap.put(_Fields.VENDOR_ID, new org.apache.thrift.meta_data.FieldMetaData("vendorId", org.apache.thrift.TFieldRequirementType.DEFAULT,
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.ONLY_VENDOR_NOT_PAID, new org.apache.thrift.meta_data.FieldMetaData("onlyVendorNotPaid", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
+      tmpMap.put(_Fields.BILLING_DATE_FROM, new org.apache.thrift.meta_data.FieldMetaData("billingDateFrom", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.BILLING_DATE_TO, new org.apache.thrift.meta_data.FieldMetaData("billingDateTo", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
-      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersWhereVendorNotPaid_args.class, metaDataMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getBilledOrders_args.class, metaDataMap);
+    }
-    public getOrdersWhereVendorNotPaid_args() {
+    public getBilledOrders_args() {
+    }
-    public getOrdersWhereVendorNotPaid_args(
+    public getBilledOrders_args(
-      long vendorId)
+      long vendorId,
+      boolean onlyVendorNotPaid,
+      long billingDateFrom,
+      long billingDateTo)
+    {
       this();
       this.vendorId = vendorId;
       setVendorIdIsSet(true);
+      this.onlyVendorNotPaid = onlyVendorNotPaid;
+      setOnlyVendorNotPaidIsSet(true);
+      this.billingDateFrom = billingDateFrom;
+      setBillingDateFromIsSet(true);
+      this.billingDateTo = billingDateTo;
+      setBillingDateToIsSet(true);
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getOrdersWhereVendorNotPaid_args(getOrdersWhereVendorNotPaid_args other) {
+    public getBilledOrders_args(getBilledOrders_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.vendorId = other.vendorId;
+      this.onlyVendorNotPaid = other.onlyVendorNotPaid;
+      this.billingDateFrom = other.billingDateFrom;
+      this.billingDateTo = other.billingDateTo;
+    }
-    public getOrdersWhereVendorNotPaid_args deepCopy() {
+    public getBilledOrders_args deepCopy() {
-      return new getOrdersWhereVendorNotPaid_args(this);
+      return new getBilledOrders_args(this);
+    }
     @Override
     public void clear() {
       setVendorIdIsSet(false);
       this.vendorId = 0;
+      setOnlyVendorNotPaidIsSet(false);
+      this.onlyVendorNotPaid = false;
+      setBillingDateFromIsSet(false);
+      this.billingDateFrom = 0;
+      setBillingDateToIsSet(false);
+      this.billingDateTo = 0;
+    }
     public long getVendorId() {
       return this.vendorId;
+    }
     public void setVendorIdIsSet(boolean value) {
       __isset_bit_vector.set(__VENDORID_ISSET_ID, value);
+    }
+    public boolean isOnlyVendorNotPaid() {
+      return this.onlyVendorNotPaid;
+    }
+    public void setOnlyVendorNotPaid(boolean onlyVendorNotPaid) {
+      this.onlyVendorNotPaid = onlyVendorNotPaid;
+      setOnlyVendorNotPaidIsSet(true);
+    }
+    public void unsetOnlyVendorNotPaid() {
+      __isset_bit_vector.clear(__ONLYVENDORNOTPAID_ISSET_ID);
+    }
+    /** Returns true if field onlyVendorNotPaid is set (has been assigned a value) and false otherwise */
+    public boolean isSetOnlyVendorNotPaid() {
+      return __isset_bit_vector.get(__ONLYVENDORNOTPAID_ISSET_ID);
+    }
+    public void setOnlyVendorNotPaidIsSet(boolean value) {
+      __isset_bit_vector.set(__ONLYVENDORNOTPAID_ISSET_ID, value);
+    }
+    public long getBillingDateFrom() {
+      return this.billingDateFrom;
+    }
+    public void setBillingDateFrom(long billingDateFrom) {
+      this.billingDateFrom = billingDateFrom;
+      setBillingDateFromIsSet(true);
+    }
+    public void unsetBillingDateFrom() {
+      __isset_bit_vector.clear(__BILLINGDATEFROM_ISSET_ID);
+    }
+    /** Returns true if field billingDateFrom is set (has been assigned a value) and false otherwise */
+    public boolean isSetBillingDateFrom() {
+      return __isset_bit_vector.get(__BILLINGDATEFROM_ISSET_ID);
+    }
+    public void setBillingDateFromIsSet(boolean value) {
+      __isset_bit_vector.set(__BILLINGDATEFROM_ISSET_ID, value);
+    }
+    public long getBillingDateTo() {
+      return this.billingDateTo;
+    }
+    public void setBillingDateTo(long billingDateTo) {
+      this.billingDateTo = billingDateTo;
+      setBillingDateToIsSet(true);
+    }
+    public void unsetBillingDateTo() {
+      __isset_bit_vector.clear(__BILLINGDATETO_ISSET_ID);
+    }
+    /** Returns true if field billingDateTo is set (has been assigned a value) and false otherwise */
+    public boolean isSetBillingDateTo() {
+      return __isset_bit_vector.get(__BILLINGDATETO_ISSET_ID);
+    }
+    public void setBillingDateToIsSet(boolean value) {
+      __isset_bit_vector.set(__BILLINGDATETO_ISSET_ID, value);
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case VENDOR_ID:
         if (value == null) {
           unsetVendorId();
         } else {
           setVendorId((Long)value);
+        }
         break;
+      case ONLY_VENDOR_NOT_PAID:
+        if (value == null) {
+          unsetOnlyVendorNotPaid();
+        } else {
+          setOnlyVendorNotPaid((Boolean)value);
+        }
+        break;
+      case BILLING_DATE_FROM:
+        if (value == null) {
+          unsetBillingDateFrom();
+        } else {
+          setBillingDateFrom((Long)value);
+        }
+        break;
+      case BILLING_DATE_TO:
+        if (value == null) {
+          unsetBillingDateTo();
+        } else {
+          setBillingDateTo((Long)value);
+        }
+        break;
+      }
+    }
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case VENDOR_ID:
         return Long.valueOf(getVendorId());
+      case ONLY_VENDOR_NOT_PAID:
+        return Boolean.valueOf(isOnlyVendorNotPaid());
+      case BILLING_DATE_FROM:
+        return Long.valueOf(getBillingDateFrom());
+      case BILLING_DATE_TO:
+        return Long.valueOf(getBillingDateTo());
+      }
       throw new IllegalStateException();
+    }
     /** Returns true if field corresponding to fieldID is set (has been assigned a value) and false otherwise */
+      }
       switch (field) {
       case VENDOR_ID:
         return isSetVendorId();
+      case ONLY_VENDOR_NOT_PAID:
+        return isSetOnlyVendorNotPaid();
+      case BILLING_DATE_FROM:
+        return isSetBillingDateFrom();
+      case BILLING_DATE_TO:
+        return isSetBillingDateTo();
+      }
       throw new IllegalStateException();
+    }
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getOrdersWhereVendorNotPaid_args)
+      if (that instanceof getBilledOrders_args)
-        return this.equals((getOrdersWhereVendorNotPaid_args)that);
+        return this.equals((getBilledOrders_args)that);
       return false;
+    }
-    public boolean equals(getOrdersWhereVendorNotPaid_args that) {
+    public boolean equals(getBilledOrders_args that) {
       if (that == null)
         return false;
       boolean this_present_vendorId = true;
       boolean that_present_vendorId = true;
           return false;
         if (this.vendorId != that.vendorId)
           return false;
+      }
+      boolean this_present_onlyVendorNotPaid = true;
+      boolean that_present_onlyVendorNotPaid = true;
+      if (this_present_onlyVendorNotPaid || that_present_onlyVendorNotPaid) {
+        if (!(this_present_onlyVendorNotPaid && that_present_onlyVendorNotPaid))
+          return false;
+        if (this.onlyVendorNotPaid != that.onlyVendorNotPaid)
+          return false;
+      }
+      boolean this_present_billingDateFrom = true;
+      boolean that_present_billingDateFrom = true;
+      if (this_present_billingDateFrom || that_present_billingDateFrom) {
+        if (!(this_present_billingDateFrom && that_present_billingDateFrom))
+          return false;
+        if (this.billingDateFrom != that.billingDateFrom)
+          return false;
+      }
+      boolean this_present_billingDateTo = true;
+      boolean that_present_billingDateTo = true;
+      if (this_present_billingDateTo || that_present_billingDateTo) {
+        if (!(this_present_billingDateTo && that_present_billingDateTo))
+          return false;
+        if (this.billingDateTo != that.billingDateTo)
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getOrdersWhereVendorNotPaid_args other) {
+    public int compareTo(getBilledOrders_args other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getOrdersWhereVendorNotPaid_args typedOther = (getOrdersWhereVendorNotPaid_args)other;
+      getBilledOrders_args typedOther = (getBilledOrders_args)other;
       lastComparison = Boolean.valueOf(isSetVendorId()).compareTo(typedOther.isSetVendorId());
       if (lastComparison != 0) {
         return lastComparison;
+      }
         lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.vendorId, typedOther.vendorId);
         if (lastComparison != 0) {
           return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetOnlyVendorNotPaid()).compareTo(typedOther.isSetOnlyVendorNotPaid());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetOnlyVendorNotPaid()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.onlyVendorNotPaid, typedOther.onlyVendorNotPaid);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetBillingDateFrom()).compareTo(typedOther.isSetBillingDateFrom());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetBillingDateFrom()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.billingDateFrom, typedOther.billingDateFrom);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetBillingDateTo()).compareTo(typedOther.isSetBillingDateTo());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetBillingDateTo()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.billingDateTo, typedOther.billingDateTo);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
       return 0;
+    }
     public _Fields fieldForId(int fieldId) {
       return _Fields.findByThriftId(fieldId);
               setVendorIdIsSet(true);
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
             break;
+          case 2: // ONLY_VENDOR_NOT_PAID
+            if (field.type == org.apache.thrift.protocol.TType.BOOL) {
+              this.onlyVendorNotPaid = iprot.readBool();
+              setOnlyVendorNotPaidIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // BILLING_DATE_FROM
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.billingDateFrom = iprot.readI64();
+              setBillingDateFromIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // BILLING_DATE_TO
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.billingDateTo = iprot.readI64();
+              setBillingDateToIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
           default:
             org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+        }
         iprot.readFieldEnd();
+      }
       oprot.writeStructBegin(STRUCT_DESC);
       oprot.writeFieldBegin(VENDOR_ID_FIELD_DESC);
       oprot.writeI64(this.vendorId);
       oprot.writeFieldEnd();
+      oprot.writeFieldBegin(ONLY_VENDOR_NOT_PAID_FIELD_DESC);
+      oprot.writeBool(this.onlyVendorNotPaid);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(BILLING_DATE_FROM_FIELD_DESC);
+      oprot.writeI64(this.billingDateFrom);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(BILLING_DATE_TO_FIELD_DESC);
+      oprot.writeI64(this.billingDateTo);
+      oprot.writeFieldEnd();
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getOrdersWhereVendorNotPaid_args(");
+      StringBuilder sb = new StringBuilder("getBilledOrders_args(");
       boolean first = true;
       sb.append("vendorId:");
       sb.append(this.vendorId);
       first = false;
+      if (!first) sb.append(", ");
+      sb.append("onlyVendorNotPaid:");
+      sb.append(this.onlyVendorNotPaid);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("billingDateFrom:");
+      sb.append(this.billingDateFrom);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("billingDateTo:");
+      sb.append(this.billingDateTo);
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws org.apache.thrift.TException {
+      }
+    }
+  }
-  public static class getOrdersWhereVendorNotPaid_result implements org.apache.thrift.TBase<getOrdersWhereVendorNotPaid_result, getOrdersWhereVendorNotPaid_result._Fields>, java.io.Serializable, Cloneable   {
+  public static class getBilledOrders_result implements org.apache.thrift.TBase<getBilledOrders_result, getBilledOrders_result._Fields>, java.io.Serializable, Cloneable   {
-    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getOrdersWhereVendorNotPaid_result");
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getBilledOrders_result");
     private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.LIST, (short)0);
     private static final org.apache.thrift.protocol.TField EX_FIELD_DESC = new org.apache.thrift.protocol.TField("ex", org.apache.thrift.protocol.TType.STRUCT, (short)1);
     private List<Order> success; // required
           new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,
               new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT, Order.class))));
       tmpMap.put(_Fields.EX, new org.apache.thrift.meta_data.FieldMetaData("ex", org.apache.thrift.TFieldRequirementType.DEFAULT,
           new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRUCT)));
       metaDataMap = Collections.unmodifiableMap(tmpMap);
-      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getOrdersWhereVendorNotPaid_result.class, metaDataMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(getBilledOrders_result.class, metaDataMap);
+    }
-    public getOrdersWhereVendorNotPaid_result() {
+    public getBilledOrders_result() {
+    }
-    public getOrdersWhereVendorNotPaid_result(
+    public getBilledOrders_result(
       List<Order> success,
       TransactionServiceException ex)
+    {
       this();
       this.success = success;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
-    public getOrdersWhereVendorNotPaid_result(getOrdersWhereVendorNotPaid_result other) {
+    public getBilledOrders_result(getBilledOrders_result other) {
       if (other.isSetSuccess()) {
         List<Order> __this__success = new ArrayList<Order>();
         for (Order other_element : other.success) {
           __this__success.add(new Order(other_element));
+        }
       if (other.isSetEx()) {
         this.ex = new TransactionServiceException(other.ex);
+      }
+    }
-    public getOrdersWhereVendorNotPaid_result deepCopy() {
+    public getBilledOrders_result deepCopy() {
-      return new getOrdersWhereVendorNotPaid_result(this);
+      return new getBilledOrders_result(this);
+    }
     @Override
     public void clear() {
       this.success = null;
     @Override
     public boolean equals(Object that) {
       if (that == null)
         return false;
-      if (that instanceof getOrdersWhereVendorNotPaid_result)
+      if (that instanceof getBilledOrders_result)
-        return this.equals((getOrdersWhereVendorNotPaid_result)that);
+        return this.equals((getBilledOrders_result)that);
       return false;
+    }
-    public boolean equals(getOrdersWhereVendorNotPaid_result that) {
+    public boolean equals(getBilledOrders_result that) {
       if (that == null)
         return false;
       boolean this_present_success = true && this.isSetSuccess();
       boolean that_present_success = true && that.isSetSuccess();
     @Override
     public int hashCode() {
       return 0;
+    }
-    public int compareTo(getOrdersWhereVendorNotPaid_result other) {
+    public int compareTo(getBilledOrders_result other) {
       if (!getClass().equals(other.getClass())) {
         return getClass().getName().compareTo(other.getClass().getName());
+      }
       int lastComparison = 0;
-      getOrdersWhereVendorNotPaid_result typedOther = (getOrdersWhereVendorNotPaid_result)other;
+      getBilledOrders_result typedOther = (getBilledOrders_result)other;
       lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
       if (lastComparison != 0) {
         return lastComparison;
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list295 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list299 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list295.size);
+                this.success = new ArrayList<Order>(_list299.size);
-                for (int _i296 = 0; _i296 < _list295.size; ++_i296)
+                for (int _i300 = 0; _i300 < _list299.size; ++_i300)
+                {
-                  Order _elem297; // required
+                  Order _elem301; // required
-                  _elem297 = new Order();
+                  _elem301 = new Order();
-                  _elem297.read(iprot);
+                  _elem301.read(iprot);
-                  this.success.add(_elem297);
+                  this.success.add(_elem301);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter298 : this.success)
+          for (Order _iter302 : this.success)
+          {
-            _iter298.write(oprot);
+            _iter302.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
       oprot.writeStructEnd();
+    }
     @Override
     public String toString() {
-      StringBuilder sb = new StringBuilder("getOrdersWhereVendorNotPaid_result(");
+      StringBuilder sb = new StringBuilder("getBilledOrders_result(");
       boolean first = true;
       sb.append("success:");
       if (this.success == null) {
         sb.append("null");
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map299 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map303 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Long>(2*_map299.size);
+                this.success = new HashMap<Long,Long>(2*_map303.size);
-                for (int _i300 = 0; _i300 < _map299.size; ++_i300)
+                for (int _i304 = 0; _i304 < _map303.size; ++_i304)
+                {
-                  long _key301; // required
+                  long _key305; // required
-                  long _val302; // required
+                  long _val306; // required
-                  _key301 = iprot.readI64();
+                  _key305 = iprot.readI64();
-                  _val302 = iprot.readI64();
+                  _val306 = iprot.readI64();
-                  this.success.put(_key301, _val302);
+                  this.success.put(_key305, _val306);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (Map.Entry<Long, Long> _iter303 : this.success.entrySet())
+          for (Map.Entry<Long, Long> _iter307 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter303.getKey());
+            oprot.writeI64(_iter307.getKey());
-            oprot.writeI64(_iter303.getValue());
+            oprot.writeI64(_iter307.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list304 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list308 = iprot.readListBegin();
-                this.success = new ArrayList<Long>(_list304.size);
+                this.success = new ArrayList<Long>(_list308.size);
-                for (int _i305 = 0; _i305 < _list304.size; ++_i305)
+                for (int _i309 = 0; _i309 < _list308.size; ++_i309)
+                {
-                  long _elem306; // required
+                  long _elem310; // required
-                  _elem306 = iprot.readI64();
+                  _elem310 = iprot.readI64();
-                  this.success.add(_elem306);
+                  this.success.add(_elem310);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.success.size()));
-          for (long _iter307 : this.success)
+          for (long _iter311 : this.success)
+          {
-            oprot.writeI64(_iter307);
+            oprot.writeI64(_iter311);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list308 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list312 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list308.size);
+                this.success = new ArrayList<Order>(_list312.size);
-                for (int _i309 = 0; _i309 < _list308.size; ++_i309)
+                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                {
-                  Order _elem310; // required
+                  Order _elem314; // required
-                  _elem310 = new Order();
+                  _elem314 = new Order();
-                  _elem310.read(iprot);
+                  _elem314.read(iprot);
-                  this.success.add(_elem310);
+                  this.success.add(_elem314);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (Order _iter311 : this.success)
+          for (Order _iter315 : this.success)
+          {
-            _iter311.write(oprot);
+            _iter315.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list312 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list316 = iprot.readListBegin();
-                this.success = new ArrayList<CODVerificationAgent>(_list312.size);
+                this.success = new ArrayList<CODVerificationAgent>(_list316.size);
-                for (int _i313 = 0; _i313 < _list312.size; ++_i313)
+                for (int _i317 = 0; _i317 < _list316.size; ++_i317)
+                {
-                  CODVerificationAgent _elem314; // required
+                  CODVerificationAgent _elem318; // required
-                  _elem314 = new CODVerificationAgent();
+                  _elem318 = new CODVerificationAgent();
-                  _elem314.read(iprot);
+                  _elem318.read(iprot);
-                  this.success.add(_elem314);
+                  this.success.add(_elem318);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       if (this.isSetSuccess()) {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.success.size()));
-          for (CODVerificationAgent _iter315 : this.success)
+          for (CODVerificationAgent _iter319 : this.success)
+          {
-            _iter315.write(oprot);
+            _iter319.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

(root)//trunk/ThriftConfig/src/main/java/in/shop2020/model/v1/order/TransactionService.java – Rev 5447 → 5481