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.catalog.InventoryType;

import in.shop2020.model.v1.catalog.Item;

import in.shop2020.model.v1.catalog.ItemType;

import in.shop2020.model.v1.catalog.Warehouse;

import in.shop2020.model.v1.catalog.WarehouseType;

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.CatalogClient;

import in.shop2020.thrift.clients.TransactionClient;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.GregorianCalendar;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

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

 * access all order specific data which requires some kind of transformation.

 * 

 * @author Chandranshu

 * 

 */

public class TransactionUtils {

	private static String courierDetailsPath = "/CourierDetailReports";

	private static Logger logger = LoggerFactory.getLogger(TransactionUtils.class);

	/**

	 * 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 offset

	 *            Offset to start from

	 * @param limit

	 *            No. 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 offset, long limit, long warehouseId){

		List<OrderStatus> statuses = getStatuses(type);

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

		try{

			TransactionClient txnClient = new TransactionClient();

			Client client = txnClient.getClient();

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

			t_orders.addAll(client.getOrdersInBatch(statuses, offset, limit, warehouseId));

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

				Order o = getOrderFromThriftOrder(t_order);

				orders.add(o);

			}

		}catch(Exception e){

			e.printStackTrace();

		}

		return orders;

	}

	/**

	 * Wrapper around the method of same name in the transaction service. This

	 * method uses a mapping of <i>type</i> to <i>status</i> to get the count of

	 * all orders with a given status.

	 * 

	 * @param type

	 *            The type of orders to return.

	 * @param warehouseId

	 *            The warehouse for which the orders should be queried.

	 * @return The count of orders of the given type assigned to the given

	 *         warehouse.

	 */

	public static int getOrderCount(OrderType type, long warehouseId){

		List<OrderStatus> statuses = getStatuses(type);

		int count = 0;

		try{

			TransactionClient txnClient = new TransactionClient();

			Client client = txnClient.getClient();

			count += client.getOrderCount(statuses, warehouseId);

		}catch(Exception e){

			e.printStackTrace();

		}

		return count;

	}

	/**

	 * 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 List<Long> getBilledOrders(long warehouseId, String providerId, boolean cod){

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

		try {

			long provider_id = Long.parseLong(providerId);

			TransactionClient client = new TransactionClient();

			Client c = client.getClient();

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

			statuses.add(OrderStatus.BILLED);

			List<in.shop2020.model.v1.order.Order> torders = c.getOrdersInBatch(statuses, 0, 0, warehouseId);

			for(in.shop2020.model.v1.order.Order torder: torders){

				if(torder.getLogistics_provider_id() == provider_id && torder.isCod() == cod){

					orders.add(torder.getId());

				}

			}

		}catch(Exception e){

			e.printStackTrace();

		}

		return orders;

	}

	public static boolean generateCourierDetailsFile(List<Long> orderIds, long providerId, long warehouseId, boolean isCod){

		Calendar date = new GregorianCalendar();

		int year = date.get(Calendar.YEAR);

		int month = date.get(Calendar.MONTH) +1;

		int day = date.get(Calendar.DAY_OF_MONTH);

		String fileNameSuffix = "-" + warehouseId + "-"+ providerId + "-" + year + "-" + month + "-" + day;

		if(isCod){

		    fileNameSuffix = "cod" + fileNameSuffix ;

		}

		else{

		    fileNameSuffix = "prepaid" + fileNameSuffix;

		}

		try {

			String fileName = courierDetailsPath + "/courier-details-" + fileNameSuffix + "-temp.xls";

			FileOutputStream f = new FileOutputStream(fileName);

			CourierDetailsGenerator courierDetailsGenerator = new CourierDetailsGenerator();

			ByteArrayOutputStream baosXLS = courierDetailsGenerator.generateCourierDetails(orderIds, warehouseId, providerId, isCod);

			baosXLS.writeTo(f);

			f.close();

		} catch (FileNotFoundException e) {

			logger.error("Unable to create the courier details file", e);

		} catch (IOException e) {

			logger.error("Unable to create the courier details file", e);

		}

		CourierDetailsReportMerger merger = new CourierDetailsReportMerger();

		try {

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

			String fName;

			fName = courierDetailsPath + "/courier-details-" + fileNameSuffix + "-temp.xls";

			if((new File(fName)).exists()){

				warehouseIdFileNames.put(0L, fName);

			}

			fName = courierDetailsPath + "/courier-details-" + fileNameSuffix + ".xls";

			if((new File(fName)).exists()){

				warehouseIdFileNames.put(1L, fName);

			}

			ByteArrayOutputStream binXLS = merger.mergeCourierDetailsReports(warehouseIdFileNames);

			FileOutputStream f = new FileOutputStream(courierDetailsPath + "/courier-details-" + fileNameSuffix + ".xls");

			binXLS.writeTo(f);

			f.close();

			File tempFile = new File(courierDetailsPath + "/courier-details-" + fileNameSuffix + "-temp.xls");

			if(tempFile.exists()){

				tempFile.delete();

			}

		} catch (FileNotFoundException e) {

			logger.error("Error while creating the Courier Details report", e);

		} catch (IOException e) {

			logger.error("IO error while writing the Courier Details report", e);

		}

		return true;

	}

	/**

	 * 

	 * @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 pickFromWarehouse = null;

		Item item = null;

        try {

            in.shop2020.model.v1.catalog.InventoryService.Client client = new CatalogClient().getClient();

            item = client.getItem(lineItem.getItem_id());

            pickFromWarehouse = CatalogUtils.getWarehousesForBillingWarehouse(t_order.getWarehouse_id())

                                    .get(t_order.getFulfilmentWarehouseId());

            if (pickFromWarehouse == null) {

                Warehouse warehouse = client.getWarehouse(t_order.getFulfilmentWarehouseId());

                pickFromWarehouse = client.getWarehouses(null, InventoryType.GOOD, warehouse.getVendor().getId(), t_order.getWarehouse_id(), 0).get(0).getDisplayName();

            }

		}

        catch (Exception e) {

            logger.error("Error looking up warehouse: " + t_order.getVendorId(), e);

        }

		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.getPromised_shipping_time(),

				t_order.getStatus().getValue(),

				t_order.getStatusDescription(),

				t_order.getOrderType().name(),

				lineItem.getItem_id(),

				lineItem.getProductGroup(),

				lineItem.getBrand(),

				lineItem.getModel_name(),

				lineItem.getModel_number(),

				lineItem.getColor(),

				lineItem.getExtra_info(),

				lineItem.getDealText(),

				lineItem.getQuantity(),

				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.getSerial_number(),

				t_order.getBatchNo(),

				t_order.getSerialNo(),

				t_order.isDoaFlag(),

				t_order.getPickupRequestNo(),

				t_order.isCod(),

				delayReason,

				pickFromWarehouse,

				ItemType.SERIALIZED.equals(item.getType()),

				t_order.getFulfilmentWarehouseId());

		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.

	 */

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

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

		switch (type) {

		case ACCEPTED:

			statuses.add(OrderStatus.ACCEPTED);

			break;

		case ALL_PENDING:

			statuses.add(OrderStatus.SUBMITTED_FOR_PROCESSING);

			statuses.add(OrderStatus.CAPTURE_IN_PROCESS);

			statuses.add(OrderStatus.INVENTORY_LOW);

			statuses.add(OrderStatus.LOW_INV_PO_RAISED);

			statuses.add(OrderStatus.LOW_INV_REVERSAL_IN_PROCESS);

			statuses.add(OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT);

			break;

		case NEW:

			statuses.add(OrderStatus.SUBMITTED_FOR_PROCESSING);

			statuses.add(OrderStatus.CAPTURE_IN_PROCESS);

			break;

		case BILLED:

			statuses.add(OrderStatus.BILLED);

			break;

		case LOW_INVENTORY:

			statuses.add(OrderStatus.INVENTORY_LOW);

			break;

		case PO_RAISED:

			statuses.add(OrderStatus.LOW_INV_PO_RAISED);

			break;

		case REVERSAL_INITIATED:

			statuses.add(OrderStatus.LOW_INV_REVERSAL_IN_PROCESS);

			break;

		case NOT_AVAILABLE:

			statuses.add(OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT);

			break;

		case CANCEL_CONFIRMED:

			statuses.add(OrderStatus.CANCEL_REQUEST_CONFIRMED);

			break;

		case DOA_REQUEST_AUTHORIZED:

			statuses.add(OrderStatus.DOA_REQUEST_AUTHORIZED);

			statuses.add(OrderStatus.DOA_PICKUP_REQUEST_RAISED);

			break;

		case LOST_IN_TRANSIT:

			statuses.add(OrderStatus.LOST_IN_TRANSIT);

			break;

		case DOA_LOST_IN_TRANSIT:

			statuses.add(OrderStatus.DOA_LOST_IN_TRANSIT);

			break;

		case DOA_RECEIVED_DAMAGED:

			statuses.add(OrderStatus.DOA_RECEIVED_DAMAGED);

			break;

		case RET_REQUEST_AUTHORIZED:

			statuses.add(OrderStatus.RET_REQUEST_AUTHORIZED);

			statuses.add(OrderStatus.RET_PICKUP_REQUEST_RAISED);

			break;

		case RET_AWAITED:

			statuses.add(OrderStatus.RET_RETURN_IN_TRANSIT);

			statuses.add(OrderStatus.RET_PICKUP_CONFIRMED);

			break;

		case RET_RECEIVED_PRESTINE:

			statuses.add(OrderStatus.RET_RECEIVED_PRESTINE);

			statuses.add(OrderStatus.RET_PRODUCT_USABLE);

			break;

		case RET_LOST_IN_TRANSIT:

			statuses.add(OrderStatus.RET_LOST_IN_TRANSIT);

			break;

		case RET_RECEIVED_DAMAGED:

			statuses.add(OrderStatus.RET_RECEIVED_DAMAGED);

			statuses.add(OrderStatus.RET_PRODUCT_UNUSABLE);

			break;

		case REJECTED:

			statuses.add(OrderStatus.REJECTED);

			break;

		case SHIPPED:

			statuses.add(OrderStatus.SHIPPED_FROM_WH);

			statuses.add(OrderStatus.SHIPPED_TO_LOGST);

			statuses.add(OrderStatus.SHIPPED_TO_DESTINATION_CITY);

			statuses.add(OrderStatus.REACHED_DESTINATION_CITY);

			statuses.add(OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE);

			break;

		case DELIVERED:

			statuses.add(OrderStatus.DELIVERY_SUCCESS);

			statuses.add(OrderStatus.DOA_PICKUP_REQUEST_RAISED);

			break;

		case DOA_AWAITED:

			statuses.add(OrderStatus.DOA_PICKUP_CONFIRMED);

			statuses.add(OrderStatus.DOA_RETURN_IN_TRANSIT);

			statuses.add(OrderStatus.DOA_RECEIVED_PRESTINE);

			break;

		case RTO_AWAITED:

			statuses.add(OrderStatus.RTO_IN_TRANSIT);

			break;

        case RTO_RECEIVED_DAMAGED:

            statuses.add(OrderStatus.RTO_RECEIVED_DAMAGED);

            break;

        case DOA_RECEIVED_PRESTINE:

			statuses.add(OrderStatus.DOA_CERT_VALID);

			statuses.add(OrderStatus.DOA_CERT_INVALID);

			break;

		case RTO_RETURNED:

			statuses.add(OrderStatus.RTO_RECEIVED_PRESTINE);

			break;

		case RESHIPPED:

			statuses.add(OrderStatus.RTO_RESHIPPED);

			statuses.add(OrderStatus.DOA_INVALID_RESHIPPED);

			statuses.add(OrderStatus.DOA_VALID_RESHIPPED);

			break;

		case REFUNDED:

		    statuses.add(OrderStatus.COD_VERIFICATION_FAILED);

			statuses.add(OrderStatus.RTO_REFUNDED);

			statuses.add(OrderStatus.DOA_INVALID_REFUNDED);

			statuses.add(OrderStatus.DOA_VALID_REFUNDED);

			statuses.add(OrderStatus.CANCELLED_DUE_TO_LOW_INVENTORY);

			break;

		case VERIFICATION_PENDING:

		    statuses.add(OrderStatus.COD_VERIFICATION_PENDING);

		    break;

		default:

			break;

		}

		return statuses;

	}

}