Subversion Repositories SmartDukaan

package in.shop2020.hotspot.dashbaord.server;

import in.shop2020.hotspot.dashbaord.shared.actions.Order;

import in.shop2020.hotspot.dashbaord.shared.actions.OrderType;

import in.shop2020.hotspot.dashbaord.shared.actions.ReturnOrder;

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

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

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

import in.shop2020.thrift.clients.TransactionClient;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

/**

 * This class is a facade to the Transaction service and should be used to

 * access all order specific data.

 * 

 * @author Chandranshu

 * 

 */

public class TransactionUtils {

	/**

	 * The human user is concerned only with a consolidated view of actionable

	 * orders. Orders with different statuses in the database can be part of the

	 * same consolidated view. This method uses a mapping of <i>type</i> to

	 * <i>status</i> to get all such orders and return them as order beans.

	 * 

	 * @param type

	 *            The type of orders to return.

	 * @param warehouseId

	 *            The warehouse for which the orders should be queried.

	 * @return A list of orders of the given type to be fulfilled from the given

	 *         warehouse

	 */

	public static List<Order> getOrders(OrderType type, long warehouseId){

		List<OrderStatus> statuses = getStatuses(type);

		List<Order> orders = new ArrayList<Order>();

		try{

			TransactionClient client = new TransactionClient();

			Client c = client.getClient();

			List<in.shop2020.model.v1.order.Order> t_orders = new ArrayList<in.shop2020.model.v1.order.Order>();

			if(statuses.isEmpty()){

				t_orders.addAll(c.getAllOrders(null, 0L, new Date().getTime(), warehouseId));

			}

			else {

				for(OrderStatus status: statuses){

					t_orders.addAll(c.getAllOrders(status, 0L, new Date().getTime(), warehouseId));

				}

			}

			for (in.shop2020.model.v1.order.Order t_order: t_orders){

				Order o = getOrderFromThriftOrder(t_order);

				orders.add(o);

				//TODO: We'll figure out how to show an alert. I don't think we need another thrift call for that.

				//check if it has an associated alert

//				List<Alert> alerts = c.getAlerts(t_order.getId(), true);

//				if(alerts != null && alerts.size() != 0){

//					o.setAlert(true);

//					o.setStatusMessage(alerts.iterator().next().getComment());

//				} else {

//					o.setAlert(false);

//				}

			}

		}catch(Exception e){

			e.printStackTrace();

		}

		return orders;

	}

	/**

	 * Calls the same method of the transaction service and returns the status

	 * returned. Catches all exceptions that are raised and returns false in

	 * that case.

	 * 

	 * @param warehouseId

	 *            The warehouse for which the orders should be marked as

	 *            manifested.

	 * @param providerId

	 *            The provider for which the orders should be marked as

	 *            manifested.

	 * @param cod

	 *             Whether cod orders have to be marked as manifested

	 * @return True if everything goes fine, false otherwise.

	 */

	public static boolean markOrdersAsManifested(long warehouseId, String providerId, boolean cod){

		try {

			long provider_id = Long.parseLong(providerId);

			TransactionClient client = new TransactionClient();

			Client c = client.getClient();

			return c.markOrdersAsManifested(warehouseId, provider_id, cod);

		}catch(Exception e){

			e.printStackTrace();

			return false;

		}

	}

	/**

	 * 

	 * @param t_order

	 *            A thrift order object with line items.

	 * @return an Order bean which can be used for rendering on the client side.

	 */

	public static Order getOrderFromThriftOrder(in.shop2020.model.v1.order.Order t_order) {

		LineItem lineItem = t_order.getLineitems().get(0);

		String delayReason = null;

		if(t_order.getDelayReason() != null)

		    delayReason = t_order.getDelayReason().name(); 

		Order order = new Order(t_order.getId(),

				t_order.getCustomer_id(),

				t_order.getCustomer_name(),

				t_order.getCustomer_mobilenumber(),

				t_order.getCustomer_pincode(),

				t_order.getCustomer_address1(),

				t_order.getCustomer_address2(),

				t_order.getCustomer_city(),

				t_order.getCustomer_state(),

				t_order.getCustomer_email(),

				t_order.getCreated_timestamp(),

				t_order.getShipping_timestamp(),

				t_order.getVerification_timestamp(),

				t_order.getExpected_delivery_time(),

				t_order.getPromised_delivery_time(),

				t_order.getExpected_shipping_time(),

				t_order.getStatus().getValue(),

				t_order.getStatusDescription(),

				lineItem.getItem_id(),

				lineItem.getProductGroup(),

				lineItem.getBrand(),

				lineItem.getModel_name(),

				lineItem.getModel_number(),

				lineItem.getColor(),

				lineItem.getExtra_info(),

				t_order.getTotal_amount(),

				t_order.getTotal_weight(),

				t_order.getAirwaybill_no(),

				t_order.getBilled_by(),

				t_order.getInvoice_number(),

				t_order.getJacket_number(),

				lineItem.getItem_number(),

				lineItem.getImei_number(),

				t_order.getBatchNo(),

				t_order.getSerialNo(),

				t_order.isDoaFlag(),

				t_order.getPickupRequestNo(),

				t_order.isCod(),

				delayReason);

		return order;

	}

	/**

	 * Queries the transction server to get the list of all return orders that

	 * have to be processed.

	 * 

	 * @return A list of all return orders to be processed.

	 */

	public static List<ReturnOrder> getReturnOrders(long warehouseId){

		List<ReturnOrder> retOrders = new ArrayList<ReturnOrder>();

		try{

			TransactionClient client = new TransactionClient();

			Client c = client.getClient();

			List<in.shop2020.model.v1.order.ReturnOrder> tRetOrders =  c.getReturnOrders(warehouseId, 0L, new Date().getTime());

			for(in.shop2020.model.v1.order.ReturnOrder retOrder : tRetOrders){

				retOrders.add(getReturnOrderFromThriftRO(retOrder));

			}

		}catch(Exception e){

			e.printStackTrace();

		}

		return retOrders;

	}

	public static ReturnOrder getReturnOrderFromThriftRO(in.shop2020.model.v1.order.ReturnOrder tRetOrder){

		ReturnOrder retOrder = new ReturnOrder(tRetOrder.getOrderId(),

				tRetOrder.getWarehouseId(),

				tRetOrder.getItemId(),

				tRetOrder.getProductGroup(),

				tRetOrder.getBrand(),

				tRetOrder.getModelName(),

				tRetOrder.getModelNumber(),

				tRetOrder.getColor(),

				tRetOrder.getInvoiceNumber(),

				tRetOrder.getJacketNumber(),

				tRetOrder.getTotalPrice(),

				tRetOrder.getTransferPrice(),

				false,

				tRetOrder.getCreatedAt());

		return retOrder;

	}

	/**

	 * This method maps a given type to a list of statuses.

	 * 

	 * @param type

	 *            The type of orders to fetch.

	 * @return The list of Thrift statuses associated with a particular order

	 *         type.

	 */

	private static List<OrderStatus> getStatuses(OrderType type) {

		List<OrderStatus> statuses = new ArrayList<OrderStatus>();

		switch (type) {

		case ACCEPTED:

			statuses.add(OrderStatus.ACCEPTED);

			break;

		case ALL:

			break;

		case NEW:

			statuses.add(OrderStatus.SUBMITTED_FOR_PROCESSING);

			statuses.add(OrderStatus.INVENTORY_LOW);

			break;

		case BILLED:

			statuses.add(OrderStatus.BILLED);

			break;

		case NO_STOCK:

			statuses.add(OrderStatus.INVENTORY_LOW);

			break;

		case REJECTED:

			statuses.add(OrderStatus.REJECTED);

			break;

		case SHIPPED:

			statuses.add(OrderStatus.SHIPPED_FROM_WH);

			statuses.add(OrderStatus.SHIPPED_TO_LOGST);

			break;

		case DELIVERED:

			statuses.add(OrderStatus.DELIVERY_SUCCESS);

			statuses.add(OrderStatus.DOA_PICKUP_REQUESTED);

			break;

		case DOA_AWAITED:

			statuses.add(OrderStatus.DOA_RETURN_AUTHORIZED);

			statuses.add(OrderStatus.DOA_RETURN_IN_TRANSIT);

			statuses.add(OrderStatus.DOA_RECEIVED);

			break;

		case SALES_RETURN_AWAITED:

			statuses.add(OrderStatus.SALES_RETURN_IN_TRANSIT);

			break;

		case DOA_RETURNED:

			statuses.add(OrderStatus.DOA_CERT_VALID);

			break;

		case SALES_RETURNED:

			statuses.add(OrderStatus.SALES_RET_RECEIVED);

			statuses.add(OrderStatus.DOA_CERT_INVALID);

			break;

		case RESHIPPED:

			statuses.add(OrderStatus.SALES_RET_RESHIPPED);

			statuses.add(OrderStatus.DOA_INVALID_RESHIPPED);

			statuses.add(OrderStatus.DOA_RESHIPPED);

			break;

		case REFUNDED:

		    statuses.add(OrderStatus.CANCELED);

			statuses.add(OrderStatus.SALES_RET_REFUNDED);

			statuses.add(OrderStatus.DOA_INVALID_REFUNDED);

			statuses.add(OrderStatus.DOA_VALID_REFUNDED);

			statuses.add(OrderStatus.REFUNDED);

			break;

		case VERIFICATION_PENDING:

		    statuses.add(OrderStatus.INIT);

		    break;

		default:

			break;

		}

		return statuses;

	}

}