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

     public PaginatedUserSanction getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, String sort) throws org.apache.thrift.TException;
     public List<OutstandingPayments> getOutstandingPayments(String fetchType, long userId, long limit) throws org.apache.thrift.TException;
+    public Map<Boolean,String> markPaymentSettled(long userId, long paymentId, double totalAmount, long repaymentDate) throws org.apache.thrift.TException;
     public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException;
     public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoList(List<Long> order_ids) throws org.apache.thrift.TException;
     public Map<Long,List<ReturnOrderInfo>> getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses) throws org.apache.thrift.TException;
     public void getUserSanctionsDetailsAsPerLimit(long userId, long creditorId, long limit, long offset, String sort, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getUserSanctionsDetailsAsPerLimit_call> resultHandler) throws org.apache.thrift.TException;
     public void getOutstandingPayments(String fetchType, long userId, long limit, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getOutstandingPayments_call> resultHandler) throws org.apache.thrift.TException;
+    public void markPaymentSettled(long userId, long paymentId, double totalAmount, long repaymentDate, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.markPaymentSettled_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfoList(List<Long> order_ids, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoList_call> resultHandler) throws org.apache.thrift.TException;
     public void getReturnOrderInfoListAsByStatus(List<Long> order_ids, List<String> statuses, org.apache.thrift.async.AsyncMethodCallback<AsyncClient.getReturnOrderInfoListAsByStatus_call> resultHandler) throws org.apache.thrift.TException;
         return result.success;
+      }
       throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "getOutstandingPayments failed: unknown result");
+    }
+    public Map<Boolean,String> markPaymentSettled(long userId, long paymentId, double totalAmount, long repaymentDate) throws org.apache.thrift.TException
+    {
+      send_markPaymentSettled(userId, paymentId, totalAmount, repaymentDate);
+      return recv_markPaymentSettled();
+    }
+    public void send_markPaymentSettled(long userId, long paymentId, double totalAmount, long repaymentDate) throws org.apache.thrift.TException
+    {
+      markPaymentSettled_args args = new markPaymentSettled_args();
+      args.setUserId(userId);
+      args.setPaymentId(paymentId);
+      args.setTotalAmount(totalAmount);
+      args.setRepaymentDate(repaymentDate);
+      sendBase("markPaymentSettled", args);
+    }
+    public Map<Boolean,String> recv_markPaymentSettled() throws org.apache.thrift.TException
+    {
+      markPaymentSettled_result result = new markPaymentSettled_result();
+      receiveBase(result, "markPaymentSettled");
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      throw new org.apache.thrift.TApplicationException(org.apache.thrift.TApplicationException.MISSING_RESULT, "markPaymentSettled failed: unknown result");
+    }
     public ReturnOrderInfo getReturnOrderInfo(long id) throws TransactionServiceException, org.apache.thrift.TException
+    {
       send_getReturnOrderInfo(id);
       return recv_getReturnOrderInfo();
+    }
         org.apache.thrift.protocol.TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
         return (new Client(prot)).recv_getOutstandingPayments();
+      }
+    }
+    public void markPaymentSettled(long userId, long paymentId, double totalAmount, long repaymentDate, org.apache.thrift.async.AsyncMethodCallback<markPaymentSettled_call> resultHandler) throws org.apache.thrift.TException {
+      checkReady();
+      markPaymentSettled_call method_call = new markPaymentSettled_call(userId, paymentId, totalAmount, repaymentDate, resultHandler, this, ___protocolFactory, ___transport);
+      this.___currentMethod = method_call;
+      ___manager.call(method_call);
+    }
+    public static class markPaymentSettled_call extends org.apache.thrift.async.TAsyncMethodCall {
+      private long userId;
+      private long paymentId;
+      private double totalAmount;
+      private long repaymentDate;
+      public markPaymentSettled_call(long userId, long paymentId, double totalAmount, long repaymentDate, org.apache.thrift.async.AsyncMethodCallback<markPaymentSettled_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.userId = userId;
+        this.paymentId = paymentId;
+        this.totalAmount = totalAmount;
+        this.repaymentDate = repaymentDate;
+      }
+      public void write_args(org.apache.thrift.protocol.TProtocol prot) throws org.apache.thrift.TException {
+        prot.writeMessageBegin(new org.apache.thrift.protocol.TMessage("markPaymentSettled", org.apache.thrift.protocol.TMessageType.CALL, 0));
+        markPaymentSettled_args args = new markPaymentSettled_args();
+        args.setUserId(userId);
+        args.setPaymentId(paymentId);
+        args.setTotalAmount(totalAmount);
+        args.setRepaymentDate(repaymentDate);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+      public Map<Boolean,String> 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_markPaymentSettled();
+      }
+    }
     public void getReturnOrderInfo(long id, org.apache.thrift.async.AsyncMethodCallback<getReturnOrderInfo_call> resultHandler) throws org.apache.thrift.TException {
       checkReady();
       getReturnOrderInfo_call method_call = new getReturnOrderInfo_call(id, resultHandler, this, ___protocolFactory, ___transport);
       this.___currentMethod = method_call;
       ___manager.call(method_call);
       processMap.put("processLoanTransaction", new processLoanTransaction());
       processMap.put("getLimitedCreditHistoryRecords", new getLimitedCreditHistoryRecords());
       processMap.put("getLimitedLoanHistoryRecords", new getLimitedLoanHistoryRecords());
       processMap.put("getUserSanctionsDetailsAsPerLimit", new getUserSanctionsDetailsAsPerLimit());
       processMap.put("getOutstandingPayments", new getOutstandingPayments());
+      processMap.put("markPaymentSettled", new markPaymentSettled());
       processMap.put("getReturnOrderInfo", new getReturnOrderInfo());
       processMap.put("getReturnOrderInfoList", new getReturnOrderInfoList());
       processMap.put("getReturnOrderInfoListAsByStatus", new getReturnOrderInfoListAsByStatus());
       processMap.put("updateReturnOrderInfo", new updateReturnOrderInfo());
       processMap.put("bulkUpdateReturnOrderInfo", new bulkUpdateReturnOrderInfo());
         result.success = iface.getOutstandingPayments(args.fetchType, args.userId, args.limit);
         return result;
+      }
+    }
+    private static class markPaymentSettled<I extends Iface> extends org.apache.thrift.ProcessFunction<I, markPaymentSettled_args> {
+      public markPaymentSettled() {
+        super("markPaymentSettled");
+      }
+      protected markPaymentSettled_args getEmptyArgsInstance() {
+        return new markPaymentSettled_args();
+      }
+      protected markPaymentSettled_result getResult(I iface, markPaymentSettled_args args) throws org.apache.thrift.TException {
+        markPaymentSettled_result result = new markPaymentSettled_result();
+        result.success = iface.markPaymentSettled(args.userId, args.paymentId, args.totalAmount, args.repaymentDate);
+        return result;
+      }
+    }
     private static class getReturnOrderInfo<I extends Iface> extends org.apache.thrift.ProcessFunction<I, getReturnOrderInfo_args> {
       public getReturnOrderInfo() {
         super("getReturnOrderInfo");
+      }
+      }
+    }
+  }
+  public static class markPaymentSettled_args implements org.apache.thrift.TBase<markPaymentSettled_args, markPaymentSettled_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markPaymentSettled_args");
+    private static final org.apache.thrift.protocol.TField USER_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("userId", org.apache.thrift.protocol.TType.I64, (short)1);
+    private static final org.apache.thrift.protocol.TField PAYMENT_ID_FIELD_DESC = new org.apache.thrift.protocol.TField("paymentId", org.apache.thrift.protocol.TType.I64, (short)2);
+    private static final org.apache.thrift.protocol.TField TOTAL_AMOUNT_FIELD_DESC = new org.apache.thrift.protocol.TField("totalAmount", org.apache.thrift.protocol.TType.DOUBLE, (short)3);
+    private static final org.apache.thrift.protocol.TField REPAYMENT_DATE_FIELD_DESC = new org.apache.thrift.protocol.TField("repaymentDate", org.apache.thrift.protocol.TType.I64, (short)4);
+    private long userId; // required
+    private long paymentId; // required
+    private double totalAmount; // required
+    private long repaymentDate; // 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 {
+      USER_ID((short)1, "userId"),
+      PAYMENT_ID((short)2, "paymentId"),
+      TOTAL_AMOUNT((short)3, "totalAmount"),
+      REPAYMENT_DATE((short)4, "repaymentDate");
+      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: // USER_ID
+            return USER_ID;
+          case 2: // PAYMENT_ID
+            return PAYMENT_ID;
+          case 3: // TOTAL_AMOUNT
+            return TOTAL_AMOUNT;
+          case 4: // REPAYMENT_DATE
+            return REPAYMENT_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 __USERID_ISSET_ID = 0;
+    private static final int __PAYMENTID_ISSET_ID = 1;
+    private static final int __TOTALAMOUNT_ISSET_ID = 2;
+    private static final int __REPAYMENTDATE_ISSET_ID = 3;
+    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.USER_ID, new org.apache.thrift.meta_data.FieldMetaData("userId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.PAYMENT_ID, new org.apache.thrift.meta_data.FieldMetaData("paymentId", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.I64)));
+      tmpMap.put(_Fields.TOTAL_AMOUNT, new org.apache.thrift.meta_data.FieldMetaData("totalAmount", org.apache.thrift.TFieldRequirementType.DEFAULT,
+          new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.DOUBLE)));
+      tmpMap.put(_Fields.REPAYMENT_DATE, new org.apache.thrift.meta_data.FieldMetaData("repaymentDate", 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(markPaymentSettled_args.class, metaDataMap);
+    }
+    public markPaymentSettled_args() {
+    }
+    public markPaymentSettled_args(
+      long userId,
+      long paymentId,
+      double totalAmount,
+      long repaymentDate)
+    {
+      this();
+      this.userId = userId;
+      setUserIdIsSet(true);
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+      this.totalAmount = totalAmount;
+      setTotalAmountIsSet(true);
+      this.repaymentDate = repaymentDate;
+      setRepaymentDateIsSet(true);
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markPaymentSettled_args(markPaymentSettled_args other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.userId = other.userId;
+      this.paymentId = other.paymentId;
+      this.totalAmount = other.totalAmount;
+      this.repaymentDate = other.repaymentDate;
+    }
+    public markPaymentSettled_args deepCopy() {
+      return new markPaymentSettled_args(this);
+    }
+    @Override
+    public void clear() {
+      setUserIdIsSet(false);
+      this.userId = 0;
+      setPaymentIdIsSet(false);
+      this.paymentId = 0;
+      setTotalAmountIsSet(false);
+      this.totalAmount = 0.0;
+      setRepaymentDateIsSet(false);
+      this.repaymentDate = 0;
+    }
+    public long getUserId() {
+      return this.userId;
+    }
+    public void setUserId(long userId) {
+      this.userId = userId;
+      setUserIdIsSet(true);
+    }
+    public void unsetUserId() {
+      __isset_bit_vector.clear(__USERID_ISSET_ID);
+    }
+    /** Returns true if field userId is set (has been assigned a value) and false otherwise */
+    public boolean isSetUserId() {
+      return __isset_bit_vector.get(__USERID_ISSET_ID);
+    }
+    public void setUserIdIsSet(boolean value) {
+      __isset_bit_vector.set(__USERID_ISSET_ID, value);
+    }
+    public long getPaymentId() {
+      return this.paymentId;
+    }
+    public void setPaymentId(long paymentId) {
+      this.paymentId = paymentId;
+      setPaymentIdIsSet(true);
+    }
+    public void unsetPaymentId() {
+      __isset_bit_vector.clear(__PAYMENTID_ISSET_ID);
+    }
+    /** Returns true if field paymentId is set (has been assigned a value) and false otherwise */
+    public boolean isSetPaymentId() {
+      return __isset_bit_vector.get(__PAYMENTID_ISSET_ID);
+    }
+    public void setPaymentIdIsSet(boolean value) {
+      __isset_bit_vector.set(__PAYMENTID_ISSET_ID, value);
+    }
+    public double getTotalAmount() {
+      return this.totalAmount;
+    }
+    public void setTotalAmount(double totalAmount) {
+      this.totalAmount = totalAmount;
+      setTotalAmountIsSet(true);
+    }
+    public void unsetTotalAmount() {
+      __isset_bit_vector.clear(__TOTALAMOUNT_ISSET_ID);
+    }
+    /** Returns true if field totalAmount is set (has been assigned a value) and false otherwise */
+    public boolean isSetTotalAmount() {
+      return __isset_bit_vector.get(__TOTALAMOUNT_ISSET_ID);
+    }
+    public void setTotalAmountIsSet(boolean value) {
+      __isset_bit_vector.set(__TOTALAMOUNT_ISSET_ID, value);
+    }
+    public long getRepaymentDate() {
+      return this.repaymentDate;
+    }
+    public void setRepaymentDate(long repaymentDate) {
+      this.repaymentDate = repaymentDate;
+      setRepaymentDateIsSet(true);
+    }
+    public void unsetRepaymentDate() {
+      __isset_bit_vector.clear(__REPAYMENTDATE_ISSET_ID);
+    }
+    /** Returns true if field repaymentDate is set (has been assigned a value) and false otherwise */
+    public boolean isSetRepaymentDate() {
+      return __isset_bit_vector.get(__REPAYMENTDATE_ISSET_ID);
+    }
+    public void setRepaymentDateIsSet(boolean value) {
+      __isset_bit_vector.set(__REPAYMENTDATE_ISSET_ID, value);
+    }
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case USER_ID:
+        if (value == null) {
+          unsetUserId();
+        } else {
+          setUserId((Long)value);
+        }
+        break;
+      case PAYMENT_ID:
+        if (value == null) {
+          unsetPaymentId();
+        } else {
+          setPaymentId((Long)value);
+        }
+        break;
+      case TOTAL_AMOUNT:
+        if (value == null) {
+          unsetTotalAmount();
+        } else {
+          setTotalAmount((Double)value);
+        }
+        break;
+      case REPAYMENT_DATE:
+        if (value == null) {
+          unsetRepaymentDate();
+        } else {
+          setRepaymentDate((Long)value);
+        }
+        break;
+      }
+    }
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case USER_ID:
+        return Long.valueOf(getUserId());
+      case PAYMENT_ID:
+        return Long.valueOf(getPaymentId());
+      case TOTAL_AMOUNT:
+        return Double.valueOf(getTotalAmount());
+      case REPAYMENT_DATE:
+        return Long.valueOf(getRepaymentDate());
+      }
+      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 USER_ID:
+        return isSetUserId();
+      case PAYMENT_ID:
+        return isSetPaymentId();
+      case TOTAL_AMOUNT:
+        return isSetTotalAmount();
+      case REPAYMENT_DATE:
+        return isSetRepaymentDate();
+      }
+      throw new IllegalStateException();
+    }
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof markPaymentSettled_args)
+        return this.equals((markPaymentSettled_args)that);
+      return false;
+    }
+    public boolean equals(markPaymentSettled_args that) {
+      if (that == null)
+        return false;
+      boolean this_present_userId = true;
+      boolean that_present_userId = true;
+      if (this_present_userId || that_present_userId) {
+        if (!(this_present_userId && that_present_userId))
+          return false;
+        if (this.userId != that.userId)
+          return false;
+      }
+      boolean this_present_paymentId = true;
+      boolean that_present_paymentId = true;
+      if (this_present_paymentId || that_present_paymentId) {
+        if (!(this_present_paymentId && that_present_paymentId))
+          return false;
+        if (this.paymentId != that.paymentId)
+          return false;
+      }
+      boolean this_present_totalAmount = true;
+      boolean that_present_totalAmount = true;
+      if (this_present_totalAmount || that_present_totalAmount) {
+        if (!(this_present_totalAmount && that_present_totalAmount))
+          return false;
+        if (this.totalAmount != that.totalAmount)
+          return false;
+      }
+      boolean this_present_repaymentDate = true;
+      boolean that_present_repaymentDate = true;
+      if (this_present_repaymentDate || that_present_repaymentDate) {
+        if (!(this_present_repaymentDate && that_present_repaymentDate))
+          return false;
+        if (this.repaymentDate != that.repaymentDate)
+          return false;
+      }
+      return true;
+    }
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+    public int compareTo(markPaymentSettled_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markPaymentSettled_args typedOther = (markPaymentSettled_args)other;
+      lastComparison = Boolean.valueOf(isSetUserId()).compareTo(typedOther.isSetUserId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetUserId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.userId, typedOther.userId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetPaymentId()).compareTo(typedOther.isSetPaymentId());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetPaymentId()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.paymentId, typedOther.paymentId);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetTotalAmount()).compareTo(typedOther.isSetTotalAmount());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetTotalAmount()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.totalAmount, typedOther.totalAmount);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetRepaymentDate()).compareTo(typedOther.isSetRepaymentDate());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetRepaymentDate()) {
+        lastComparison = org.apache.thrift.TBaseHelper.compareTo(this.repaymentDate, typedOther.repaymentDate);
+        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: // USER_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.userId = iprot.readI64();
+              setUserIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // PAYMENT_ID
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.paymentId = iprot.readI64();
+              setPaymentIdIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // TOTAL_AMOUNT
+            if (field.type == org.apache.thrift.protocol.TType.DOUBLE) {
+              this.totalAmount = iprot.readDouble();
+              setTotalAmountIsSet(true);
+            } else {
+              org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 4: // REPAYMENT_DATE
+            if (field.type == org.apache.thrift.protocol.TType.I64) {
+              this.repaymentDate = iprot.readI64();
+              setRepaymentDateIsSet(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(USER_ID_FIELD_DESC);
+      oprot.writeI64(this.userId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(PAYMENT_ID_FIELD_DESC);
+      oprot.writeI64(this.paymentId);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(TOTAL_AMOUNT_FIELD_DESC);
+      oprot.writeDouble(this.totalAmount);
+      oprot.writeFieldEnd();
+      oprot.writeFieldBegin(REPAYMENT_DATE_FIELD_DESC);
+      oprot.writeI64(this.repaymentDate);
+      oprot.writeFieldEnd();
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markPaymentSettled_args(");
+      boolean first = true;
+      sb.append("userId:");
+      sb.append(this.userId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("paymentId:");
+      sb.append(this.paymentId);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("totalAmount:");
+      sb.append(this.totalAmount);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("repaymentDate:");
+      sb.append(this.repaymentDate);
+      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 markPaymentSettled_result implements org.apache.thrift.TBase<markPaymentSettled_result, markPaymentSettled_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("markPaymentSettled_result");
+    private static final org.apache.thrift.protocol.TField SUCCESS_FIELD_DESC = new org.apache.thrift.protocol.TField("success", org.apache.thrift.protocol.TType.MAP, (short)0);
+    private Map<Boolean,String> 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.MapMetaData(org.apache.thrift.protocol.TType.MAP,
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL),
+              new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.STRING))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      org.apache.thrift.meta_data.FieldMetaData.addStructMetaDataMap(markPaymentSettled_result.class, metaDataMap);
+    }
+    public markPaymentSettled_result() {
+    }
+    public markPaymentSettled_result(
+      Map<Boolean,String> success)
+    {
+      this();
+      this.success = success;
+    }
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public markPaymentSettled_result(markPaymentSettled_result other) {
+      if (other.isSetSuccess()) {
+        Map<Boolean,String> __this__success = new HashMap<Boolean,String>();
+        for (Map.Entry<Boolean, String> other_element : other.success.entrySet()) {
+          Boolean other_element_key = other_element.getKey();
+          String other_element_value = other_element.getValue();
+          Boolean __this__success_copy_key = other_element_key;
+          String __this__success_copy_value = other_element_value;
+          __this__success.put(__this__success_copy_key, __this__success_copy_value);
+        }
+        this.success = __this__success;
+      }
+    }
+    public markPaymentSettled_result deepCopy() {
+      return new markPaymentSettled_result(this);
+    }
+    @Override
+    public void clear() {
+      this.success = null;
+    }
+    public int getSuccessSize() {
+      return (this.success == null) ? 0 : this.success.size();
+    }
+    public void putToSuccess(boolean key, String val) {
+      if (this.success == null) {
+        this.success = new HashMap<Boolean,String>();
+      }
+      this.success.put(key, val);
+    }
+    public Map<Boolean,String> getSuccess() {
+      return this.success;
+    }
+    public void setSuccess(Map<Boolean,String> 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((Map<Boolean,String>)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 markPaymentSettled_result)
+        return this.equals((markPaymentSettled_result)that);
+      return false;
+    }
+    public boolean equals(markPaymentSettled_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(markPaymentSettled_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+      int lastComparison = 0;
+      markPaymentSettled_result typedOther = (markPaymentSettled_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.MAP) {
+              {
+                org.apache.thrift.protocol.TMap _map696 = iprot.readMapBegin();
+                this.success = new HashMap<Boolean,String>(2*_map696.size);
+                for (int _i697 = 0; _i697 < _map696.size; ++_i697)
+                {
+                  boolean _key698; // required
+                  String _val699; // required
+                  _key698 = iprot.readBool();
+                  _val699 = iprot.readString();
+                  this.success.put(_key698, _val699);
+                }
+                iprot.readMapEnd();
+              }
+            } 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.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.BOOL, org.apache.thrift.protocol.TType.STRING, this.success.size()));
+          for (Map.Entry<Boolean, String> _iter700 : this.success.entrySet())
+          {
+            oprot.writeBool(_iter700.getKey());
+            oprot.writeString(_iter700.getValue());
+          }
+          oprot.writeMapEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("markPaymentSettled_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 getReturnOrderInfo_args implements org.apache.thrift.TBase<getReturnOrderInfo_args, getReturnOrderInfo_args._Fields>, java.io.Serializable, Cloneable   {
     private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("getReturnOrderInfo_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: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list696 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list701 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list696.size);
+                this.order_ids = new ArrayList<Long>(_list701.size);
-                for (int _i697 = 0; _i697 < _list696.size; ++_i697)
+                for (int _i702 = 0; _i702 < _list701.size; ++_i702)
                 {
-                  long _elem698; // required
+                  long _elem703; // required
-                  _elem698 = iprot.readI64();
+                  _elem703 = iprot.readI64();
-                  this.order_ids.add(_elem698);
+                  this.order_ids.add(_elem703);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.order_ids != null) {
         oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
-          for (long _iter699 : this.order_ids)
+          for (long _iter704 : this.order_ids)
+          {
-            oprot.writeI64(_iter699);
+            oprot.writeI64(_iter704);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map700 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map705 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map700.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map705.size);
-                for (int _i701 = 0; _i701 < _map700.size; ++_i701)
+                for (int _i706 = 0; _i706 < _map705.size; ++_i706)
                 {
-                  long _key702; // required
+                  long _key707; // required
-                  List<ReturnOrderInfo> _val703; // required
+                  List<ReturnOrderInfo> _val708; // required
-                  _key702 = iprot.readI64();
+                  _key707 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list704 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list709 = iprot.readListBegin();
-                    _val703 = new ArrayList<ReturnOrderInfo>(_list704.size);
+                    _val708 = new ArrayList<ReturnOrderInfo>(_list709.size);
-                    for (int _i705 = 0; _i705 < _list704.size; ++_i705)
+                    for (int _i710 = 0; _i710 < _list709.size; ++_i710)
+                    {
-                      ReturnOrderInfo _elem706; // required
+                      ReturnOrderInfo _elem711; // required
-                      _elem706 = new ReturnOrderInfo();
+                      _elem711 = new ReturnOrderInfo();
-                      _elem706.read(iprot);
+                      _elem711.read(iprot);
-                      _val703.add(_elem706);
+                      _val708.add(_elem711);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key702, _val703);
+                  this.success.put(_key707, _val708);
+                }
                 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.LIST, this.success.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter707 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter712 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter707.getKey());
+            oprot.writeI64(_iter712.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter707.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter712.getValue().size()));
-              for (ReturnOrderInfo _iter708 : _iter707.getValue())
+              for (ReturnOrderInfo _iter713 : _iter712.getValue())
+              {
-                _iter708.write(oprot);
+                _iter713.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list709 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list714 = iprot.readListBegin();
-                this.order_ids = new ArrayList<Long>(_list709.size);
+                this.order_ids = new ArrayList<Long>(_list714.size);
-                for (int _i710 = 0; _i710 < _list709.size; ++_i710)
+                for (int _i715 = 0; _i715 < _list714.size; ++_i715)
                 {
-                  long _elem711; // required
+                  long _elem716; // required
-                  _elem711 = iprot.readI64();
+                  _elem716 = iprot.readI64();
-                  this.order_ids.add(_elem711);
+                  this.order_ids.add(_elem716);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+            }
             break;
           case 2: // STATUSES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list712 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list717 = iprot.readListBegin();
-                this.statuses = new ArrayList<String>(_list712.size);
+                this.statuses = new ArrayList<String>(_list717.size);
-                for (int _i713 = 0; _i713 < _list712.size; ++_i713)
+                for (int _i718 = 0; _i718 < _list717.size; ++_i718)
                 {
-                  String _elem714; // required
+                  String _elem719; // required
-                  _elem714 = iprot.readString();
+                  _elem719 = iprot.readString();
-                  this.statuses.add(_elem714);
+                  this.statuses.add(_elem719);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.order_ids != null) {
         oprot.writeFieldBegin(ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.order_ids.size()));
-          for (long _iter715 : this.order_ids)
+          for (long _iter720 : this.order_ids)
+          {
-            oprot.writeI64(_iter715);
+            oprot.writeI64(_iter720);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
       if (this.statuses != null) {
         oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRING, this.statuses.size()));
-          for (String _iter716 : this.statuses)
+          for (String _iter721 : this.statuses)
+          {
-            oprot.writeString(_iter716);
+            oprot.writeString(_iter721);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map717 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map722 = iprot.readMapBegin();
-                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map717.size);
+                this.success = new HashMap<Long,List<ReturnOrderInfo>>(2*_map722.size);
-                for (int _i718 = 0; _i718 < _map717.size; ++_i718)
+                for (int _i723 = 0; _i723 < _map722.size; ++_i723)
                 {
-                  long _key719; // required
+                  long _key724; // required
-                  List<ReturnOrderInfo> _val720; // required
+                  List<ReturnOrderInfo> _val725; // required
-                  _key719 = iprot.readI64();
+                  _key724 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list721 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list726 = iprot.readListBegin();
-                    _val720 = new ArrayList<ReturnOrderInfo>(_list721.size);
+                    _val725 = new ArrayList<ReturnOrderInfo>(_list726.size);
-                    for (int _i722 = 0; _i722 < _list721.size; ++_i722)
+                    for (int _i727 = 0; _i727 < _list726.size; ++_i727)
+                    {
-                      ReturnOrderInfo _elem723; // required
+                      ReturnOrderInfo _elem728; // required
-                      _elem723 = new ReturnOrderInfo();
+                      _elem728 = new ReturnOrderInfo();
-                      _elem723.read(iprot);
+                      _elem728.read(iprot);
-                      _val720.add(_elem723);
+                      _val725.add(_elem728);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.success.put(_key719, _val720);
+                  this.success.put(_key724, _val725);
+                }
                 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.LIST, this.success.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter724 : this.success.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter729 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter724.getKey());
+            oprot.writeI64(_iter729.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter724.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter729.getValue().size()));
-              for (ReturnOrderInfo _iter725 : _iter724.getValue())
+              for (ReturnOrderInfo _iter730 : _iter729.getValue())
+              {
-                _iter725.write(oprot);
+                _iter730.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // ORDER_RETURN_INFOS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map726 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map731 = iprot.readMapBegin();
-                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map726.size);
+                this.orderReturnInfosMap = new HashMap<Long,List<ReturnOrderInfo>>(2*_map731.size);
-                for (int _i727 = 0; _i727 < _map726.size; ++_i727)
+                for (int _i732 = 0; _i732 < _map731.size; ++_i732)
                 {
-                  long _key728; // required
+                  long _key733; // required
-                  List<ReturnOrderInfo> _val729; // required
+                  List<ReturnOrderInfo> _val734; // required
-                  _key728 = iprot.readI64();
+                  _key733 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TList _list730 = iprot.readListBegin();
+                    org.apache.thrift.protocol.TList _list735 = iprot.readListBegin();
-                    _val729 = new ArrayList<ReturnOrderInfo>(_list730.size);
+                    _val734 = new ArrayList<ReturnOrderInfo>(_list735.size);
-                    for (int _i731 = 0; _i731 < _list730.size; ++_i731)
+                    for (int _i736 = 0; _i736 < _list735.size; ++_i736)
+                    {
-                      ReturnOrderInfo _elem732; // required
+                      ReturnOrderInfo _elem737; // required
-                      _elem732 = new ReturnOrderInfo();
+                      _elem737 = new ReturnOrderInfo();
-                      _elem732.read(iprot);
+                      _elem737.read(iprot);
-                      _val729.add(_elem732);
+                      _val734.add(_elem737);
+                    }
                     iprot.readListEnd();
+                  }
-                  this.orderReturnInfosMap.put(_key728, _val729);
+                  this.orderReturnInfosMap.put(_key733, _val734);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.orderReturnInfosMap != null) {
         oprot.writeFieldBegin(ORDER_RETURN_INFOS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.LIST, this.orderReturnInfosMap.size()));
-          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter733 : this.orderReturnInfosMap.entrySet())
+          for (Map.Entry<Long, List<ReturnOrderInfo>> _iter738 : this.orderReturnInfosMap.entrySet())
+          {
-            oprot.writeI64(_iter733.getKey());
+            oprot.writeI64(_iter738.getKey());
+            {
-              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter733.getValue().size()));
+              oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, _iter738.getValue().size()));
-              for (ReturnOrderInfo _iter734 : _iter733.getValue())
+              for (ReturnOrderInfo _iter739 : _iter738.getValue())
+              {
-                _iter734.write(oprot);
+                _iter739.write(oprot);
+              }
               oprot.writeListEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map735 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map740 = iprot.readMapBegin();
-                this.success = new HashMap<Long,Boolean>(2*_map735.size);
+                this.success = new HashMap<Long,Boolean>(2*_map740.size);
-                for (int _i736 = 0; _i736 < _map735.size; ++_i736)
+                for (int _i741 = 0; _i741 < _map740.size; ++_i741)
                 {
-                  long _key737; // required
+                  long _key742; // required
-                  boolean _val738; // required
+                  boolean _val743; // required
-                  _key737 = iprot.readI64();
+                  _key742 = iprot.readI64();
-                  _val738 = iprot.readBool();
+                  _val743 = iprot.readBool();
-                  this.success.put(_key737, _val738);
+                  this.success.put(_key742, _val743);
+                }
                 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.BOOL, this.success.size()));
-          for (Map.Entry<Long, Boolean> _iter739 : this.success.entrySet())
+          for (Map.Entry<Long, Boolean> _iter744 : this.success.entrySet())
+          {
-            oprot.writeI64(_iter739.getKey());
+            oprot.writeI64(_iter744.getKey());
-            oprot.writeBool(_iter739.getValue());
+            oprot.writeBool(_iter744.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 _list740 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list745 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list740.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list745.size);
-                for (int _i741 = 0; _i741 < _list740.size; ++_i741)
+                for (int _i746 = 0; _i746 < _list745.size; ++_i746)
                 {
-                  ReturnOrderInfo _elem742; // required
+                  ReturnOrderInfo _elem747; // required
-                  _elem742 = new ReturnOrderInfo();
+                  _elem747 = new ReturnOrderInfo();
-                  _elem742.read(iprot);
+                  _elem747.read(iprot);
-                  this.success.add(_elem742);
+                  this.success.add(_elem747);
+                }
                 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 (ReturnOrderInfo _iter743 : this.success)
+          for (ReturnOrderInfo _iter748 : this.success)
+          {
-            _iter743.write(oprot);
+            _iter748.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list744 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list749 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list744.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list749.size);
-                for (int _i745 = 0; _i745 < _list744.size; ++_i745)
+                for (int _i750 = 0; _i750 < _list749.size; ++_i750)
                 {
-                  ReturnOrderInfo _elem746; // required
+                  ReturnOrderInfo _elem751; // required
-                  _elem746 = new ReturnOrderInfo();
+                  _elem751 = new ReturnOrderInfo();
-                  _elem746.read(iprot);
+                  _elem751.read(iprot);
-                  this.success.add(_elem746);
+                  this.success.add(_elem751);
+                }
                 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 (ReturnOrderInfo _iter747 : this.success)
+          for (ReturnOrderInfo _iter752 : this.success)
+          {
-            _iter747.write(oprot);
+            _iter752.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 3: // RETURN_ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list748 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list753 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list748.size);
+                this.returnOrderIds = new ArrayList<Long>(_list753.size);
-                for (int _i749 = 0; _i749 < _list748.size; ++_i749)
+                for (int _i754 = 0; _i754 < _list753.size; ++_i754)
                 {
-                  long _elem750; // required
+                  long _elem755; // required
-                  _elem750 = iprot.readI64();
+                  _elem755 = iprot.readI64();
-                  this.returnOrderIds.add(_elem750);
+                  this.returnOrderIds.add(_elem755);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.returnOrderIds != null) {
         oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
-          for (long _iter751 : this.returnOrderIds)
+          for (long _iter756 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter751);
+            oprot.writeI64(_iter756);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // RETURN_ORDER_IDS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list752 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list757 = iprot.readListBegin();
-                this.returnOrderIds = new ArrayList<Long>(_list752.size);
+                this.returnOrderIds = new ArrayList<Long>(_list757.size);
-                for (int _i753 = 0; _i753 < _list752.size; ++_i753)
+                for (int _i758 = 0; _i758 < _list757.size; ++_i758)
                 {
-                  long _elem754; // required
+                  long _elem759; // required
-                  _elem754 = iprot.readI64();
+                  _elem759 = iprot.readI64();
-                  this.returnOrderIds.add(_elem754);
+                  this.returnOrderIds.add(_elem759);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.returnOrderIds != null) {
         oprot.writeFieldBegin(RETURN_ORDER_IDS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I64, this.returnOrderIds.size()));
-          for (long _iter755 : this.returnOrderIds)
+          for (long _iter760 : this.returnOrderIds)
+          {
-            oprot.writeI64(_iter755);
+            oprot.writeI64(_iter760);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list756 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list761 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list756.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list761.size);
-                for (int _i757 = 0; _i757 < _list756.size; ++_i757)
+                for (int _i762 = 0; _i762 < _list761.size; ++_i762)
                 {
-                  ReturnOrderInfo _elem758; // required
+                  ReturnOrderInfo _elem763; // required
-                  _elem758 = new ReturnOrderInfo();
+                  _elem763 = new ReturnOrderInfo();
-                  _elem758.read(iprot);
+                  _elem763.read(iprot);
-                  this.success.add(_elem758);
+                  this.success.add(_elem763);
+                }
                 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 (ReturnOrderInfo _iter759 : this.success)
+          for (ReturnOrderInfo _iter764 : this.success)
+          {
-            _iter759.write(oprot);
+            _iter764.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map760 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map765 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map760.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map765.size);
-                for (int _i761 = 0; _i761 < _map760.size; ++_i761)
+                for (int _i766 = 0; _i766 < _map765.size; ++_i766)
                 {
-                  long _key762; // required
+                  long _key767; // required
-                  Map<String,String> _val763; // required
+                  Map<String,String> _val768; // required
-                  _key762 = iprot.readI64();
+                  _key767 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map764 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map769 = iprot.readMapBegin();
-                    _val763 = new HashMap<String,String>(2*_map764.size);
+                    _val768 = new HashMap<String,String>(2*_map769.size);
-                    for (int _i765 = 0; _i765 < _map764.size; ++_i765)
+                    for (int _i770 = 0; _i770 < _map769.size; ++_i770)
+                    {
-                      String _key766; // required
+                      String _key771; // required
-                      String _val767; // required
+                      String _val772; // required
-                      _key766 = iprot.readString();
+                      _key771 = iprot.readString();
-                      _val767 = iprot.readString();
+                      _val772 = iprot.readString();
-                      _val763.put(_key766, _val767);
+                      _val768.put(_key771, _val772);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key762, _val763);
+                  this.returnOrdersMap.put(_key767, _val768);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter768 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter773 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter768.getKey());
+            oprot.writeI64(_iter773.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter768.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter773.getValue().size()));
-              for (Map.Entry<String, String> _iter769 : _iter768.getValue().entrySet())
+              for (Map.Entry<String, String> _iter774 : _iter773.getValue().entrySet())
+              {
-                oprot.writeString(_iter769.getKey());
+                oprot.writeString(_iter774.getKey());
-                oprot.writeString(_iter769.getValue());
+                oprot.writeString(_iter774.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map770 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map775 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map770.size);
+                this.returnOrdersMap = new HashMap<Long,Boolean>(2*_map775.size);
-                for (int _i771 = 0; _i771 < _map770.size; ++_i771)
+                for (int _i776 = 0; _i776 < _map775.size; ++_i776)
                 {
-                  long _key772; // required
+                  long _key777; // required
-                  boolean _val773; // required
+                  boolean _val778; // required
-                  _key772 = iprot.readI64();
+                  _key777 = iprot.readI64();
-                  _val773 = iprot.readBool();
+                  _val778 = iprot.readBool();
-                  this.returnOrdersMap.put(_key772, _val773);
+                  this.returnOrdersMap.put(_key777, _val778);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.BOOL, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Boolean> _iter774 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Boolean> _iter779 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter774.getKey());
+            oprot.writeI64(_iter779.getKey());
-            oprot.writeBool(_iter774.getValue());
+            oprot.writeBool(_iter779.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map775 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map780 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map775.size);
+                this.returnOrdersMap = new HashMap<Long,Map<String,String>>(2*_map780.size);
-                for (int _i776 = 0; _i776 < _map775.size; ++_i776)
+                for (int _i781 = 0; _i781 < _map780.size; ++_i781)
                 {
-                  long _key777; // required
+                  long _key782; // required
-                  Map<String,String> _val778; // required
+                  Map<String,String> _val783; // required
-                  _key777 = iprot.readI64();
+                  _key782 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map779 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map784 = iprot.readMapBegin();
-                    _val778 = new HashMap<String,String>(2*_map779.size);
+                    _val783 = new HashMap<String,String>(2*_map784.size);
-                    for (int _i780 = 0; _i780 < _map779.size; ++_i780)
+                    for (int _i785 = 0; _i785 < _map784.size; ++_i785)
+                    {
-                      String _key781; // required
+                      String _key786; // required
-                      String _val782; // required
+                      String _val787; // required
-                      _key781 = iprot.readString();
+                      _key786 = iprot.readString();
-                      _val782 = iprot.readString();
+                      _val787 = iprot.readString();
-                      _val778.put(_key781, _val782);
+                      _val783.put(_key786, _val787);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.returnOrdersMap.put(_key777, _val778);
+                  this.returnOrdersMap.put(_key782, _val783);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter783 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter788 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter783.getKey());
+            oprot.writeI64(_iter788.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter783.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter788.getValue().size()));
-              for (Map.Entry<String, String> _iter784 : _iter783.getValue().entrySet())
+              for (Map.Entry<String, String> _iter789 : _iter788.getValue().entrySet())
+              {
-                oprot.writeString(_iter784.getKey());
+                oprot.writeString(_iter789.getKey());
-                oprot.writeString(_iter784.getValue());
+                oprot.writeString(_iter789.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // REFUND_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map785 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map790 = iprot.readMapBegin();
-                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map785.size);
+                this.refundOrdersMap = new HashMap<Long,Map<String,String>>(2*_map790.size);
-                for (int _i786 = 0; _i786 < _map785.size; ++_i786)
+                for (int _i791 = 0; _i791 < _map790.size; ++_i791)
                 {
-                  long _key787; // required
+                  long _key792; // required
-                  Map<String,String> _val788; // required
+                  Map<String,String> _val793; // required
-                  _key787 = iprot.readI64();
+                  _key792 = iprot.readI64();
+                  {
-                    org.apache.thrift.protocol.TMap _map789 = iprot.readMapBegin();
+                    org.apache.thrift.protocol.TMap _map794 = iprot.readMapBegin();
-                    _val788 = new HashMap<String,String>(2*_map789.size);
+                    _val793 = new HashMap<String,String>(2*_map794.size);
-                    for (int _i790 = 0; _i790 < _map789.size; ++_i790)
+                    for (int _i795 = 0; _i795 < _map794.size; ++_i795)
+                    {
-                      String _key791; // required
+                      String _key796; // required
-                      String _val792; // required
+                      String _val797; // required
-                      _key791 = iprot.readString();
+                      _key796 = iprot.readString();
-                      _val792 = iprot.readString();
+                      _val797 = iprot.readString();
-                      _val788.put(_key791, _val792);
+                      _val793.put(_key796, _val797);
+                    }
                     iprot.readMapEnd();
+                  }
-                  this.refundOrdersMap.put(_key787, _val788);
+                  this.refundOrdersMap.put(_key792, _val793);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.refundOrdersMap != null) {
         oprot.writeFieldBegin(REFUND_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.MAP, this.refundOrdersMap.size()));
-          for (Map.Entry<Long, Map<String,String>> _iter793 : this.refundOrdersMap.entrySet())
+          for (Map.Entry<Long, Map<String,String>> _iter798 : this.refundOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter793.getKey());
+            oprot.writeI64(_iter798.getKey());
+            {
-              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter793.getValue().size()));
+              oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.STRING, org.apache.thrift.protocol.TType.STRING, _iter798.getValue().size()));
-              for (Map.Entry<String, String> _iter794 : _iter793.getValue().entrySet())
+              for (Map.Entry<String, String> _iter799 : _iter798.getValue().entrySet())
+              {
-                oprot.writeString(_iter794.getKey());
+                oprot.writeString(_iter799.getKey());
-                oprot.writeString(_iter794.getValue());
+                oprot.writeString(_iter799.getValue());
+              }
               oprot.writeMapEnd();
+            }
+          }
           oprot.writeMapEnd();
+        }
         switch (field.id) {
           case 1: // STATUS_LIST
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list795 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list800 = iprot.readListBegin();
-                this.statusList = new ArrayList<ReturnTransactionStatus>(_list795.size);
+                this.statusList = new ArrayList<ReturnTransactionStatus>(_list800.size);
-                for (int _i796 = 0; _i796 < _list795.size; ++_i796)
+                for (int _i801 = 0; _i801 < _list800.size; ++_i801)
                 {
-                  ReturnTransactionStatus _elem797; // required
+                  ReturnTransactionStatus _elem802; // required
-                  _elem797 = ReturnTransactionStatus.findByValue(iprot.readI32());
+                  _elem802 = ReturnTransactionStatus.findByValue(iprot.readI32());
-                  this.statusList.add(_elem797);
+                  this.statusList.add(_elem802);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.statusList != null) {
         oprot.writeFieldBegin(STATUS_LIST_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statusList.size()));
-          for (ReturnTransactionStatus _iter798 : this.statusList)
+          for (ReturnTransactionStatus _iter803 : this.statusList)
+          {
-            oprot.writeI32(_iter798.getValue());
+            oprot.writeI32(_iter803.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 _list799 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list804 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnTransaction>(_list799.size);
+                this.success = new ArrayList<ReturnTransaction>(_list804.size);
-                for (int _i800 = 0; _i800 < _list799.size; ++_i800)
+                for (int _i805 = 0; _i805 < _list804.size; ++_i805)
                 {
-                  ReturnTransaction _elem801; // required
+                  ReturnTransaction _elem806; // required
-                  _elem801 = new ReturnTransaction();
+                  _elem806 = new ReturnTransaction();
-                  _elem801.read(iprot);
+                  _elem806.read(iprot);
-                  this.success.add(_elem801);
+                  this.success.add(_elem806);
+                }
                 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 (ReturnTransaction _iter802 : this.success)
+          for (ReturnTransaction _iter807 : this.success)
+          {
-            _iter802.write(oprot);
+            _iter807.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+        }
         switch (field.id) {
           case 1: // STATUSES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list803 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list808 = iprot.readListBegin();
-                this.statuses = new ArrayList<OrderStatus>(_list803.size);
+                this.statuses = new ArrayList<OrderStatus>(_list808.size);
-                for (int _i804 = 0; _i804 < _list803.size; ++_i804)
+                for (int _i809 = 0; _i809 < _list808.size; ++_i809)
                 {
-                  OrderStatus _elem805; // required
+                  OrderStatus _elem810; // required
-                  _elem805 = OrderStatus.findByValue(iprot.readI32());
+                  _elem810 = OrderStatus.findByValue(iprot.readI32());
-                  this.statuses.add(_elem805);
+                  this.statuses.add(_elem810);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.statuses != null) {
         oprot.writeFieldBegin(STATUSES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.I32, this.statuses.size()));
-          for (OrderStatus _iter806 : this.statuses)
+          for (OrderStatus _iter811 : this.statuses)
+          {
-            oprot.writeI32(_iter806.getValue());
+            oprot.writeI32(_iter811.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 _list807 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list812 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list807.size);
+                this.success = new ArrayList<Order>(_list812.size);
-                for (int _i808 = 0; _i808 < _list807.size; ++_i808)
+                for (int _i813 = 0; _i813 < _list812.size; ++_i813)
                 {
-                  Order _elem809; // required
+                  Order _elem814; // required
-                  _elem809 = new Order();
+                  _elem814 = new Order();
-                  _elem809.read(iprot);
+                  _elem814.read(iprot);
-                  this.success.add(_elem809);
+                  this.success.add(_elem814);
+                }
                 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 _iter810 : this.success)
+          for (Order _iter815 : this.success)
+          {
-            _iter810.write(oprot);
+            _iter815.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
       } else if (this.isSetEx()) {
+            }
             break;
           case 2: // ATTRIBUTES
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list811 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list816 = iprot.readListBegin();
-                this.attributes = new ArrayList<Attribute>(_list811.size);
+                this.attributes = new ArrayList<Attribute>(_list816.size);
-                for (int _i812 = 0; _i812 < _list811.size; ++_i812)
+                for (int _i817 = 0; _i817 < _list816.size; ++_i817)
                 {
-                  Attribute _elem813; // required
+                  Attribute _elem818; // required
-                  _elem813 = new Attribute();
+                  _elem818 = new Attribute();
-                  _elem813.read(iprot);
+                  _elem818.read(iprot);
-                  this.attributes.add(_elem813);
+                  this.attributes.add(_elem818);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
+      }
       if (this.attributes != null) {
         oprot.writeFieldBegin(ATTRIBUTES_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.attributes.size()));
-          for (Attribute _iter814 : this.attributes)
+          for (Attribute _iter819 : this.attributes)
+          {
-            _iter814.write(oprot);
+            _iter819.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 1: // SHIPMENT_LOGISTICS_COST_DETAILS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list815 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list820 = iprot.readListBegin();
-                this.shipmentLogisticsCostDetails = new ArrayList<ShipmentLogisticsCostDetail>(_list815.size);
+                this.shipmentLogisticsCostDetails = new ArrayList<ShipmentLogisticsCostDetail>(_list820.size);
-                for (int _i816 = 0; _i816 < _list815.size; ++_i816)
+                for (int _i821 = 0; _i821 < _list820.size; ++_i821)
                 {
-                  ShipmentLogisticsCostDetail _elem817; // required
+                  ShipmentLogisticsCostDetail _elem822; // required
-                  _elem817 = new ShipmentLogisticsCostDetail();
+                  _elem822 = new ShipmentLogisticsCostDetail();
-                  _elem817.read(iprot);
+                  _elem822.read(iprot);
-                  this.shipmentLogisticsCostDetails.add(_elem817);
+                  this.shipmentLogisticsCostDetails.add(_elem822);
+                }
                 iprot.readListEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeStructBegin(STRUCT_DESC);
       if (this.shipmentLogisticsCostDetails != null) {
         oprot.writeFieldBegin(SHIPMENT_LOGISTICS_COST_DETAILS_FIELD_DESC);
+        {
           oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT, this.shipmentLogisticsCostDetails.size()));
-          for (ShipmentLogisticsCostDetail _iter818 : this.shipmentLogisticsCostDetails)
+          for (ShipmentLogisticsCostDetail _iter823 : this.shipmentLogisticsCostDetails)
+          {
-            _iter818.write(oprot);
+            _iter823.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list819 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list824 = iprot.readListBegin();
-                this.success = new ArrayList<Order>(_list819.size);
+                this.success = new ArrayList<Order>(_list824.size);
-                for (int _i820 = 0; _i820 < _list819.size; ++_i820)
+                for (int _i825 = 0; _i825 < _list824.size; ++_i825)
                 {
-                  Order _elem821; // required
+                  Order _elem826; // required
-                  _elem821 = new Order();
+                  _elem826 = new Order();
-                  _elem821.read(iprot);
+                  _elem826.read(iprot);
-                  this.success.add(_elem821);
+                  this.success.add(_elem826);
+                }
                 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 _iter822 : this.success)
+          for (Order _iter827 : this.success)
+          {
-            _iter822.write(oprot);
+            _iter827.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list823 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list828 = iprot.readListBegin();
-                this.success = new ArrayList<ReturnOrderInfo>(_list823.size);
+                this.success = new ArrayList<ReturnOrderInfo>(_list828.size);
-                for (int _i824 = 0; _i824 < _list823.size; ++_i824)
+                for (int _i829 = 0; _i829 < _list828.size; ++_i829)
                 {
-                  ReturnOrderInfo _elem825; // required
+                  ReturnOrderInfo _elem830; // required
-                  _elem825 = new ReturnOrderInfo();
+                  _elem830 = new ReturnOrderInfo();
-                  _elem825.read(iprot);
+                  _elem830.read(iprot);
-                  this.success.add(_elem825);
+                  this.success.add(_elem830);
+                }
                 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 (ReturnOrderInfo _iter826 : this.success)
+          for (ReturnOrderInfo _iter831 : this.success)
+          {
-            _iter826.write(oprot);
+            _iter831.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }
+            }
             break;
           case 2: // RETURN_ORDERS_MAP
             if (field.type == org.apache.thrift.protocol.TType.MAP) {
+              {
-                org.apache.thrift.protocol.TMap _map827 = iprot.readMapBegin();
+                org.apache.thrift.protocol.TMap _map832 = iprot.readMapBegin();
-                this.returnOrdersMap = new HashMap<Long,Long>(2*_map827.size);
+                this.returnOrdersMap = new HashMap<Long,Long>(2*_map832.size);
-                for (int _i828 = 0; _i828 < _map827.size; ++_i828)
+                for (int _i833 = 0; _i833 < _map832.size; ++_i833)
                 {
-                  long _key829; // required
+                  long _key834; // required
-                  long _val830; // required
+                  long _val835; // required
-                  _key829 = iprot.readI64();
+                  _key834 = iprot.readI64();
-                  _val830 = iprot.readI64();
+                  _val835 = iprot.readI64();
-                  this.returnOrdersMap.put(_key829, _val830);
+                  this.returnOrdersMap.put(_key834, _val835);
+                }
                 iprot.readMapEnd();
+              }
             } else {
               org.apache.thrift.protocol.TProtocolUtil.skip(iprot, field.type);
       oprot.writeFieldEnd();
       if (this.returnOrdersMap != null) {
         oprot.writeFieldBegin(RETURN_ORDERS_MAP_FIELD_DESC);
+        {
           oprot.writeMapBegin(new org.apache.thrift.protocol.TMap(org.apache.thrift.protocol.TType.I64, org.apache.thrift.protocol.TType.I64, this.returnOrdersMap.size()));
-          for (Map.Entry<Long, Long> _iter831 : this.returnOrdersMap.entrySet())
+          for (Map.Entry<Long, Long> _iter836 : this.returnOrdersMap.entrySet())
+          {
-            oprot.writeI64(_iter831.getKey());
+            oprot.writeI64(_iter836.getKey());
-            oprot.writeI64(_iter831.getValue());
+            oprot.writeI64(_iter836.getValue());
+          }
           oprot.writeMapEnd();
+        }
         oprot.writeFieldEnd();
+      }
+        }
         switch (field.id) {
           case 0: // SUCCESS
             if (field.type == org.apache.thrift.protocol.TType.LIST) {
+              {
-                org.apache.thrift.protocol.TList _list832 = iprot.readListBegin();
+                org.apache.thrift.protocol.TList _list837 = iprot.readListBegin();
-                this.success = new ArrayList<PendingStoreOrder>(_list832.size);
+                this.success = new ArrayList<PendingStoreOrder>(_list837.size);
-                for (int _i833 = 0; _i833 < _list832.size; ++_i833)
+                for (int _i838 = 0; _i838 < _list837.size; ++_i838)
                 {
-                  PendingStoreOrder _elem834; // required
+                  PendingStoreOrder _elem839; // required
-                  _elem834 = new PendingStoreOrder();
+                  _elem839 = new PendingStoreOrder();
-                  _elem834.read(iprot);
+                  _elem839.read(iprot);
-                  this.success.add(_elem834);
+                  this.success.add(_elem839);
+                }
                 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 (PendingStoreOrder _iter835 : this.success)
+          for (PendingStoreOrder _iter840 : this.success)
+          {
-            _iter835.write(oprot);
+            _iter840.write(oprot);
+          }
           oprot.writeListEnd();
+        }
         oprot.writeFieldEnd();
+      }

Subversion Repositories SmartDukaan

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