Implement ManualHandlingTasks

Implement ManualHandlingTasks class to support PauseForManualTasks

Change-Id: I6da216a0378d685a8e0c5168ceb8f5a1d9fdc719
Issue-ID: SO-1551
Signed-off-by: Kuleshov, Elena <evn@att.com>

3 files changed, 455 insertions, 0 deletions

diff --git a/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasks.java b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasks.java
new file mode 100644
index 0000000000..2fba3b3b25
--- /dev/null
+++ b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasks.java
@@ -0,0 +1,202 @@
+package org.onap.so.bpmn.infrastructure.manualhandling.tasks;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import org.camunda.bpm.engine.TaskService;
+import org.camunda.bpm.engine.delegate.BpmnError;
+import org.camunda.bpm.engine.delegate.DelegateTask;
+import org.camunda.bpm.engine.delegate.DelegateExecution;
+import org.onap.so.client.exception.ExceptionBuilder;
+import org.onap.so.client.ticket.ExternalTicket;
+import org.onap.so.db.request.beans.InfraActiveRequests;
+import org.onap.so.db.request.client.RequestsDbClient;
+import org.onap.so.logger.MessageEnum;
+import org.onap.so.logger.MsoLogger;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ManualHandlingTasks {
+	private static final MsoLogger msoLogger = MsoLogger.getMsoLogger(MsoLogger.Catalog.BPEL, ManualHandlingTasks.class);
+
+	private static final String TASK_TYPE_PAUSE = "pause";
+	private static final String TASK_TYPE_FALLOUT = "fallout";
+	
+	@Autowired
+	private ExceptionBuilder exceptionUtil;
+	 
+	@Autowired
+	private RequestsDbClient requestDbclient;
+
+	public void setFalloutTaskVariables (DelegateTask task) {
+		
+		DelegateExecution execution = task.getExecution();	
+		try {
+			String taskId = task.getId();
+			msoLogger.debug("taskId is: " + taskId);			
+			String type = TASK_TYPE_FALLOUT;
+			String nfRole = (String) execution.getVariable("vnfType");
+			String subscriptionServiceType = (String) execution.getVariable("serviceType");
+			String originalRequestId = (String) execution.getVariable("msoRequestId");
+			String originalRequestorId = (String) execution.getVariable("requestorId");
+			String description = "";
+			String timeout = "";
+			String errorSource = (String) execution.getVariable("failedActivity");
+			String errorCode = (String) execution.getVariable("errorCode");
+			String errorMessage = (String) execution.getVariable("errorText");
+			String buildingBlockName = (String) execution.getVariable("currentActivity");
+			String buildingBlockStep = (String) execution.getVariable("workStep");
+			String validResponses = (String) execution.getVariable("validResponses");
+
+			Map<String, String> taskVariables = new HashMap<String, String>();
+			taskVariables.put("type", type);
+			taskVariables.put("nfRole", nfRole);
+			taskVariables.put("subscriptionServiceType", subscriptionServiceType);
+			taskVariables.put("originalRequestId", originalRequestId);
+			taskVariables.put("originalRequestorId", originalRequestorId);
+			taskVariables.put("errorSource", errorSource);
+			taskVariables.put("errorCode", errorCode);
+			taskVariables.put("errorMessage", errorMessage);
+			taskVariables.put("buildingBlockName", buildingBlockName);
+			taskVariables.put("buildingBlockStep", buildingBlockStep);
+			taskVariables.put("validResponses", validResponses);
+			taskVariables.put("tmeout", timeout);
+			taskVariables.put("description", description);
+			TaskService taskService = execution.getProcessEngineServices().getTaskService();
+
+			taskService.setVariables(taskId, taskVariables);
+			msoLogger.debug("successfully created fallout task: "+ taskId);
+		} catch (BpmnError e) {
+			msoLogger.debug("BPMN exception: " + e.getMessage());
+			throw e;
+		} catch (Exception ex){
+			String msg = "Exception in setFalloutTaskVariables " + ex.getMessage();
+			msoLogger.debug(msg);
+			exceptionUtil.buildAndThrowWorkflowException(execution, 7000, msg);
+		}		
+	}
+	
+	public void setPauseTaskVariables (DelegateTask task) {
+
+		DelegateExecution execution = task.getExecution();
+
+		try {
+			String taskId = task.getId();
+			msoLogger.debug("taskId is: " + taskId);			
+			String type = TASK_TYPE_PAUSE;
+			String nfRole = (String) execution.getVariable("vnfType");
+			String subscriptionServiceType = (String) execution.getVariable("serviceType");
+			String originalRequestId = (String) execution.getVariable("msoRequestId");
+			String originalRequestorId = (String) execution.getVariable("requestorId");
+			String description = (String) execution.getVariable("description");
+			String timeout = (String) execution.getVariable("taskTimeout");
+			String errorSource = "";
+			String errorCode = "";
+			String errorMessage = "";
+			String buildingBlockName = "";
+			String buildingBlockStep = "";
+			String validResponses = (String) execution.getVariable("validResponses");
+
+			Map<String, String> taskVariables = new HashMap<String, String>();
+			taskVariables.put("type", type);
+			taskVariables.put("nfRole", nfRole);
+			taskVariables.put("description", description);
+			taskVariables.put("timeout", timeout);
+			taskVariables.put("subscriptionServiceType", subscriptionServiceType);
+			taskVariables.put("originalRequestId", originalRequestId);
+			taskVariables.put("originalRequestorId", originalRequestorId);
+			taskVariables.put("errorSource", errorSource);
+			taskVariables.put("errorCode", errorCode);
+			taskVariables.put("errorMessage", errorMessage);
+			taskVariables.put("buildingBlockName", buildingBlockName);
+			taskVariables.put("buildingBlockStep", buildingBlockStep);
+			taskVariables.put("validResponses", validResponses);
+			TaskService taskService = execution.getProcessEngineServices().getTaskService();
+
+			taskService.setVariables(taskId, taskVariables);
+			msoLogger.debug("successfully created pause task: "+ taskId);
+		} catch (BpmnError e) {
+			msoLogger.debug("BPMN exception: " + e.getMessage());
+			throw e;
+		} catch (Exception ex){
+			String msg = "Exception in setPauseTaskVariables " + ex.getMessage();
+			msoLogger.debug(msg);
+			exceptionUtil.buildAndThrowWorkflowException(execution, 7000, msg);
+		}
+		
+	}
+
+	public void completeTask (DelegateTask task) {
+
+		DelegateExecution execution = task.getExecution();
+		
+		try {
+
+			String taskId = task.getId();
+			msoLogger.debug("taskId is: " + taskId);
+			TaskService taskService = execution.getProcessEngineServices().getTaskService();
+
+			Map<String, Object> taskVariables = taskService.getVariables(taskId);
+			String responseValue = (String) taskVariables.get("responseValue");
+
+			msoLogger.debug("Received responseValue on completion: "+ responseValue);
+			// Have to set the first letter of the response to upper case
+			String responseValueUppercaseStart = responseValue.substring(0, 1).toUpperCase() + responseValue.substring(1);
+			msoLogger.debug("ResponseValue to taskListener: "+ responseValueUppercaseStart);
+			execution.setVariable("responseValueTask", responseValueUppercaseStart);			
+			
+		} catch (BpmnError e) {
+			msoLogger.debug("BPMN exception: " + e.getMessage());
+			throw e;
+		} catch (Exception ex){
+			String msg = "Exception in completeManualTask " + ex.getMessage();
+			msoLogger.debug(msg);
+			exceptionUtil.buildAndThrowWorkflowException(execution, 7000, msg);
+		}
+		
+	}
+
+	public void createExternalTicket (DelegateExecution execution) {
+		
+		try {			
+			ExternalTicket ticket = new ExternalTicket();	
+			
+			ticket.setRequestId((String) execution.getVariable("msoRequestId"));	
+			ticket.setCurrentActivity((String) execution.getVariable("currentActivity"));			
+			ticket.setNfRole((String) execution.getVariable("vnfType"));
+			ticket.setDescription((String) execution.getVariable("description"));			
+			ticket.setSubscriptionServiceType((String) execution.getVariable("serviceType"));
+			ticket.setRequestorId((String) execution.getVariable("requestorId"));			
+			ticket.setTimeout((String) execution.getVariable("taskTimeout"));			
+			ticket.setErrorSource((String) execution.getVariable("failedActivity"));			
+			ticket.setErrorCode((String) execution.getVariable("errorCode"));
+			ticket.setErrorMessage((String) execution.getVariable("errorText"));			
+			ticket.setWorkStep((String) execution.getVariable("workStep"));
+	
+			ticket.createTicket();
+		} catch (BpmnError e) {
+			String msg = "BPMN error in createAOTSTicket " + e.getMessage();
+			msoLogger.error(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, msg, "BPMN", MsoLogger.ErrorCode.UnknownError, "");
+		} catch (Exception ex){
+			String msg = "Exception in createExternalTicket " + ex.getMessage();
+			msoLogger.error(MessageEnum.BPMN_GENERAL_EXCEPTION_ARG, msg, "BPMN", MsoLogger.ErrorCode.UnknownError, "");
+		}
+	
+	}
+	
+	public void updateRequestDbStatus(DelegateExecution execution, String status) {
+		try {
+			String requestId = (String) execution.getVariable("msoRequestId");
+			InfraActiveRequests request = requestDbclient.getInfraActiveRequestbyRequestId(requestId);
+			
+			request.setRequestStatus(status);					
+			request.setLastModifiedBy("ManualHandling");
+				
+			requestDbclient.updateInfraActiveRequests(request);
+		} catch (Exception e) {
+			msoLogger.error("Unable to save the updated request status to the DB",e);
+		}
+	}
+
+}
diff --git a/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/client/ticket/ExternalTicket.java b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/client/ticket/ExternalTicket.java
new file mode 100644
index 0000000000..519afe6f2d
--- /dev/null
+++ b/bpmn/so-bpmn-tasks/src/main/java/org/onap/so/client/ticket/ExternalTicket.java
@@ -0,0 +1,155 @@
+package org.onap.so.client.ticket;
+
+public class ExternalTicket {
+	private String requestId;
+	private String nfRole;
+	private String currentActivity;
+	private String description;
+	private String subscriptionServiceType;
+	private String requestorId;
+	private String timeout;
+	private String errorSource;
+	private String errorCode;
+	private String errorMessage;
+	private String workStep;	
+
+	public String getRequestId() {
+		return requestId;
+	}
+
+
+
+	public void setRequestId(String requestId) {
+		this.requestId = requestId;
+	}
+
+
+
+	public String getNfRole() {
+		return nfRole;
+	}
+
+
+
+	public void setNfRole(String nfRole) {
+		this.nfRole = nfRole;
+	}
+
+
+
+	public String getCurrentActivity() {
+		return currentActivity;
+	}
+
+
+
+	public void setCurrentActivity(String currentActivity) {
+		this.currentActivity = currentActivity;
+	}
+
+
+
+	public String getDescription() {
+		return description;
+	}
+
+
+
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+
+
+	public String getSubscriptionServiceType() {
+		return subscriptionServiceType;
+	}
+
+
+
+	public void setSubscriptionServiceType(String subscriptionServiceType) {
+		this.subscriptionServiceType = subscriptionServiceType;
+	}
+
+
+
+	public String getRequestorId() {
+		return requestorId;
+	}
+
+
+
+	public void setRequestorId(String requestorId) {
+		this.requestorId = requestorId;
+	}
+
+
+
+	public String getTimeout() {
+		return timeout;
+	}
+
+
+
+	public void setTimeout(String timeout) {
+		this.timeout = timeout;
+	}
+
+
+
+	public String getErrorSource() {
+		return errorSource;
+	}
+
+
+
+	public void setErrorSource(String errorSource) {
+		this.errorSource = errorSource;
+	}
+
+
+
+	public String getErrorCode() {
+		return errorCode;
+	}
+
+
+
+	public void setErrorCode(String errorCode) {
+		this.errorCode = errorCode;
+	}
+
+
+
+	public String getErrorMessage() {
+		return errorMessage;
+	}
+
+
+
+	public void setErrorMessage(String errorMessage) {
+		this.errorMessage = errorMessage;
+	}
+
+
+
+	public String getWorkStep() {
+		return workStep;
+	}
+
+
+
+	public void setWorkStep(String workStep) {
+		this.workStep = workStep;
+	}
+
+
+
+	public void createTicket() throws Exception {
+		//Replace with your ticket creation mechanism if any
+	}
+	
+	
+	
+
+}
diff --git a/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasksTest.java b/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasksTest.java
new file mode 100644
index 0000000000..5e9565446f
--- /dev/null
+++ b/bpmn/so-bpmn-tasks/src/test/java/org/onap/so/bpmn/infrastructure/manualhandling/tasks/ManualHandlingTasksTest.java
@@ -0,0 +1,98 @@
+package org.onap.so.bpmn.infrastructure.manualhandling.tasks;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.camunda.bpm.engine.ProcessEngineServices;
+import org.camunda.bpm.engine.TaskService;
+import org.camunda.bpm.engine.delegate.DelegateExecution;
+import org.camunda.bpm.engine.delegate.DelegateTask;
+import org.camunda.bpm.extension.mockito.delegate.DelegateExecutionFake;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.onap.so.bpmn.BaseTaskTest;
+import org.onap.so.db.request.beans.InfraActiveRequests;
+
+public class ManualHandlingTasksTest extends BaseTaskTest {
+	@InjectMocks
+	protected ManualHandlingTasks manualHandlingTasks = new ManualHandlingTasks();	
+	
+	@Mock
+	TaskService taskService;
+	
+	@Mock
+	private DelegateExecution mockExecution;
+	
+	@Mock
+	ProcessEngineServices processEngineServices;
+	
+	@Mock
+	private DelegateTask task;
+	
+	private DelegateExecution delegateExecution;
+	
+	@Before
+	public void before() throws Exception {
+		delegateExecution = new DelegateExecutionFake();	
+	}		
+	
+	@Test
+	public void setFalloutTaskVariables_Test () {
+		when(task.getId()).thenReturn("taskId");
+		when(task.getExecution()).thenReturn(mockExecution);
+		when(mockExecution.getProcessEngineServices()).thenReturn(processEngineServices);
+		when(processEngineServices.getTaskService()).thenReturn(taskService);		
+		manualHandlingTasks.setFalloutTaskVariables(task);
+		verify(taskService, times(1)).setVariables(any(String.class), any(Map.class));		
+	}
+	
+	@Test
+	public void setPauseTaskVariables_Test () {
+		when(task.getId()).thenReturn("taskId");
+		when(task.getExecution()).thenReturn(mockExecution);
+		when(mockExecution.getProcessEngineServices()).thenReturn(processEngineServices);
+		when(processEngineServices.getTaskService()).thenReturn(taskService);		
+		manualHandlingTasks.setPauseTaskVariables(task);
+		verify(taskService, times(1)).setVariables(any(String.class), any(Map.class));		
+	}
+	
+	@Test
+	public void completeTask_Test() throws Exception{
+		when(task.getId()).thenReturn("taskId");
+		when(task.getExecution()).thenReturn(mockExecution);		
+		Map<String, Object> taskVariables = new HashMap<String, Object>();
+		taskVariables.put("responseValue", "resume");		
+		when(mockExecution.getProcessEngineServices()).thenReturn(processEngineServices);
+		when(processEngineServices.getTaskService()).thenReturn(taskService);
+		when(taskService.getVariables(any(String.class))).thenReturn(taskVariables);
+		manualHandlingTasks.completeTask(task);
+		verify(mockExecution, times(1)).setVariable("responseValueTask", "Resume");
+	}
+		
+	@Test
+	public void updateRequestDbStatus_Test() throws Exception{
+		InfraActiveRequests mockedRequest = new InfraActiveRequests();
+		delegateExecution.setVariable("msoRequestId", "testMsoRequestId");
+		when(requestsDbClient.getInfraActiveRequestbyRequestId(any(String.class))).thenReturn(mockedRequest);
+		doNothing().when(requestsDbClient).updateInfraActiveRequests(any(InfraActiveRequests.class));
+		manualHandlingTasks.updateRequestDbStatus(delegateExecution, "IN_PROGRESS");		
+		verify(requestsDbClient, times(1)).updateInfraActiveRequests(any(InfraActiveRequests.class));
+		assertEquals(mockedRequest.getRequestStatus(), "IN_PROGRESS");
+	}
+	
+	@Test
+	public void createExternalTicket_Test() throws Exception{
+		delegateExecution.setVariable("msoRequestId", ("testMsoRequestId"));
+		delegateExecution.setVariable("vnfType", "testVnfType");
+		manualHandlingTasks.createExternalTicket(delegateExecution);	
+	}
+}