Subversion Repositories SmartDukaan

Rev

Rev 21887 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

/**
 * 
 */
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.InventoryClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.config.ConfigClient;
import in.shop2020.model.v1.inventory.WarehouseLocation;
import in.shop2020.model.v1.inventory.Warehouse;
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.HashMap;
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 fedexTrackClientMumbai;
        private FedExTrackingService fedexTrackClientDelhi;

        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().substring(0, Math.min(ticket.getDescription().length(), 2048)-1));
                                        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);
                                ex.printStackTrace();
                        }
                        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>();
                log.info("Search Filter..."+searchFilter.isNotShowPmTickets());
                in.shop2020.crm.domain.SearchFilter filter_to_check  =in.shop2020.crm.domain.SearchFilter.create(searchFilter);
                log.info("Search Filter after conversion..."+filter_to_check.getNotShowPmTickets());
                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();

                if (activities != null) {
                        for (in.shop2020.crm.domain.Activity ticket : activities) {
                                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);
                        }
                }
                log.info("Returning tactivities."+tactivities.toString());
                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 = new HashMap<String,String>();
                Map<String, String> fedexReconciliationDataMap1 = null;
                Map<String, String> fedexReconciliationDataMap2 = null;
                try{
                        TransactionClient transactionServiceClient = new TransactionClient();
                        List<Order> orderList= transactionServiceClient.getClient().getOrderList(order_ids);
                        List<Order> orderListDelhi = new ArrayList<Order>();
                        List<Order> orderListMumbai = new ArrayList<Order>();
                        for(Order ord1: orderList){
                                Warehouse warehouse = null;
                                try{
                                        InventoryClient isc = new InventoryClient();
                                        warehouse = isc.getClient().getWarehouse(ord1.getWarehouse_id());
                                } catch(Exception e) {
                                        log.error("Unable to get warehouse for id : " + ord1.getWarehouse_id(),e);
                                }
                                if(warehouse!=null){
                                        if(WarehouseLocation.Mumbai==warehouse.getLogisticsLocation()){
                                                orderListMumbai.add(ord1);
                                        }
                                        else{
                                                orderListDelhi.add(ord1);
                                        }
                                }
                        }
                        
                        fedexTrackClientMumbai = new FedExTrackingService(WarehouseLocation.Mumbai);
                        fedexTrackClientDelhi = new FedExTrackingService(WarehouseLocation.Delhi);
                        
                        if("delivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExDeliveredOrdersMap(orderListMumbai);
                        }
                        if("delivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExDeliveredOrdersMap(orderListDelhi);
                        }
                        if("returned_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExReturnedOrdersMap(orderListMumbai);
                        }
                        if("returned_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExReturnedOrdersMap(orderListDelhi);
                        }
                        if("undelivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExUnDeliveredOrdersMap(orderListMumbai);
                        }
                        if("undelivered_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExUnDeliveredOrdersMap(orderListDelhi);
                        }
                        if("first_delivery_attempted_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExFirstDeliveryAttemptedOrdersMap(orderListMumbai);
                        }
                        if("first_delivery_attempted_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExFirstDeliveryAttemptedOrdersMap(orderListDelhi);
                        }
                        if("destination_city_reached_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExReachedDestinationOrdersMap(orderListMumbai);
                        }
                        if("destination_city_reached_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExReachedDestinationOrdersMap(orderListDelhi);
                        }
                        if("picked_up_orders".equalsIgnoreCase(method_key) || "local_connection_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap1 = fedexTrackClientMumbai.readFedExPickupOrdersMap(orderListMumbai);
                        }
                        if("picked_up_orders".equalsIgnoreCase(method_key) || "local_connection_orders".equalsIgnoreCase(method_key)){
                                fedexReconciliationDataMap2 = fedexTrackClientDelhi.readFedExPickupOrdersMap(orderListDelhi);
                        }
                        fedexReconciliationDataMap.putAll(fedexReconciliationDataMap1);
                        fedexReconciliationDataMap.putAll(fedexReconciliationDataMap2);
                        // 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;
        }
}