Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.shiro.SecurityUtils;

import org.apache.struts2.convention.annotation.InterceptorRef;

import org.apache.struts2.convention.annotation.InterceptorRefs;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.json.JSONArray;

import in.shop2020.model.v1.order.Order;

import in.shop2020.model.v1.order.OrderStatus;

import in.shop2020.model.v1.order.RefundType;

import in.shop2020.model.v1.order.ReplacementShippingType;

import in.shop2020.model.v1.order.ReturnAction;

import in.shop2020.model.v1.order.ReturnOrderInfo;

import in.shop2020.model.v1.order.ReturnPickupRequest;

import in.shop2020.model.v1.order.ReturnPickupType;

import in.shop2020.model.v1.order.ReturnTransaction;

import in.shop2020.model.v1.order.ReturnTransactionStatus;

import in.shop2020.model.v1.order.ReturnTxnPickupStatus;

import in.shop2020.model.v1.order.ReturnTxnResolutionStatus;

import in.shop2020.model.v1.order.TransactionService.Client;

import in.shop2020.model.v1.order.TransactionServiceException;

import in.shop2020.model.v1.user.Address;

import in.shop2020.model.v1.user.AddressType;

import in.shop2020.model.v1.user.User;

import in.shop2020.model.v1.user.UserContextException;

import in.shop2020.payments.Payment;

import in.shop2020.payments.PaymentException;

import in.shop2020.thrift.clients.PaymentClient;

import in.shop2020.thrift.clients.TransactionClient;

import in.shop2020.thrift.clients.UserClient;

@InterceptorRefs({

	@InterceptorRef("myDefault"),

	@InterceptorRef("returnTransactionValidator")

})

public class ReturnTransactionsController extends BaseController {

	/**

	 * 

	 */

	private static final long serialVersionUID = 1L;

	private static final String VIEW = "return-transactions-view";

	private static final String CONFIRM = "confirm-return-transaction";

	private static final String VIEW_RETURN_TRANSACTION = "view-return-transaction";

	private static final String VIEW_RETURN_ORDER = "view-return-order";

	private static final String PICKUP_VIEW = "pickup-view";

	private String userId;

	private String returnType;

	private List<Order> orders;

	private String result;

	private String tableData;

	private List<Address> addresses;

	private String name;

	private String line1;

	private String line2;

	private String landmark;

	private String city;

	private String state;

	private String country;

	private String pincode;

	private String phone;

	private String addressType;

	private String addressId;

	private ReturnTransaction returnTransaction;

	private String newReturnTransactionStatus;

	private String returnTransactionId;

	private String returnOrderId;

	private ReturnOrderInfo returnOrderInfo;

	private List<ReturnOrderInfo> returnOrderInfoList;

	private String returnOrderIdsForPickUp;

	private String pickupRequestId;

	private ReturnPickupRequest returnPickupRequest;

	private String pickupRequestNo;

	private String logisticProviderId;

	private String pickupStatus;

	private String promised_pickup_timestamp;

	private String pickedUpAt;

	private List<ReturnTransaction> returnTransactions;

	private String receivedQty;

	private String receivedCondition;

	private String[] serialNumbers;

	private String scanFreebie;

	private String productUsable;

	private String splitOrderQuantity;

	private String refundAmount;

	private String refundType;

	private String refundReason;

	private String chequeDetails;

	private String refundDescription;

	private String couponDetails;

	private String shippingType;

	private Order order;

	public String index() {

		return INDEX;

	}

	public String view() throws NumberFormatException, TException {

		transactionServiceClient = new TransactionClient().getClient();

		setOrders(transactionServiceClient.getEligibleOrdersForReturn(

				Long.valueOf(userId), returnType, canOverideWarranty()));

		return VIEW;

	}

	private boolean canOverideWarranty(){

		return SecurityUtils.getSubject().hasRole("TeamLead")?true:false;

	}

	public String getReturnTransactionsForUser() throws TransactionServiceException, NumberFormatException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		transactionServiceClient.getReturnTransactionsForCustomer(null, null, null, 0l, Long.valueOf(userId));

		setReturnTransactions(transactionServiceClient.getReturnTransactionsForCustomer(null, null, null, 0l, Long.valueOf(userId)));

		return "return-transaction-all";

	}

	public String viewPickUp() throws NumberFormatException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		setReturnOrderInfoList(transactionServiceClient.getEligibleReturnOrdersForPickup(Long.valueOf(userId)));

		return PICKUP_VIEW;

	}

	public String validateReturn() throws NumberFormatException,

	UserContextException, TException {

		result = "true";

		List<ReturnOrderInfo> returnOrderList = getTableData();

		Map<Long, Long> returnOrdersMap = new HashMap<Long, Long>();

		for (ReturnOrderInfo r : returnOrderList){

			if (r.getReturnPickupType() == ReturnPickupType.NOT_REQUIRED && r.getReturnAction() == ReturnAction.REPLACEMENT){

				result = "false";

			}

			returnOrdersMap.put(r.getOrderId(), r.getReturnQuantity());

		}

		transactionServiceClient = new TransactionClient().getClient();

		boolean t_result = transactionServiceClient.validateReturnTransaction(Long.valueOf(userId), returnOrdersMap, returnType, canOverideWarranty());

		if(!t_result){

			result = "false";

		}

		if (!Boolean.valueOf(result)) {

			return "result";

		}

		userContextServiceClient = new UserClient().getClient();

		setAddresses(userContextServiceClient.getAllAddressesForUser(Long

				.valueOf(userId)));

		return CONFIRM;

	}

	public String createReturnPickup() throws TransactionServiceException, TException{

		String[] returnOrderIds = returnOrderIdsForPickUp.split(",");

		List<Long> returnOrders = new ArrayList<Long>();

		for (String s : returnOrderIds){

			returnOrders.add(Long.valueOf(s));

		}

		transactionServiceClient = new TransactionClient().getClient();

		long t_requestPickupId = transactionServiceClient.createReturnPickupRequest(returnOrders);

		if (t_requestPickupId==0){

			throw new TransactionServiceException();

		}

		setPickupRequestId(String.valueOf(t_requestPickupId));

		setReturnPickupRequest(transactionServiceClient.getReturnPickupRequest(t_requestPickupId));

		setReturnOrderInfoList(transactionServiceClient.getAllReturnOrdersForReturnPickupRequest(t_requestPickupId));

		return "pick-up-index";

	}

	public String viewReturnPickup() throws NumberFormatException, TException, TransactionServiceException{

		transactionServiceClient = new TransactionClient().getClient();

		ReturnPickupRequest t_retuenPickuprequest = transactionServiceClient.getReturnPickupRequest(Long.valueOf(pickupRequestId));

		setPickupRequestId(String.valueOf(t_retuenPickuprequest.getId()));

		setReturnPickupRequest(t_retuenPickuprequest);

		setReturnOrderInfoList(transactionServiceClient.getAllReturnOrdersForReturnPickupRequest(t_retuenPickuprequest.getId()));

		return "pick-up-index";

	}

	public String refundReceivedOrder() throws NumberFormatException, TransactionServiceException, TException, PaymentException{

		try{

			transactionServiceClient = new TransactionClient().getClient();

			returnOrderInfo = transactionServiceClient.getReturnOrderInfo(Long.valueOf(returnOrderId));

			returnOrderInfo.setRefundType(RefundType.findByValue(Integer.valueOf(refundType)));

			returnOrderInfo.setRefundedBy(getAgentName());

			if (returnOrderInfo.getRefundType() == RefundType.INIT){

				setResult("Illegal refund type");

				return "result";

			}

			in.shop2020.model.v1.order.Order t_order = transactionServiceClient.getOrder(returnOrderInfo.getOrderId());

			PaymentClient paymentServiceClient = new PaymentClient();

			List<Payment> orderPayments =null; 

			if(!t_order.isCod()){

				orderPayments =paymentServiceClient.getClient()

				.getPaymentForTxnId(t_order.getTransactionId());

			}

			List<in.shop2020.model.v1.order.Attribute> attrList = new ArrayList<in.shop2020.model.v1.order.Attribute>();

			in.shop2020.model.v1.order.Attribute attr1 = new in.shop2020.model.v1.order.Attribute();

			attr1.setName("Refund_Option");

			in.shop2020.model.v1.order.Attribute attr2 = new in.shop2020.model.v1.order.Attribute();

			attr2.setName("Refund_Amount");

			in.shop2020.model.v1.order.Attribute attr3 = new in.shop2020.model.v1.order.Attribute();

			attr3.setName("Refund_TimeStamp");

			SimpleDateFormat timestmapFormat = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");

			attr2.setValue(refundAmount);

			attr3.setValue(timestmapFormat.format(Calendar.getInstance().getTime()));

			if (RECEIVE_PICKUP_STATE_CHECK.contains(returnOrderInfo.getReturnStatus()) && returnOrderInfo.getReturnTxnResolutionStatus() == ReturnTxnResolutionStatus.QUALITY_CHECK){

				if (returnOrderInfo.getReturnAction() == ReturnAction.REPLACEMENT){

					if (returnOrderInfo.getRefundType() != RefundType.REPLACEMENT){

						setResult("Refund type should be replacement");

						return "result";

					}

					returnOrderInfo.setRefundType(RefundType.REPLACEMENT);

					returnOrderInfo.setShippingType(ReplacementShippingType.findByValue(Integer.valueOf(shippingType)));

					if (returnOrderInfo.getShippingType() != ReplacementShippingType.IMMEDIATE){

						setResult("Shipping type should be immediate");

						return "result";

					}

				}

				else{

					if(!(SecurityUtils.getSubject().hasRole("TeamLead"))){

						setResult("Admin rights are required to process this operation");

						return "result";

					}

					if (returnOrderInfo.getRefundType() == null){

						setResult("Illegal refund type");

						return "result";

					}

					if (returnOrderInfo.getRefundType() == RefundType.CHEQUE){

						if (chequeDetails == null || chequeDetails.trim().isEmpty()){

							setResult("Cheque details should be filled out");

							return "result";

						}

						returnOrderInfo.setRefundType(RefundType.CHEQUE);

						attr1.setValue("Refund By Cheque: "+chequeDetails);

						attrList.add(attr1);

						attrList.add(attr2);

						attrList.add(attr3);

					}

					if (returnOrderInfo.getRefundType() == RefundType.COUPON){

						if (couponDetails == null || couponDetails.trim().isEmpty()){

							setResult("Coupon details should be filled out");

							return "result";

						}

						attr1.setValue("Refund By Coupon: "+couponDetails);

						attrList.add(attr1);

						attrList.add(attr2);

						attrList.add(attr3);

						returnOrderInfo.setRefundType(RefundType.COUPON);

					}

					if (returnOrderInfo.getRefundType() == RefundType.GATEWAY){

						returnOrderInfo.setRefundType(RefundType.GATEWAY);

						attr1.setValue("Refund By Payment Gatway: "+refundDescription);

						attrList.add(attr2);

						attrList.add(attr3);

						attrList.add(attr1);

					}

					if (Double.valueOf(refundAmount) > returnOrderInfo.getLineitem().getTotal_price()){

						setResult("Refund amount can;t be greater than order amount");

						return "result";

					}

				}

				if (refundReason == null || refundReason.trim().isEmpty()){

					setResult("Refund Reason should be filled out");

					return "result";

				}

				if (refundDescription == null || refundDescription.trim().isEmpty()){

					setResult("Refund Reason should be filled out");

					return "result";

				}

				returnOrderInfo.setRefundReason(refundReason);

				returnOrderInfo.setRefundDescription(refundDescription);

				boolean t_result = transactionServiceClient.refundReturnOrder(returnOrderInfo, attrList);

				if(t_result){

					setResult("Refunded successfully");

					return "result";

				}

				setResult("Unable to refund or replace");

				return "result";

			}

			setResult("Illegal operation");

			return "result";

		}

		catch(Exception e){

			e.printStackTrace();

			setResult("Some exception occured");

			return "result";

		}

	}

	public String markReturnNotPickedUp() throws TransactionServiceException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		returnOrderInfo = transactionServiceClient.getReturnOrderInfo(Long.valueOf(returnOrderId));

		if ((returnOrderInfo.getReturnStatus().equalsIgnoreCase("RET_REQUEST_AUTHORIZED") || returnOrderInfo.getReturnStatus().equalsIgnoreCase("DOA_REQUEST_AUTHORIZED"))&& returnOrderInfo.getReturnPickupType() == ReturnPickupType.NOT_REQUIRED){

			if(refundReason.trim()==null || refundReason.trim().isEmpty()){

				setResult("Refund reason can't be empty");

				return "result";

			}

			returnOrderInfo.setRefundReason(refundReason.trim());

			returnOrderInfo.setRefundAmount(Double.valueOf(refundAmount));

			if (returnOrderInfo.getRefundAmount() > returnOrderInfo.getLineitem().getTotal_price()){

				setResult("Refund amount can;t be greater than order amount");

				return "result";

			}

			returnOrderInfo.setRefundType(RefundType.findByValue(Integer.valueOf(refundType)));

			if (returnOrderInfo.getRefundType() != RefundType.WALLET){

				setResult("Refund type should be wallet");

				return "result";

			}

			returnOrderInfo.setRefundedBy(getAgentName());

			boolean t_result = transactionServiceClient.markReturnNotRequiredOrdersProcessed(returnOrderInfo);

			if (t_result){

				setResult("Refund processed successfully");

				return "result";

			}

			setResult("Unable to process refund");

			return "result";

		}

		setResult("Illegal operation");

		return "result";

	}

	public String updateReturnPickup() throws TransactionServiceException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		ReturnPickupRequest t_retuenPickuprequest = transactionServiceClient.getReturnPickupRequest(Long.valueOf(pickupRequestId));

		ReturnPickupRequest rpr = new ReturnPickupRequest();

		rpr.setId(Long.valueOf(pickupRequestId));

		rpr.setPickupStatus(ReturnTxnPickupStatus.findByValue(Integer.valueOf(pickupStatus)));

		if (ReturnTxnPickupStatus.PICKUP_CONFIRMED == rpr.getPickupStatus()){

			rpr.setLogisticsProviderId(Long.valueOf(logisticProviderId));

			rpr.setPickupRequestNo(pickupRequestNo);

		}

		if (ReturnTxnPickupStatus.PICKUP_SCHEDULED == rpr.getPickupStatus()){

			try{

				rpr.setPromised_pickup_timestamp(Long.valueOf(promised_pickup_timestamp));

			}

			catch(Exception e){

				setResult("Illegal promised pickup timestamp");

				return "result";

			}

		}

		if (ReturnTxnPickupStatus.PICKUP_IN_TRANSIT == rpr.getPickupStatus()){

			try{

				rpr.setPickedUpAt(Long.valueOf(pickedUpAt));

			}

			catch(Exception e){

				setResult("Illegal Pickedup timestamp");

				return "result";

			}

		}

		String validation_result = validateReturnPickupUpdateRequest(rpr,t_retuenPickuprequest);

		if (validation_result.isEmpty()){

			transactionServiceClient.updateReturnPickupRequest(rpr);

			setResult("Status updated successfully");

			return "result";

		}

		setResult(validation_result);

		return "result";

	}

	public String receiveItem() throws TransactionServiceException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		returnOrderInfo = transactionServiceClient.getReturnOrderInfo(Long.valueOf(returnOrderId));

		if (returnOrderInfo.getReturnQuantity() != Long.valueOf(receivedQty)){

			setResult("Received Qty is not equal to return quantity");

			return "result";

		}

		if (returnOrderInfo.getFreebieItemId() == 0 && Long.valueOf(scanFreebie)==1){

			setResult("No freebie was given.");

			return "result";

		}

		Map<String,String> info = new HashMap<String,String>();

		Map<Long, Map<String,String>> returnOrderMap = new HashMap<Long,Map<String,String>>();

		info.put("ReceiveCondition", receivedCondition);

		info.put("Quantity", receivedQty);

		info.put("ScanFreebie",Long.valueOf(scanFreebie)==1?"yes":"no");

		info.put("productUsable",Long.valueOf(productUsable)==1?"true":"false");

		String serialNumberValues = "";

		for(String s : serialNumbers){

			serialNumberValues = serialNumberValues+s.trim()+",";

		}

		info.put("SerialNumbers", serialNumberValues);

		returnOrderMap.put(returnOrderInfo.getId(), info);

		boolean receiveResult = transactionServiceClient.receiveReturnPickup(returnOrderMap, 0l);

		setResult(String.valueOf(receiveResult));

		return "result";

	}

	private String validateReturnPickupUpdateRequest(ReturnPickupRequest rpr, ReturnPickupRequest t_retuenPickuprequest) throws TransactionServiceException, TException{

		StringBuilder sb = new StringBuilder();

		if (ReturnTxnPickupStatus.PICKUP_REQUESTED == rpr.getPickupStatus()){

			if(!(t_retuenPickuprequest.getPickupStatus() == ReturnTxnPickupStatus.PENDING)){

				sb.append("Illegal operation -Pickup Status check failed");

			}

		}

		if (ReturnTxnPickupStatus.PICKUP_CONFIRMED == rpr.getPickupStatus()){

			if(!(t_retuenPickuprequest.getPickupStatus() == ReturnTxnPickupStatus.PICKUP_REQUESTED)){

				sb.append("Illegal operation -Pickup Status check failed");

			}

			if (providerNameMap.get(rpr.getLogisticsProviderId())==null){

				sb.append("Logistic provider is not valid");

			}

			if(rpr.getPickupRequestNo()==null || rpr.getPickupRequestNo().trim().isEmpty() ){

				sb.append("Request pickup number can't be empty");

			}

		}

		if (ReturnTxnPickupStatus.PICKUP_RECEIVED == rpr.getPickupStatus()){

			if(!(t_retuenPickuprequest.getPickupStatus() == ReturnTxnPickupStatus.PICKUP_IN_TRANSIT)){

				sb.append("Illegal operation -Pickup Status check failed");

			}

			List<ReturnOrderInfo> all_return_orders = transactionServiceClient.getAllReturnOrdersForReturnPickupRequest(t_retuenPickuprequest.getId());

			for (ReturnOrderInfo r : all_return_orders){

				if (!RECEIVE_PICKUP_STATE_CHECK.contains(r.getReturnStatus())){

					sb.append("Return Order "+r.getId()+" is not marked received.\n");

				}

			}

		}

		return sb.toString();

	}

	public String addNewAddress() throws NumberFormatException,

	UserContextException, TException {

		Address address = new Address();

		address.setLine1(line1);

		address.setLine2(line2);

		address.setLandmark(landmark);

		address.setCity(city);

		address.setState(state);

		address.setPin(pincode);

		address.setCountry(country);

		address.setEnabled(true);

		address.setType(AddressType.findByValue(Integer.valueOf(addressType)));

		address.setName(name);

		address.setPhone(phone);

		String sb = validateAddress(address);

		if (sb.length() == 0) {

			userContextServiceClient = new UserClient().getClient();

			userContextServiceClient.addAddressForUser(Long.valueOf(userId),

					address, false);

		}

		setResult(sb);

		return "result";

	}

	private String validateAddress(Address t_address) {

		StringBuilder sb = new StringBuilder();

		if (t_address.getLine1().trim().length() == 0) {

			sb.append("Line1 can't be empty.");

		}

		if (t_address.getLine2().trim().length() == 0) {

			sb.append("Line2 can't be empty.");

		}

		if (t_address.getCity().trim().length() == 0) {

			sb.append("City can't be empty.");

		}

		if (t_address.getState().trim().length() == 0) {

			sb.append("State can't be empty.");

		}

		if (t_address.getPin().trim().length() < 6) {

			sb.append("Not valid pincode");

		}

		if (t_address.getPhone().trim().length() < 10) {

			sb.append("Not valid phone number");

		}

		if (t_address.getName().trim().length() == 0) {

			sb.append("Not valid name");

		}

		return sb.toString();

	}

	public String createReturnTransaction() throws UserContextException,

	TException, TransactionServiceException {

		ReturnTransaction t_returnTransaction = new ReturnTransaction();

		t_returnTransaction.setAddress_id(Long.valueOf(addressId));

		userContextServiceClient = new UserClient().getClient();

		Address address = userContextServiceClient

		.getAddressById(t_returnTransaction.getAddress_id());

		User user = userContextServiceClient.getUserById(Long.valueOf(userId));

		t_returnTransaction.setCustomer_id(user.getUserId());

		t_returnTransaction.setCustomer_name(address.getName());

		t_returnTransaction.setCustomer_email(user.getEmail());

		t_returnTransaction.setPincode(address.getPin());

		t_returnTransaction.setCustomerPhone(address.getPhone());

		t_returnTransaction.setCustomerCity(address.getCity());

		t_returnTransaction.setCustomerState(address.getState());

		t_returnTransaction.setCustomerAddress(address.getLine1() + " "

				+ address.getLine2());

		List<ReturnOrderInfo> returnOrders = getTableData();

		t_returnTransaction.setReturnOrders(returnOrders);

		transactionServiceClient = new TransactionClient().getClient();

		returnTransaction = transactionServiceClient.createReturnTransaction(

				t_returnTransaction, returnType, canOverideWarranty());

		if (returnTransaction.getId() == 0) {

			setResult(String.valueOf(returnTransaction.getId()));

			return "result";

		}

		return VIEW_RETURN_TRANSACTION;

	}

	public String viewReturnTransaction() throws NumberFormatException, TransactionServiceException, TException {

		returnTransaction = getReturnTransaction(Long.valueOf(returnTransactionId));

		return VIEW_RETURN_TRANSACTION;

	}

	public String viewReturnOrder() throws NumberFormatException, TransactionServiceException, TException {

		returnTransaction = getReturnTransaction(Long.valueOf(returnTransactionId));

		return VIEW_RETURN_TRANSACTION;

	}

	private ReturnTransaction getReturnTransaction(long id) throws TransactionServiceException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		ReturnTransaction t_returnTransaction = transactionServiceClient.getReturnTransaction(id);

		return t_returnTransaction;

	}

	public String changeStatusForReturnTransaction() throws NumberFormatException, TransactionServiceException, TException{

		ReturnTransaction t_returnTransaction = getReturnTransaction(Long.valueOf(returnTransactionId));

		//Check forward_state_map to validate new status

		List<ReturnTransactionStatus> further_states = FORWARD_STATE_MAP.get(t_returnTransaction.getStatus());

		if (further_states.contains(ReturnTransactionStatus.findByValue(Integer.valueOf(newReturnTransactionStatus)))){

			transactionServiceClient = new TransactionClient().getClient();

			transactionServiceClient.changeReturnTransactionStatus(t_returnTransaction.getId(), ReturnTransactionStatus.findByValue(Integer.valueOf(newReturnTransactionStatus)), null);

			setResult("Status changed successfully");

		}

		else{

			setResult("Illegal operation");

		}

		return "result";

	}

	public String getReturnOrderInfoForId() throws NumberFormatException, TransactionServiceException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		setReturnOrderInfo(transactionServiceClient.getReturnOrderInfo(Long.valueOf(returnOrderId)));

		setOrder(transactionServiceClient.getOrder(returnOrderInfo.getOrderId()));

		return VIEW_RETURN_ORDER;

	}

	public String splitReturnOrder() throws TransactionServiceException, NumberFormatException, TException{

		transactionServiceClient = new TransactionClient().getClient();

		ReturnOrderInfo new_return_order = transactionServiceClient.splitReturnOrderInfo(Long.valueOf(returnOrderId), Long.valueOf(splitOrderQuantity));

		if (new_return_order.getId()==0){

			throw new TransactionServiceException();

		}

		setResult("Splitted return order Id "+new_return_order.getId());

		return "result";

	}

	public void setUserId(String userId) {

		this.userId = userId;

	}

	public String getUserId() {

		return userId;

	}

	public void setOrders(List<Order> orders) {

		this.orders = orders;

	}

	public List<Order> getOrders() {

		return orders;

	}

	public void setResult(String result) {

		this.result = result;

	}

	public String getResult() {

		return result;

	}

	public void setTableData(String tableData) {

		this.tableData = tableData;

	}

	public List<ReturnOrderInfo> getTableData() {

		JSONArray jsonTableData = new JSONArray(tableData);

		ArrayList<ReturnOrderInfo> returnOrderInfoList = new ArrayList<ReturnOrderInfo>();

		for (int i = 0; i < jsonTableData.length(); i++) {

			ReturnOrderInfo r = new ReturnOrderInfo();

			r.setOrderId(Long.valueOf(jsonTableData.getJSONObject(i).getString(

			"orderId")));

			r.setReturnQuantity(Long.valueOf(jsonTableData.getJSONObject(i)

					.getString("returnQty")));

			if (r.getReturnQuantity() == 0) {

				continue;

			}

			r.setReturnAction(ReturnAction.findByValue(Integer

					.valueOf(jsonTableData.getJSONObject(i).getString("action"))));

			r.setReturnPickupType(ReturnPickupType.findByValue(Integer

					.valueOf(jsonTableData.getJSONObject(i).getString("returnPickupType"))));

			returnOrderInfoList.add(r);

		}

		return returnOrderInfoList;

	}

	public int checkForOriginalOrders(){

		try{

			if(order.getOriginalOrderId()!=0l && order.getOriginalOrderId() > 0l){

				transactionServiceClient = new TransactionClient().getClient();

				in.shop2020.model.v1.order.Order old_order = transactionServiceClient.getOrder(order.getOriginalOrderId());

				if(old_order.isCod()){

					return 1;

				}

				else{

					return 2;

				}

			}

		}

		catch(Exception e){

			log.error(e);

		}

		return 0;

	}

	public void setAddresses(List<Address> addresses) {

		this.addresses = addresses;

	}

	public List<Address> getAddresses() {

		return addresses;

	}

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getLine1() {

		return line1;

	}

	public void setLine1(String line1) {

		this.line1 = line1;

	}

	public String getLine2() {

		return line2;

	}

	public void setLine2(String line2) {

		this.line2 = line2;

	}

	public String getLandmark() {

		return landmark;

	}

	public void setLandmark(String landmark) {

		this.landmark = landmark;

	}

	public String getCity() {

		return city;

	}

	public void setCity(String city) {

		this.city = city;

	}

	public String getState() {

		return state;

	}

	public void setState(String state) {

		this.state = state;

	}

	public String getCountry() {

		return country;

	}

	public void setCountry(String country) {

		this.country = country;

	}

	public String getPincode() {

		return pincode;

	}

	public void setPincode(String pincode) {

		this.pincode = pincode;

	}

	public String getPhone() {

		return phone;

	}

	public void setPhone(String phone) {

		this.phone = phone;

	}

	public String getAddressType() {

		return addressType;

	}

	public void setAddressType(String addressType) {

		this.addressType = addressType;

	}

	public void setReturnType(String returnType) {

		this.returnType = returnType;

	}

	public String getReturnType() {

		return returnType;

	}

	public void setAddressId(String addressId) {

		this.addressId = addressId;

	}

	public String getAddressId() {

		return addressId;

	}

	public void setReturnTransaction(ReturnTransaction returnTransaction) {

		this.returnTransaction = returnTransaction;

	}

	public ReturnTransaction getReturnTransaction() {

		return returnTransaction;

	}

	public void setNewReturnTransactionStatus(String newReturnTransactionStatus) {

		this.newReturnTransactionStatus = newReturnTransactionStatus;

	}

	public String getNewReturnTransactionStatus() {

		return newReturnTransactionStatus;

	}

	public void setReturnTransactionId(String returnTransactionId) {

		this.returnTransactionId = returnTransactionId;

	}

	public String getReturnTransactionId() {

		return returnTransactionId;

	}

	public String getReturnOrderId() {

		return returnOrderId;

	}

	public void setReturnOrderId(String returnOrderId) {

		this.returnOrderId = returnOrderId;

	}

	public void setReturnOrderInfo(ReturnOrderInfo returnOrderInfo) {

		this.returnOrderInfo = returnOrderInfo;

	}

	public ReturnOrderInfo getReturnOrderInfo() {

		return returnOrderInfo;

	}

	public static void main(String[] args){

		ReturnTransactionsController r = new ReturnTransactionsController();

		System.out.println(r.getForwardStatusForStatus(ReturnTransactionStatus.REJECTED));

		System.out.println(r.getForwardStatusForStatus(ReturnTransactionStatus.INPROCESS));

	}

	public void setReturnOrderInfoList(List<ReturnOrderInfo> returnOrderInfoList) {

		this.returnOrderInfoList = returnOrderInfoList;

	}

	public List<ReturnOrderInfo> getReturnOrderInfoList() {

		return returnOrderInfoList;

	}

	public void setReturnOrderIdsForPickUp(String returnOrderIdsForPickUp) {

		this.returnOrderIdsForPickUp = returnOrderIdsForPickUp;

	}

	public String getReturnOrderIdsForPickUp() {

		return returnOrderIdsForPickUp;

	}

	public void setPickupRequestId(String pickupRequestId) {

		this.pickupRequestId = pickupRequestId;

	}

	public String getPickupRequestId() {

		return pickupRequestId;

	}

	public void setReturnPickupRequest(ReturnPickupRequest returnPickupRequest) {

		this.returnPickupRequest = returnPickupRequest;

	}

	public ReturnPickupRequest getReturnPickupRequest() {

		return returnPickupRequest;

	}

	public Map<Long, String> getAvailableLogisticsPartner(){

		return providerNameMap;

	}

	public String getLogisticProviderName(long providerId){

		return providerNameMap.get(providerId);

	}

	public String getPickupRequestNo() {

		return pickupRequestNo;

	}

	public void setPickupRequestNo(String pickupRequestNo) {

		this.pickupRequestNo = pickupRequestNo;

	}

	public String getLogisticProviderId() {

		return logisticProviderId;

	}

	public void setLogisticProviderId(String logisticProviderId) {

		this.logisticProviderId = logisticProviderId;

	}

	public String getPickupStatus() {

		return pickupStatus;

	}

	public void setPickupStatus(String pickupStatus) {

		this.pickupStatus = pickupStatus;

	}

	public String getPromised_pickup_timestamp() {

		return promised_pickup_timestamp;

	}

	public void setPromised_pickup_timestamp(String promised_pickup_timestamp) {

		this.promised_pickup_timestamp = promised_pickup_timestamp;

	}

	public String getPickedUpAt() {

		return pickedUpAt;

	}

	public void setPickedUpAt(String pickedUpAt) {

		this.pickedUpAt = pickedUpAt;

	}

	public void setReturnTransactions(List<ReturnTransaction> returnTransactions) {

		this.returnTransactions = returnTransactions;

	}

	public List<ReturnTransaction> getReturnTransactions() {

		return returnTransactions;

	}

	public String getReceivedQty() {

		return receivedQty;

	}

	public void setReceivedQty(String receivedQty) {

		this.receivedQty = receivedQty;

	}

	public String getReceivedCondition() {

		return receivedCondition;

	}

	public void setReceivedCondition(String receivedCondition) {

		this.receivedCondition = receivedCondition;

	}

	public String[] getSerialNumbers() {

		return serialNumbers;

	}

	public void setSerialNumbers(String[] serialNumbers) {

		this.serialNumbers = serialNumbers;

	}

	public String getScanFreebie() {

		return scanFreebie;

	}

	public void setScanFreebie(String scanFreebie) {

		this.scanFreebie = scanFreebie;

	}

	public String getProductUsable() {

		return productUsable;

	}

	public void setProductUsable(String productUsable) {

		this.productUsable = productUsable;

	}

	public void setSplitOrderQuantity(String splitOrderQuantity) {

		this.splitOrderQuantity = splitOrderQuantity;

	}

	public String getSplitOrderQuantity() {

		return splitOrderQuantity;

	}

	public void setRefundType(String refundType) {

		this.refundType = refundType;

	}

	public String getRefundType() {

		return refundType;

	}

	public void setRefundAmount(String refundAmount) {

		this.refundAmount = refundAmount;

	}

	public String getRefundAmount() {

		return refundAmount;

	}

	public void setRefundReason(String refundReason) {

		this.refundReason = refundReason;

	}

	public String getRefundReason() {

		return refundReason;

	}

	public void setOrder(Order order) {

		this.order = order;

	}

	public Order getOrder() {

		return order;

	}

	public String getRefundDescription() {

		return refundDescription;

	}

	public void setRefundDescription(String refundDescription) {

		this.refundDescription = refundDescription;

	}

	public String getChequeDetails() {

		return chequeDetails;

	}

	public void setChequeDetails(String chequeDetails) {

		this.chequeDetails = chequeDetails;

	}

	public String getShippingType() {

		return shippingType;

	}

	public void setShippingType(String shippingType) {

		this.shippingType = shippingType;

	}

	public String getCouponDetails() {

		return couponDetails;

	}

	public void setCouponDetails(String couponDetails) {

		this.couponDetails = couponDetails;

	}

}