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

      * 	2. Creates a return order for the warehouse executive to return the shipped material.
      * 	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
+     *
      * If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
      * 	1. Creates a refund request for batch processing.
+     * 	2. Cancels the reservation of the item in the warehouse.
-     * 	2. Marks the current order as the REFUNDED final state.
+     * 	3. Marks the current order as the REFUNDED final state.
+     *
+     * For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
+     * 	1. Cancels the reservation of the item in the warehouse.
+     * 	2. Marks the current order as CANCELED.
+     *
+     * In all cases, it updates the reason for cancellation or refund and the person who performed the action.
+     *
      * Returns True if it is successful, False otherwise.
+     *
      * Throws an exception if the order with the given id couldn't be found.
+     *
      * @param orderId
+     * @param refundedBy
+     * @param reason
      */
-    public boolean refundOrder(long orderId) throws TransactionServiceException, TException;
+    public boolean refundOrder(long orderId, String refundedBy, String reason) throws TransactionServiceException, TException;
     /**
      * Get all return orders created between the from and to dates for the given warehouse.
      * Ignores the warehouse if it is passed as -1.
+     *
         throw result.ex;
+      }
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
+    }
-    public boolean refundOrder(long orderId) throws TransactionServiceException, TException
+    public boolean refundOrder(long orderId, String refundedBy, String reason) throws TransactionServiceException, TException
+    {
-      send_refundOrder(orderId);
+      send_refundOrder(orderId, refundedBy, reason);
       return recv_refundOrder();
+    }
-    public void send_refundOrder(long orderId) throws TException
+    public void send_refundOrder(long orderId, String refundedBy, String reason) throws TException
+    {
       oprot_.writeMessageBegin(new TMessage("refundOrder", TMessageType.CALL, seqid_));
       refundOrder_args args = new refundOrder_args();
       args.orderId = orderId;
+      args.refundedBy = refundedBy;
+      args.reason = reason;
       args.write(oprot_);
       oprot_.writeMessageEnd();
       oprot_.getTransport().flush();
+    }
         refundOrder_args args = new refundOrder_args();
         args.read(iprot);
         iprot.readMessageEnd();
         refundOrder_result result = new refundOrder_result();
         try {
-          result.success = iface_.refundOrder(args.orderId);
+          result.success = iface_.refundOrder(args.orderId, args.refundedBy, args.reason);
           result.setSuccessIsSet(true);
         } catch (TransactionServiceException ex) {
           result.ex = ex;
         } catch (Throwable th) {
           LOGGER.error("Internal error processing refundOrder", th);
   public static class refundOrder_args implements TBase<refundOrder_args._Fields>, java.io.Serializable, Cloneable, Comparable<refundOrder_args>   {
     private static final TStruct STRUCT_DESC = new TStruct("refundOrder_args");
     private static final TField ORDER_ID_FIELD_DESC = new TField("orderId", TType.I64, (short)1);
+    private static final TField REFUNDED_BY_FIELD_DESC = new TField("refundedBy", TType.STRING, (short)2);
+    private static final TField REASON_FIELD_DESC = new TField("reason", TType.STRING, (short)3);
     private long orderId;
+    private String refundedBy;
+    private String reason;
     /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
     public enum _Fields implements TFieldIdEnum {
-      ORDER_ID((short)1, "orderId");
+      ORDER_ID((short)1, "orderId"),
+      REFUNDED_BY((short)2, "refundedBy"),
+      REASON((short)3, "reason");
       private static final Map<Integer, _Fields> byId = new HashMap<Integer, _Fields>();
       private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
       static {
     private BitSet __isset_bit_vector = new BitSet(1);
     public static final Map<_Fields, FieldMetaData> metaDataMap = Collections.unmodifiableMap(new EnumMap<_Fields, FieldMetaData>(_Fields.class) {{
       put(_Fields.ORDER_ID, new FieldMetaData("orderId", TFieldRequirementType.DEFAULT,
           new FieldValueMetaData(TType.I64)));
+      put(_Fields.REFUNDED_BY, new FieldMetaData("refundedBy", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
+      put(_Fields.REASON, new FieldMetaData("reason", TFieldRequirementType.DEFAULT,
+          new FieldValueMetaData(TType.STRING)));
     }});
     static {
       FieldMetaData.addStructMetaDataMap(refundOrder_args.class, metaDataMap);
+    }
     public refundOrder_args() {
+    }
     public refundOrder_args(
-      long orderId)
+      long orderId,
+      String refundedBy,
+      String reason)
+    {
       this();
       this.orderId = orderId;
       setOrderIdIsSet(true);
+      this.refundedBy = refundedBy;
+      this.reason = reason;
+    }
     /**
      * Performs a deep copy on <i>other</i>.
      */
     public refundOrder_args(refundOrder_args other) {
       __isset_bit_vector.clear();
       __isset_bit_vector.or(other.__isset_bit_vector);
       this.orderId = other.orderId;
+      if (other.isSetRefundedBy()) {
+        this.refundedBy = other.refundedBy;
+      }
+      if (other.isSetReason()) {
+        this.reason = other.reason;
+      }
+    }
     public refundOrder_args deepCopy() {
       return new refundOrder_args(this);
+    }
     public void setOrderIdIsSet(boolean value) {
       __isset_bit_vector.set(__ORDERID_ISSET_ID, value);
+    }
+    public String getRefundedBy() {
+      return this.refundedBy;
+    }
+    public refundOrder_args setRefundedBy(String refundedBy) {
+      this.refundedBy = refundedBy;
+      return this;
+    }
+    public void unsetRefundedBy() {
+      this.refundedBy = null;
+    }
+    /** Returns true if field refundedBy is set (has been asigned a value) and false otherwise */
+    public boolean isSetRefundedBy() {
+      return this.refundedBy != null;
+    }
+    public void setRefundedByIsSet(boolean value) {
+      if (!value) {
+        this.refundedBy = null;
+      }
+    }
+    public String getReason() {
+      return this.reason;
+    }
+    public refundOrder_args setReason(String reason) {
+      this.reason = reason;
+      return this;
+    }
+    public void unsetReason() {
+      this.reason = null;
+    }
+    /** Returns true if field reason is set (has been asigned a value) and false otherwise */
+    public boolean isSetReason() {
+      return this.reason != null;
+    }
+    public void setReasonIsSet(boolean value) {
+      if (!value) {
+        this.reason = null;
+      }
+    }
     public void setFieldValue(_Fields field, Object value) {
       switch (field) {
       case ORDER_ID:
         if (value == null) {
           unsetOrderId();
         } else {
           setOrderId((Long)value);
+        }
         break;
+      case REFUNDED_BY:
+        if (value == null) {
+          unsetRefundedBy();
+        } else {
+          setRefundedBy((String)value);
+        }
+        break;
+      case REASON:
+        if (value == null) {
+          unsetReason();
+        } else {
+          setReason((String)value);
+        }
+        break;
+      }
+    }
     public void setFieldValue(int fieldID, Object value) {
       setFieldValue(_Fields.findByThriftIdOrThrow(fieldID), value);
     public Object getFieldValue(_Fields field) {
       switch (field) {
       case ORDER_ID:
         return new Long(getOrderId());
+      case REFUNDED_BY:
+        return getRefundedBy();
+      case REASON:
+        return getReason();
+      }
       throw new IllegalStateException();
+    }
     public Object getFieldValue(int fieldId) {
     /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
     public boolean isSet(_Fields field) {
       switch (field) {
       case ORDER_ID:
         return isSetOrderId();
+      case REFUNDED_BY:
+        return isSetRefundedBy();
+      case REASON:
+        return isSetReason();
+      }
       throw new IllegalStateException();
+    }
     public boolean isSet(int fieldID) {
           return false;
         if (this.orderId != that.orderId)
           return false;
+      }
+      boolean this_present_refundedBy = true && this.isSetRefundedBy();
+      boolean that_present_refundedBy = true && that.isSetRefundedBy();
+      if (this_present_refundedBy || that_present_refundedBy) {
+        if (!(this_present_refundedBy && that_present_refundedBy))
+          return false;
+        if (!this.refundedBy.equals(that.refundedBy))
+          return false;
+      }
+      boolean this_present_reason = true && this.isSetReason();
+      boolean that_present_reason = true && that.isSetReason();
+      if (this_present_reason || that_present_reason) {
+        if (!(this_present_reason && that_present_reason))
+          return false;
+        if (!this.reason.equals(that.reason))
+          return false;
+      }
       return true;
+    }
     @Override
     public int hashCode() {
+      }
       lastComparison = TBaseHelper.compareTo(orderId, typedOther.orderId);
       if (lastComparison != 0) {
         return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetRefundedBy()).compareTo(isSetRefundedBy());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(refundedBy, typedOther.refundedBy);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = Boolean.valueOf(isSetReason()).compareTo(isSetReason());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      lastComparison = TBaseHelper.compareTo(reason, typedOther.reason);
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
       return 0;
+    }
     public void read(TProtocol iprot) throws TException {
       TField field;
                 setOrderIdIsSet(true);
               } else {
                 TProtocolUtil.skip(iprot, field.type);
+              }
               break;
+            case REFUNDED_BY:
+              if (field.type == TType.STRING) {
+                this.refundedBy = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+            case REASON:
+              if (field.type == TType.STRING) {
+                this.reason = iprot.readString();
+              } else {
+                TProtocolUtil.skip(iprot, field.type);
+              }
+              break;
+          }
           iprot.readFieldEnd();
+        }
+      }
       iprot.readStructEnd();
       oprot.writeStructBegin(STRUCT_DESC);
       oprot.writeFieldBegin(ORDER_ID_FIELD_DESC);
       oprot.writeI64(this.orderId);
       oprot.writeFieldEnd();
+      if (this.refundedBy != null) {
+        oprot.writeFieldBegin(REFUNDED_BY_FIELD_DESC);
+        oprot.writeString(this.refundedBy);
+        oprot.writeFieldEnd();
+      }
+      if (this.reason != null) {
+        oprot.writeFieldBegin(REASON_FIELD_DESC);
+        oprot.writeString(this.reason);
+        oprot.writeFieldEnd();
+      }
       oprot.writeFieldStop();
       oprot.writeStructEnd();
+    }
     @Override
       boolean first = true;
       sb.append("orderId:");
       sb.append(this.orderId);
       first = false;
+      if (!first) sb.append(", ");
+      sb.append("refundedBy:");
+      if (this.refundedBy == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.refundedBy);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("reason:");
+      if (this.reason == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.reason);
+      }
+      first = false;
       sb.append(")");
       return sb.toString();
+    }
     public void validate() throws TException {

Subversion Repositories SmartDukaan

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