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.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, 2047));

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

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

			}

		}

		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;

	}

}