Subversion Repositories SmartDukaan

package in.shop2020.serving.controllers;

import in.shop2020.crm.Activity;

import in.shop2020.crm.ActivityType;

import in.shop2020.crm.SearchFilter;

import in.shop2020.crm.Ticket;

import in.shop2020.crm.TicketCategory;

import in.shop2020.crm.TicketPriority;

import in.shop2020.crm.TicketStatus;

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

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

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

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

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

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

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

import in.shop2020.payments.Attribute;

import in.shop2020.payments.Constants;

import in.shop2020.payments.Payment;

import in.shop2020.payments.PaymentException;

import in.shop2020.payments.PaymentService.Client;

import in.shop2020.serving.auth.CRMAuthorizingRealm;

import in.shop2020.serving.model.ShipmentUpdate;

import in.shop2020.serving.services.BlueDartTrackingService;

import in.shop2020.thrift.clients.CRMClient;

import in.shop2020.thrift.clients.PaymentClient;

import in.shop2020.thrift.clients.TransactionClient;

import in.shop2020.thrift.clients.UserClient;

import in.shop2020.utils.ModelUtils;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.concurrent.Callable;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

import net.htmlparser.jericho.Source;

import org.apache.log4j.Logger;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

/**

 * @author vikas

 * 

 */

@SuppressWarnings("serial")

public class UserOrderInfoController extends BaseController {

    private static Logger                  log                     = Logger.getLogger(Class.class);

    private static BlueDartTrackingService blueDartTrackingService = new BlueDartTrackingService();

    private long                 orderId;

    private Order                order;

    private List<Payment>        payments;

    private List<ShipmentUpdate> shipmentUpdates = new ArrayList<ShipmentUpdate>();

    private Long                 codTicketId;

    private List<Address>        addresses;

    private Set<OrderStatus>     setOfcancellableStates;

    private String               cancellationInitiator;

    private String               cancelReason;

    private String               body;

    public UserOrderInfoController() {

        super();

        setOfcancellableStates = new HashSet<OrderStatus>();

        setOfcancellableStates.add(OrderStatus.SUBMITTED_FOR_PROCESSING);

        setOfcancellableStates.add(OrderStatus.INVENTORY_LOW);

        setOfcancellableStates.add(OrderStatus.LOW_INV_PO_RAISED);

        setOfcancellableStates.add(OrderStatus.LOW_INV_REVERSAL_IN_PROCESS);

        setOfcancellableStates.add(OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT);

        setOfcancellableStates.add(OrderStatus.ACCEPTED);

        setOfcancellableStates.add(OrderStatus.BILLED);

        setOfcancellableStates.add(OrderStatus.PAYMENT_FLAGGED);

    }

    public String index() {

        try {

            PaymentClient paymentServiceClient = new PaymentClient();

            TransactionClient transactionServiceClient = new TransactionClient();

            order = transactionServiceClient.getClient().getOrder(orderId);

            payments = paymentServiceClient.getClient()

            .getPaymentForTxnId(order.getTransactionId());

            // Spawning a thread to capture shipment updates from Bluedart

            // This is done to ensure that response from Crm web app is sent

            // within given time limits. Also, we wont be affected in the cases 

            // where bluedart site is down or slow

            Executors.newSingleThreadExecutor().invokeAll(Collections.singletonList(new Callable<Boolean>() {

                public Boolean call() throws Exception {

                    shipmentUpdates = blueDartTrackingService.getUpdates(order.getAirwaybill_no());

                    return true;

                }

            }), 5, TimeUnit.SECONDS);

            if (order.isCod() && OrderStatus.COD_VERIFICATION_PENDING.equals(order.getStatus())) {

                populateCODTicketId(order.getCustomer_id());

            }

            if (canEditOrderAddress()) {

                userContextServiceClient = new UserClient().getClient();

                addresses = userContextServiceClient.getAllAddressesForUser(order.getCustomer_id());

            }

        } catch (TTransportException e) {

            log.error("Unable to create thrift Client", e);

        } catch (TransactionServiceException e) {

            addActionError("Invalid order id or no order selected.");

        } catch (TException e) {

            log.error("Unable to get thrift Client", e);

        } catch (PaymentException e) {

            log.error("Unable to get payments for transctionId : " + order.getTransactionId(), e);

        } catch (InterruptedException e) {

            log.error("Thread was interrupted", e);

        } catch (UserContextException e) {

            log.error("Unable to get addresses for user : " + order.getCustomer_id(), e);

        }

        return INDEX;

    }

    private boolean canEditOrderAddress() {

        return false;

    }

    private void populateCODTicketId(long customerId) {

        try {

            SearchFilter searchFilter = new SearchFilter();

            searchFilter.setTicketCategory(TicketCategory.COD_VERIFICATION);

            searchFilter.setTicketStatuses(new ArrayList<TicketStatus>());

            searchFilter.getTicketStatuses().add(TicketStatus.OPEN);

            searchFilter.getTicketStatuses().add(TicketStatus.REOPEN);

            searchFilter.setCustomerId(customerId);

            crmServiceClient = new CRMClient().getClient();

            List<Ticket> tickets = crmServiceClient.getTickets(searchFilter);

            if (tickets != null && !tickets.isEmpty()) {

                codTicketId = tickets.get(0).getId();

            }

        } catch (TException e) {

            log.error("Error fetching tickets for customerId: " + customerId, e);

        }

    }

    public String markOrderForCancellation() {

        try{

            TransactionClient transactionServiceClient = new TransactionClient();

            log.info("URL = " + request.getRequestURI());

            log.info("Initiator = " + request.getParameter("cancellationInitiator"));

            log.info("orderId = " + request.getParameter("orderId"));

            if (cancellationInitiator.equals("CUSTOMER")) {

                order = transactionServiceClient.getClient().getOrder(orderId);

                transactionServiceClient.getClient().markOrderCancellationRequestReceived(orderId);

                long creatorId = CRMAuthorizingRealm.getAgent(currentAgentEmailId).getId();

                Ticket ticket = new Ticket();

                String plainTextbody = "";

                if(body!=null && !body.isEmpty()){

                    plainTextbody = new Source(body).getTextExtractor().toString();

                }

                ticket.setDescription("Creating ticket for Cancellation Request Received, Reason : " + cancelReason + " : " + plainTextbody);

                ticket.setCreatorId(creatorId);

                ticket.setStatus(TicketStatus.OPEN);

                ticket.setPriority(TicketPriority.HIGH);

                ticket.setCategory(TicketCategory.ORDER_CANCELLATION);

                ticket.setOrderId(orderId);

                Activity activity = new Activity();

                activity.setDescription("Creating Ticket");

                activity.setType(ActivityType.OTHER);

                activity.setTicketPriority(TicketPriority.HIGH);

                activity.setTicketStatus(TicketStatus.OPEN);

                activity.setCreatorId(creatorId);

                activity.setTicketDescription("Creating ticket for Cancellation Request Received, Reason : " + cancelReason + " : " + plainTextbody);

                activity.setTicketCategory(TicketCategory.ORDER_CANCELLATION);

                ticket.setCustomerId(order.getCustomer_id());

                activity.setCustomerId(order.getCustomer_id());

                ticket.setCustomerName(order.getCustomer_name());

                activity.setCustomerName(order.getCustomer_name());

                ticket.setCustomerEmailId(order.getCustomer_email());

                activity.setCustomerEmailId(order.getCustomer_email());

                ticket.setCustomerMobileNumber(order.getCustomer_mobilenumber());

                activity.setCustomerMobileNumber(order.getCustomer_mobilenumber());

                ticket.setAssigneeId(1);

                activity.setTicketAssigneeId(1);

                crmServiceClient = new CRMClient().getClient();

                crmServiceClient.insertTicket(ticket, activity);

            } 

            else if (cancellationInitiator.equals("INTERNAL")) {

                String plainTextbody = "";

                if(body!=null && !body.isEmpty()){

                    plainTextbody = new Source(body).getTextExtractor().toString();

                }

                transactionServiceClient.getClient().refundOrder(orderId, currentAgentEmailId, cancelReason + " : " + plainTextbody);

                long creatorId = CRMAuthorizingRealm.getAgent(currentAgentEmailId).getId();

                Ticket ticket = new Ticket();

                ticket.setDescription("Creating ticket for Order Cancellation due to Low inventory");

                ticket.setCreatorId(creatorId);

                ticket.setStatus(TicketStatus.CLOSED);

                ticket.setPriority(TicketPriority.MEDIUM);

                ticket.setCategory(TicketCategory.ORDER_CANCELLATION);

                ticket.setOrderId(orderId);

                Activity activity = new Activity();

                activity.setDescription("Creating Ticket");

                activity.setType(ActivityType.OTHER);

                activity.setTicketPriority(TicketPriority.MEDIUM);

                activity.setTicketStatus(TicketStatus.CLOSED);

                activity.setCreatorId(creatorId);

                activity.setTicketCategory(TicketCategory.ORDER_CANCELLATION);

                activity.setTicketDescription("Creating ticket for Order Cancellation due to Low inventory");

                ticket.setCustomerId(order.getCustomer_id());

                activity.setCustomerId(order.getCustomer_id());

                ticket.setCustomerName(order.getCustomer_name());

                activity.setCustomerName(order.getCustomer_name());

                ticket.setCustomerEmailId(order.getCustomer_email());

                activity.setCustomerEmailId(order.getCustomer_email());

                ticket.setCustomerMobileNumber(order.getCustomer_mobilenumber());

                activity.setCustomerMobileNumber(order.getCustomer_mobilenumber());

                ticket.setAssigneeId(1);

                activity.setTicketAssigneeId(1);

                crmServiceClient = new CRMClient().getClient();

                crmServiceClient.insertTicket(ticket, activity);

            }

        } catch(Exception e) {

            log.error("Could not mark order for Cancellation, OrderId : " + orderId, e);

        }

        return index();

    }

    public boolean canOrderBeCancelled() {

        if (setOfcancellableStates.contains(order.getStatus())) {

            return true;

        }

        return false;

    }

    public String getPaymentGateway(Payment payment) {

        String gatewayName = "";

        try {

            Client paymentServiceClient = new PaymentClient().getClient();

            gatewayName = paymentServiceClient.getPaymentGateway(payment.getGatewayId()).getName();

        } catch (TTransportException e) {

        } catch (PaymentException e) {

        } catch (TException e) {

        }

        return gatewayName;

    }

    public String getProductName(LineItem lineItem) {

        String name = ModelUtils.extractProductNameFromLineItem(lineItem);

        if (lineItem.getColor() != null && !lineItem.getColor().isEmpty()) {

            name += "(" + lineItem.getColor() + ")";

        }

        return name;

    }

    public int convertDouble(double value) {

        return (int)value;

    }

    public String getAddress(Order order) {

        return ModelUtils.extractAddressFromOrder(order);

    }

    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 setOrderId(String orderId) {

        try {

            this.orderId = Long.parseLong(orderId);

        } catch (NumberFormatException e) {

            log.error(e);

        }

    }

    public List<Payment> getPayments() {

        return payments;

    }

    public List<ShipmentUpdate> getShipmentUpdates() {

        return shipmentUpdates;

    }

    public void setShipmentUpdates(List<ShipmentUpdate> shipmentUpdates) {

        this.shipmentUpdates = shipmentUpdates;

    }

    public Order getOrder() {

        return order;

    }

    public void setOrder(Order order) {

        this.order = order;

    }

    public Long getCodTicketId() {

        return codTicketId;

    }

    public void setCodTicketId(Long codTicketId) {

        this.codTicketId = codTicketId;

    }

    public List<Address> getAddresses() {

        return addresses;

    }

    public void setAddresses(List<Address> addresses) {

        this.addresses = addresses;

    }

    public String getOrderStatusDescription(Order order) {

        String status = order.getStatus().getDescription();

        if (order.getStatus() == OrderStatus.DELIVERY_SUCCESS) {

            status = "Completed";

        }

        return status;

    }

    public String getCancellationInitiator() {

        return cancellationInitiator;

    }

    public void setCancellationInitiator(String cancellationInitiator) {

        this.cancellationInitiator = cancellationInitiator;

    }

    public String getCancelReason() {

        return cancelReason;

    }

    public void setCancelReason(String cancelReason) {

        this.cancelReason = cancelReason;

    }

    public String getBody() {

        return body;

    }

    public void setBody(String body) {

        this.body = body;

    }

}