Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.model.v1.order.LineItem;
import in.shop2020.model.v1.order.Order;
import in.shop2020.payments.Attribute;
import in.shop2020.payments.Constants;
import in.shop2020.payments.Payment;
import in.shop2020.payments.PaymentException;
import in.shop2020.thrift.clients.PaymentServiceClient;
import in.shop2020.thrift.clients.TransactionServiceClient;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;

import org.apache.log4j.Logger;
import org.apache.thrift.TApplicationException;
import org.apache.thrift.TException;

/**
 * @author vikas
 *
 */
@SuppressWarnings("serial")
public class UserOrderInfoController extends BaseController {
    private static Logger log = Logger.getLogger(Class.class);
    private long userId;
    private long orderId;
    private Map<String, String> userOrder;
    private List<Map<String, String>> lineItemsList;
    private List<Map<String, String>> paymentsList;

    public UserOrderInfoController(){
        super();
    }

    public String index() throws Exception {
        PaymentServiceClient paymentServiceClient = new PaymentServiceClient();
        TransactionServiceClient transactionServiceClient = new TransactionServiceClient();
        Order order = null;
        try {
            order = transactionServiceClient.getClient().getOrderForCustomer(orderId, userId);
        }
        catch (Exception e) {
            addActionError("Invalid order id or no order selected.");
            return "index";
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        sdf.setTimeZone(TimeZone.getTimeZone("IST"));
        setUserOrderMap(order, sdf);
        setLineItems(order.getLineitems());

        List<Payment> payments = paymentServiceClient.getClient().getPaymentForTxnId(order.getTransactionId());
        if (payments != null && !payments.isEmpty()) {
            setPayments(payments, sdf, paymentServiceClient);
        }
        return "index";
    }

    private void setPayments(List<Payment> payments, SimpleDateFormat sdf, PaymentServiceClient paymentServiceClient) throws PaymentException, TException {
        paymentsList = new ArrayList<Map<String,String>>();
        for (Payment payment : payments) {
            Map<String,String> paymentMap = new HashMap<String, String>();
            if (payment.getAuthCode() != null && !payment.getAuthCode().isEmpty()) {
                paymentMap.put("authcode", payment.getAuthCode());
            }
            if (payment.getDescription() != null && !payment.getDescription().isEmpty()) {
                paymentMap.put("description", payment.getDescription());
            }
            if (payment.getErrorCode() != null && !payment.getErrorCode().isEmpty()) {
                paymentMap.put("errorcode", payment.getErrorCode());
            }
            if (payment.getGatewayPaymentId() != null && !payment.getGatewayPaymentId().isEmpty()) {
                paymentMap.put("gatewaypaymentid", payment.getGatewayPaymentId());
            }
            if (payment.getGatewayTxnDate() != null && !payment.getGatewayTxnDate().isEmpty()) {
                paymentMap.put("gatewaytxndt", payment.getGatewayTxnDate());
            }
            if (payment.getGatewayTxnId() != null && !payment.getGatewayTxnId().isEmpty()) {
                paymentMap.put("gatewaytxnid", payment.getGatewayTxnId());
            }
            if (payment.getGatewayTxnStatus() != null && !payment.getGatewayTxnStatus().isEmpty()) {
                paymentMap.put("gatewaytxnstatus", payment.getGatewayTxnStatus());
            }
            if (payment.getReferenceCode() != null && !payment.getReferenceCode().isEmpty()) {
                paymentMap.put("refcode", payment.getReferenceCode());
            }
            if (payment.getSessionId() != null && !payment.getSessionId().isEmpty()) {
                paymentMap.put("sessioid", payment.getSessionId());
            }
            paymentMap.put("amount", Double.toString(payment.getAmount()));
            paymentMap.put("status", payment.getStatus().name());
            try {
                paymentMap.put("gatewayname", paymentServiceClient.getClient().getPaymentGateway(payment.getGatewayId()).getName());
            }
            catch (TApplicationException e) {
                log.warn("No payment gateway set", e);
            }
            paymentMap.put("paymethod", getPaymentMethod(payment.getAttributes()));
            
            if (payment.getSuccessTimestamp() != 0) {
                paymentMap.put("successts", sdf.format(new Date(payment.getSuccessTimestamp())));
            }
            paymentsList.add(paymentMap);
        }
    }

    private void setLineItems(List<LineItem> lineitems) {
        lineItemsList = new ArrayList<Map<String,String>>();
        for (LineItem lItem : lineitems) {
            Map<String, String> lineItemMap = new HashMap<String, String>();
            StringBuilder productName = new StringBuilder();
            if (lItem.getBrand() != null && !lItem.getBrand().isEmpty()) {
                productName.append(lItem.getBrand() + " ");
            }
            if (lItem.getModel_name() != null && !lItem.getModel_name().isEmpty()) {
                productName.append(lItem.getModel_name()  + " ");
            }
            if (lItem.getModel_number() != null && !lItem.getModel_number().isEmpty()) {
                productName.append(lItem.getModel_number()  + " ");
            }
            lineItemMap.put("name", productName.toString());
            lineItemMap.put("quantity", Double.toString(lItem.getQuantity()));
            lineItemMap.put("unit_price", Double.toString(lItem.getUnit_price()));
            lineItemMap.put("total_price", Double.toString(lItem.getTotal_price()));
            lineItemsList.add(lineItemMap);
        }
    }

    private void setUserOrderMap(Order order, SimpleDateFormat sdf) {
        userOrder = new HashMap<String, String>();
        userOrder.put("id", Long.toString(order.getId()));
        if (order.getCreated_timestamp() != 0) {
            userOrder.put("created", sdf.format(new Date(order.getCreated_timestamp())));
        }
        if (order.getDelivery_timestamp() != 0) {
            userOrder.put("delivered", sdf.format(new Date(order.getDelivery_timestamp())));
        }
        if (order.getAccepted_timestamp() != 0) {
            userOrder.put("accepted", sdf.format(new Date(order.getAccepted_timestamp())));
        }
        if (order.getBilling_timestamp() != 0) {
            userOrder.put("billingts", sdf.format(new Date(order.getBilling_timestamp())));
        }
        if (order.getExpected_delivery_time() != 0) {
            userOrder.put("expdelivery", sdf.format(new Date(order.getExpected_delivery_time())));
        }
        if (order.getShipping_timestamp() != 0) {
            userOrder.put("shippingts", sdf.format(new Date(order.getShipping_timestamp())));
        }
        if (order.getPickup_timestamp() != 0) {
            userOrder.put("pickupts", sdf.format(new Date(order.getPickup_timestamp())));
        }
        if (order.getOutofstock_timestamp() != 0) {
            userOrder.put("outofstockts", sdf.format(new Date(order.getOutofstock_timestamp())));
        }
        userOrder.put("serialno", Long.toString(order.getSerialNo()));
        userOrder.put("airwaybillno", order.getAirwaybill_no());
        userOrder.put("billedby", order.getBilled_by());
        userOrder.put("invoiceno", order.getInvoice_number());
        userOrder.put("receiver", order.getReceiver());
        userOrder.put("status", order.getStatusDescription());
        userOrder.put("trackingid", order.getTracking_id());
        userOrder.put("amount", Double.toString(order.getTotal_amount()));

        StringBuilder address = new StringBuilder();
        if (order.getCustomer_address1() != null) {
            address.append(order.getCustomer_address1() + ", ");
        }
        if (order.getCustomer_address2() != null) {
            address.append(order.getCustomer_address2() + ", ");
        }
        if (order.getCustomer_city() != null) {
            address.append(order.getCustomer_city() + ", ");
        }
        if (order.getCustomer_state() != null) {
            address.append(order.getCustomer_state() + "-");
        }
        if (order.getCustomer_pincode() != null) {
            address.append(order.getCustomer_pincode());
        }
        userOrder.put("shipping", address.toString());
    }
    
    public String getPaymentMethod(List<Attribute> paymentAttributes) {
        String paymentMethod = null;
        if(paymentAttributes == null || paymentAttributes.isEmpty()) {
            return "N/A";
        }
        for(Attribute a : paymentAttributes) {
            if("payMethod".equals(a.getName())) {
                paymentMethod = Constants.PAYMENT_METHOD.get(a.getValue());
                break;
            }
        }
        return paymentMethod != null ? paymentMethod : "N/A";
    }

    public void setUserId(String userId) {
        try {
            this.userId = Long.parseLong(userId);
        }
        catch (NumberFormatException e) {
            log.error(e);
        }
    }

    public void setOrderId(String orderId) {
        try {
            this.orderId = Long.parseLong(orderId);
        }
        catch (NumberFormatException e) {
            log.error(e);
        }
    }

    public Long getUserId() {
        return userId;
    }

    public Map<String, String> getUserOrder() {
        return userOrder;
    }

    public List<Map<String, String>> getLineItemsList() {
        return lineItemsList;
    }

    public List<Map<String, String>> getPaymentsList() {
        return paymentsList;
    }
}