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.logistics.PickupStore;

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

import in.shop2020.serving.services.BlueDartTrackingService;

import in.shop2020.serving.services.DelhiveryTrackingService;

import in.shop2020.thrift.clients.CRMClient;

import in.shop2020.thrift.clients.HelperClient;

import in.shop2020.thrift.clients.LogisticsClient;

import in.shop2020.thrift.clients.PaymentClient;

import in.shop2020.thrift.clients.TransactionClient;

import in.shop2020.thrift.clients.UserClient;

import in.shop2020.utils.ModelUtils;

import in.shop2020.warehouse.WarehouseService;

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.InputStream;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Collections;

import java.util.Date;

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 javax.servlet.ServletOutputStream;

import net.htmlparser.jericho.Source;

import org.apache.commons.lang.StringUtils;

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 static AramexTrackingService aramexTrackingService     = new AramexTrackingService();

    private static DelhiveryTrackingService delhiveryTrackingService     = new DelhiveryTrackingService();

    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;

    private String               line1;

    private String               line2;

    private String               city;

    private String               state;

    private String               pin;

    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);

    }

    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 {

                    if (order.getLogistics_provider_id() == 1)

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

                    else if (order.getLogistics_provider_id() == 2) {

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

                    }

                    else if (order.getLogistics_provider_id() == 3) {

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

                    }

                    else {

                        shipmentUpdates = new ArrayList<ShipmentUpdate>();

                        log.error("Error : providerId = " + order.getLogistics_provider_id() + "for orderId : " + order.getId());

                    }

                    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());

                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());

                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 void getOrderConfirmationMail() throws IOException, TException {

    	HelperClient helperClient = new HelperClient();

    	String mail = helperClient.getClient().getOrderConfirmationMail(orderId);

    	File file = new File("temp");

    	FileWriter writer = new FileWriter(file);

    	writer.append(mail);

    	writer.close();

    	byte[] buffer = new byte[(int)file.length()];

        InputStream input = null;

    	try {

            int totalBytesRead = 0;

            input = new BufferedInputStream(new FileInputStream(file));

            while(totalBytesRead < buffer.length){

                int bytesRemaining = buffer.length - totalBytesRead;

                int bytesRead = input.read(buffer, totalBytesRead, bytesRemaining); 

                if (bytesRead > 0){

                    totalBytesRead = totalBytesRead + bytesRead;

                }

            }

        }

        finally {

            input.close();

            file.delete();

        }

    	response.setHeader("Content-disposition", "inline; filename=" + "OrderDetail_"+orderId );

        ServletOutputStream sos;

        try {

            sos = response.getOutputStream();

            sos.write(buffer);

            sos.flush();

        } catch (IOException e) {

            System.out.println("Unable to stream the manifest file");

        }   

    }

    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 getInsuranceExpiryDate(long DeliveryDate) {

        if (DeliveryDate == 0) {

            return "N/A";

        }

        Calendar cal = Calendar.getInstance();

        cal.setTimeInMillis(DeliveryDate);

        cal.add(Calendar.YEAR, 1);

        SimpleDateFormat sdf = new SimpleDateFormat("dd MMM, yyyy");

        return sdf.format(cal.getTime());

    }

    public String getShippingAddressOfStore(long storeId) {

        try {

            in.shop2020.logistics.LogisticsService.Client client = new LogisticsClient().getClient();

            PickupStore store = client.getPickupStore(storeId);

            return StringUtils.join(new String[] {

                    store.getName(),

                    store.getLine1(),

                    store.getLine2(),

                    store.getPin(),

                    store.getCity(),

                    store.getState(),

                    store.getPhone()}, ",");

        } catch (Exception e) {

            return "";

        }

    }

    public String getAddress(Order order) {

        return ModelUtils.extractAddressFromOrder(order);

    }

    public String changeShippingAddress() {

        try {

            TransactionClient transactionServiceClient = new TransactionClient();

            transactionServiceClient.getClient().changeShippingAddress(orderId, line1, line2, city, state, pin);

        } catch(Exception e) {

            log.error("Unable to update address for orderId : " + orderId + "and address : " + 

                    line1 + ", " + line2+ ", " + city + ", " + state + ", " + pin, e);

        }

        return null;

    }

    public Address getShippingAddress(Order order) {

        Address address = new Address();

        address.setLine1(order.getCustomer_address1());

        address.setLine2(order.getCustomer_address2());

        address.setCity(order.getCustomer_city());

        address.setState(order.getCustomer_state());

        address.setPin(order.getCustomer_pincode());

        return address;

    }

    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;

    }

    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 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 getPin() {

        return pin;

    }

    public void setPin(String pin) {

        this.pin = pin;

    }

}