Subversion Repositories SmartDukaan

/**
 * 
 */
package in.shop2020.crm.service.handler;

import in.shop2020.alert.AlertService;
import in.shop2020.alert.EntityType;
import in.shop2020.alert.MonitoredEntity;
import in.shop2020.config.ConfigException;
import in.shop2020.crm.Activity;
import in.shop2020.crm.ActivityType;
import in.shop2020.crm.Agent;
import in.shop2020.crm.TicketStatus;
import in.shop2020.crm.CRMService.Iface;
import in.shop2020.crm.SearchFilter;
import in.shop2020.crm.Ticket;
import in.shop2020.crm.TicketCategory;
import in.shop2020.crm.handler.ActivityHandler;
import in.shop2020.crm.handler.AgentHandler;
import in.shop2020.crm.handler.TicketHandler;
import in.shop2020.serving.model.ShipmentUpdate;
import in.shop2020.serving.services.FedExTrackingService;
import in.shop2020.thrift.clients.AlertClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.config.ConfigClient;
import in.shop2020.model.v1.order.Order;
import in.shop2020.model.v1.order.TransactionServiceException;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * Implementation of the interface/services exposed by thrift to clients!
 * 
 * @author mandeep
 */
@Service
public class CRMServiceHandler implements Iface {
    private static final Log log = LogFactory.getLog(CRMServiceHandler.class);

    private TicketHandler      ticketHandler;
    private ActivityHandler    activityHandler;
    private AgentHandler       agentHandler;
    private FedExTrackingService fedexTrackClient = new FedExTrackingService();

    public CRMServiceHandler() {
        log.info("Creating context");
        ApplicationContext context = new ClassPathXmlApplicationContext("context.xml");
        ticketHandler              = context.getBean(TicketHandler.class);
        activityHandler            = context.getBean(ActivityHandler.class);
        agentHandler               = context.getBean(AgentHandler.class);
    }

    public List<Ticket> getTickets(SearchFilter searchFilter) throws TException {
        List<Ticket> ttickets = new ArrayList<Ticket>();
        for (in.shop2020.crm.domain.Ticket ticket : ticketHandler
                .getTickets(in.shop2020.crm.domain.SearchFilter
                        .create(searchFilter))) {
            ttickets.add(ticket.getThriftTicket());
        }

        return ttickets;
    }

    public List<Ticket> getUnassignedTickets() throws TException {
        List<Ticket> tickets = new ArrayList<Ticket>();

        for (in.shop2020.crm.domain.Ticket ticket : ticketHandler
                .getUnassignedTickets()) {
            tickets.add(ticket.getThriftTicket());
        }

        return tickets;
    }

    @Transactional
    public void updateTicket(Ticket ticket, Activity activity)
            throws TException {
        try {
            ticketHandler.updateTicket(in.shop2020.crm.domain.Ticket
                    .create(ticket));
            activity.setTicketId(ticket.getId());
            activityHandler.insertActivity(in.shop2020.crm.domain.Activity
                    .create(activity));
            try{
                    /*For now monitoring is only done for New tickets and hence once any 
                         * activity is done on a ticket after its creation, we stop monitoring that ticket*/
                if(activity.getType()== ActivityType.SEND_EMAIL_TO_CUSTOMER || 
                                activity.getType()== ActivityType.ESCALATE_TICKET ||
                                activity.getType()== ActivityType.CALLED_CUSTOMER || 
                                activity.getTicketStatus().equals(TicketStatus.CLOSED)) {
                                AlertService.Client alertClient = new AlertClient().getClient();
                            alertClient.endMonitoringEntity(EntityType.TICKET, "ticketId = " + ticket.getId());
                }
            } catch(Exception ex) {
                log.error("Exception while ending monitoring for ticketId " + ticket.getId());
                log.error(ex);
            }
        } catch (ParseException e) {
            throw new TException("Could not update " + ticket, e);
        }
    }

    @Transactional
    public long insertTicket(Ticket ticket, Activity activity)
            throws TException {
        try {
            long ticketId = ticketHandler
                    .insertTicket(in.shop2020.crm.domain.Ticket.create(ticket));
            activity.setTicketId(ticketId);
            activityHandler.insertActivity(in.shop2020.crm.domain.Activity
                    .create(activity));
            try {
                if(ticket.getCategory()!= TicketCategory.DELIVERY_PROBLEM &&
                                ticket.getCategory()!= TicketCategory.PRODUCT_PROCUREMENT &&
                                ticket.getCategory()!= TicketCategory.DOA_RECEIVED) {
                            MonitoredEntity entity = new MonitoredEntity();
                            entity.setEntityType(EntityType.TICKET);
                            entity.setEventType(0);
                            entity.setEntityIdentifier("ticketId = " + new Long(ticketId).toString());
                            entity.setDescription(ticket.getDescription());
                            Calendar thresholdTime = Calendar.getInstance();
                            thresholdTime.add(Calendar.HOUR, 4);
                            entity.setWarnExpiryTime(thresholdTime.getTimeInMillis());
                            thresholdTime.add(Calendar.HOUR, 2);
                            entity.setCriticalExpiryTime(thresholdTime.getTimeInMillis());
                            AlertService.Client alertClient = new AlertClient().getClient();
                            alertClient.scheduleAlert(entity);
                }
            } catch (Exception ex) {
                log.error("Exception while scheduling alert for Ticket Id "+ticketId);
                log.error(ex);
            }
            return ticketId;
        } catch (ParseException e) {
            throw new TException("Could not insert " + ticket, e);
        }
    }

    public List<Activity> getActivities(SearchFilter searchFilter)
            throws TException {
        List<Activity> tactivities = new ArrayList<Activity>();
        //Start:- Added By Manish Sharma for Displaying Current Ticket Status for Unread Customer Activities on 21-Jun-2013
        in.shop2020.crm.domain.SearchFilter filter_to_check  =in.shop2020.crm.domain.SearchFilter.create(searchFilter);
        List<in.shop2020.crm.domain.Activity> activities = activityHandler
                .getActivities(filter_to_check);
        in.shop2020.crm.domain.SearchFilter new_searchFilter = new in.shop2020.crm.domain.SearchFilter();
        //End:- Added By Manish Sharma for Displaying Current Ticket Status for Unread Customer Activities on 21-Jun-2013
        
        if (activities != null) {
            for (in.shop2020.crm.domain.Activity ticket : activities) {
                //Start:- Added By Manish Sharma for Displaying Current Ticket Status for Unread Customer Activities on 21-Jun-2013
                in.shop2020.crm.Activity activity = ticket.getThriftActivity();
                if(filter_to_check.getIsActivityRead()!=null && !filter_to_check.getIsActivityRead()){
                        if(activity.getTicketId() > 0){
                                new_searchFilter.setTicketId(activity.getTicketId());
                                List<in.shop2020.crm.domain.Ticket> tickets_as_per_activity= ticketHandler.getTickets(new_searchFilter);
                                activity.setTicketStatus(tickets_as_per_activity.get(0).getStatus());
                            }
                }
                tactivities.add(activity);
                //End:- Added By Manish Sharma for Displaying Current Ticket Status for Unread Customer Activities on 21-Jun-2013
            }
        }

        return tactivities;
    }

    public long insertActivity(Activity activity) throws TException {
        try {
            return activityHandler.insertActivity(in.shop2020.crm.domain.Activity
                    .create(activity));
        } catch (ParseException e) {
            throw new TException("Could not insert " + activity, e);
        }
    }

    @Transactional
    public void markAsRead(long activityId, long agentId) throws TException {
        in.shop2020.crm.domain.SearchFilter searchFilter = new in.shop2020.crm.domain.SearchFilter();
        searchFilter.setActivityId(activityId);
        activityHandler.markAsRead(activityId);
        in.shop2020.crm.domain.Activity activity = activityHandler
                .getActivities(searchFilter).get(0);

        // Setting activity fields from latest ticket fields
        if (activity.getTicketId() != null) {
            searchFilter.setTicketId(activity.getTicketId());
            in.shop2020.crm.domain.Ticket ticket = ticketHandler.getTickets(searchFilter).get(0);
            activity.setTicketAssigneeId(ticket.getAssigneeId());
            activity.setTicketCategory(ticket.getCategory());
            activity.setTicketDescription(ticket.getDescription());
            activity.setTicketPriority(ticket.getPriority());
            activity.setTicketStatus(ticket.getStatus());
        }

        activity.setCreatorId(agentId);
        activity.setDescription("Marked as read ticketId: "
                + activity.getTicketId() + ", activityId: " + activityId);
        activity.setType(ActivityType.OTHER);
        activityHandler.insertActivity(activity);
    }

    public List<Agent> getAgents(SearchFilter searchFilter) throws TException {
        List<Agent> agents = new ArrayList<Agent>();

        for (in.shop2020.crm.domain.Agent agent : agentHandler
                .getAgents(in.shop2020.crm.domain.SearchFilter
                        .create(searchFilter))) {
            agents.add(agent.getThriftAgent());
        }

        return agents;
    }
    
    public List<Agent> getInactiveAgents(SearchFilter searchFilter) throws TException {
        List<Agent> agents = new ArrayList<Agent>();

        for (in.shop2020.crm.domain.Agent agent : agentHandler
                .getInactiveAgents(in.shop2020.crm.domain.SearchFilter
                        .create(searchFilter))) {
            agents.add(agent.getThriftAgent());
        }

        return agents;
    }

    public void updatePasswordForAgent(String agentEmailId, String password)
            throws TException {
        agentHandler.updatePasswordForAgent(agentEmailId, password);
    }

    public long getLastEmailProcessedTimestamp() throws TException {
        return agentHandler.getLastEmailProcessedTimestamp().getTime();
    }

    public void updateLastEmailProcessedTimestamp(long timestamp)
            throws TException {
        agentHandler.updateLastEmailProcessedTimestamp(new Date(timestamp));
    }

    public List<String> getRoleNamesForAgent(String agentEmailId)
            throws TException {
        return agentHandler.getRoleNamesForAgent(agentEmailId);
    }

    public List<String> getPermissionsForRoleName(String roleName)
            throws TException {
        return agentHandler.getPermissionsForRoleName(roleName);
    }
    
    public void changeAgentStatus(boolean status, String emailId)
                throws TException {
        agentHandler.changeAgentStatus(status, emailId);
    }

        public boolean isAlive() throws TException {
        try {
            return !agentHandler.getAgents(null).isEmpty();
        } catch (Exception e) {
            log.error("Could not fetch agents", e);
        }

        return false;
    }

        public void closeSession() throws TException {
        }
        
        public void insertAgent(Agent agent, List<String> role) throws TException {
                agentHandler.insertAgent(in.shop2020.crm.domain.Agent.create(agent), role);
        }
        
        public void unassignAgentTickets(int assigneeId) {
                ticketHandler.unassignAgentTickets(assigneeId);
        }
        
        public void changeAgentRole(long id, List<String> role) {
                agentHandler.changeAgentRole(id,role);
        }
        
        public int getOpenTicketCountForAgent(long agentId) {
                return ticketHandler.getOpenTicketCountForAgent(agentId);
        }
        
        public Map<String,Long> getOpenTicketsMap() {
                return ticketHandler.getOpenTicketsMap();
        }
        

        public Map<String, String> getFedexReconciliationDataMap(
                        List<Long> order_ids, String method_key) {
                log.info("Into Method of CRM Service to get Fedex Reconciliation Data");
                Map<String, String> fedexReconciliationDataMap = null;
                try{
                        TransactionClient transactionServiceClient = new TransactionClient();
                        List<Order> orderList= transactionServiceClient.getClient().getOrderList(order_ids);
                        if("delivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExDeliveredOrdersMap(orderList);
                        }
                        if("returned_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExReturnedOrdersMap(orderList);
                        }
                        if("undelivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExUnDeliveredOrdersMap(orderList);
                        }
                        if("first_delivery_attempted_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExFirstDeliveryAttemptedOrdersMap(orderList);
                        }
                        if("destination_city_reached_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExReachedDestinationOrdersMap(orderList);
                        }
                        if("picked_up_orders".equalsIgnoreCase(method_key) || "local_connection_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap = fedexTrackClient.readFedExPickupOrdersMap(orderList);
                        }
                // TODO Auto-generated method stub
                }
                catch (TTransportException e) {
                        log.error("Unable to create thrift Client from fedex reconciliation method.... ", e);
                } catch (TException e) {
                        log.error("Unable to get thrift Client from fedex reconciliation method.... ", e);
                }
                log.info("Into Method of CRM Service to get Fedex Reconciliation Data....and got it successfully");
                return fedexReconciliationDataMap;
        }
 }