Merge "Application Onboarding page changes "

20 files changed, 4629 insertions, 4185 deletions

diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/music/conf/MusicSessionRepositoryHandler.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/music/conf/MusicSessionRepositoryHandler.java
index cd911b80..7b42d52d 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/music/conf/MusicSessionRepositoryHandler.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/music/conf/MusicSessionRepositoryHandler.java
@@ -80,9 +80,7 @@ public class MusicSessionRepositoryHandler {
 				MusicService.removeSession(id);
 			} catch (MusicLockingException e) {
 				logger.error(EELFLoggerDelegate.errorLogger, "removeSession locking failed with id " + id, e);
-			} catch (MusicServiceException e) {
-				logger.error(EELFLoggerDelegate.errorLogger, "removeSession failed with id " + id, e);
-			}
+			} 
 		}
 	}
 
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsController.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsController.java
index 789a4097..4b401e22 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsController.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/AppsController.java
@@ -42,10 +42,18 @@ package org.onap.portalapp.portal.controller;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
+import java.util.stream.Stream;
+
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
 import org.onap.portalapp.controller.EPRestrictedBaseController;
 import org.onap.portalapp.portal.domain.AdminUserApplications;
 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
@@ -54,10 +62,13 @@ import org.onap.portalapp.portal.domain.EPApp;
 import org.onap.portalapp.portal.domain.EPUser;
 import org.onap.portalapp.portal.domain.EcompApp;
 import org.onap.portalapp.portal.domain.UserRoles;
+import org.onap.portalapp.portal.exceptions.InvalidApplicationException;
 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
+import org.onap.portalapp.portal.logging.logic.EPLogUtil;
 import org.onap.portalapp.portal.service.AdminRolesService;
 import org.onap.portalapp.portal.service.EPAppService;
 import org.onap.portalapp.portal.service.EPLeftMenuService;
+import org.onap.portalapp.portal.service.ExternalAccessRolesService;
 import org.onap.portalapp.portal.transport.EPAppsManualPreference;
 import org.onap.portalapp.portal.transport.EPAppsSortPreference;
 import org.onap.portalapp.portal.transport.EPDeleteAppsManualSortPref;
@@ -65,6 +76,7 @@ import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
 import org.onap.portalapp.portal.transport.FieldsValidator;
 import org.onap.portalapp.portal.transport.LocalRole;
 import org.onap.portalapp.portal.transport.OnboardingApp;
+import org.onap.portalapp.portal.utils.EPCommonSystemProperties;
 import org.onap.portalapp.portal.utils.EcompPortalUtils;
 import org.onap.portalapp.portal.utils.PortalConstants;
 import org.onap.portalapp.util.EPUserUtils;
@@ -75,12 +87,18 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
 import org.springframework.http.HttpEntity;
 import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.HttpStatusCodeException;
+import org.springframework.web.client.RestTemplate;
 
 @RestController
 @EnableAspectJAutoProxy
@@ -96,6 +114,10 @@ public class AppsController extends EPRestrictedBaseController {
 
 	@Autowired
 	private EPLeftMenuService leftMenuService;
+	
+	@Autowired
+	private ExternalAccessRolesService externalAccessRolesService;
+	RestTemplate template = new RestTemplate();
 
 	/**
 	 * RESTful service method to fetch all Applications available to current
@@ -470,7 +492,7 @@ public class AppsController extends EPRestrictedBaseController {
 			if (!adminRolesService.isSuperAdmin(user)) {
 				EcompPortalUtils.setBadPermissions(user, response, "getApps");
 			} else {
-				apps = appService.getAllApps(false);
+				apps = appService.getAllApplications(false);
 				EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/availableApps", "GET result =", apps);
 			}
 		} catch (Exception e) {
@@ -663,10 +685,18 @@ public class AppsController extends EPRestrictedBaseController {
 		EPUser user = EPUserUtils.getUserSession(request);
 		List<OnboardingApp> onboardingApps = null;
 		try {
-			if (!adminRolesService.isSuperAdmin(user)) {
+			if (!adminRolesService.isSuperAdmin(user) && !adminRolesService.isAccountAdmin(user)) {
 				EcompPortalUtils.setBadPermissions(user, response, "getOnboardingApps");
 			} else {
+				
+				if(adminRolesService.isSuperAdmin(user)){
 				onboardingApps = appService.getOnboardingApps();
+				}
+				else if(adminRolesService.isAccountAdmin(user))
+				{
+					//get all his admin apps
+					onboardingApps =  appService.getAdminAppsOfUser(user);
+				}
 				EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps", "GET result =",
 						"onboardingApps of size " + onboardingApps.size());
 			}
@@ -686,19 +716,39 @@ public class AppsController extends EPRestrictedBaseController {
 	 * @param modifiedOnboardingApp
 	 *            app to update
 	 * @return FieldsValidator
+	 * @throws Exception 
 	 */
 	@RequestMapping(value = { "/portalApi/onboardingApps" }, method = RequestMethod.PUT, produces = "application/json")
 	public FieldsValidator putOnboardingApp(HttpServletRequest request,
-			@RequestBody OnboardingApp modifiedOnboardingApp, HttpServletResponse response) {
+			@RequestBody OnboardingApp modifiedOnboardingApp, HttpServletResponse response) throws Exception {
 		FieldsValidator fieldsValidator = null;
 		EPUser user = null;
 		EPApp oldEPApp = null;
+		oldEPApp = appService.getApp(modifiedOnboardingApp.id);
+		ResponseEntity<String> res = null;
+		
 		try {
 			user = EPUserUtils.getUserSession(request);
-			if (!adminRolesService.isSuperAdmin(user)) {
+			if (!adminRolesService.isSuperAdmin(user) && !adminRolesService.isAccountAdminOfAnyActiveorInactiveApplication(user, oldEPApp) ) {
 				EcompPortalUtils.setBadPermissions(user, response, "putOnboardingApp");
 			} else {
-				oldEPApp = appService.getApp(modifiedOnboardingApp.id);
+				if((oldEPApp.getCentralAuth() && modifiedOnboardingApp.isCentralAuth && !oldEPApp.getNameSpace().equalsIgnoreCase(modifiedOnboardingApp.nameSpace) && modifiedOnboardingApp.nameSpace!= null ) || (!oldEPApp.getCentralAuth() && modifiedOnboardingApp.isCentralAuth && modifiedOnboardingApp.nameSpace!= null))
+				{
+					try {
+						res = appService.checkIfNameSpaceIsValid(modifiedOnboardingApp.nameSpace);
+					} catch (HttpClientErrorException e) {
+						logger.error(EELFLoggerDelegate.errorLogger, "checkIfNameSpaceExists failed", e);
+						EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+						if (e.getStatusCode() == HttpStatus.NOT_FOUND || e.getStatusCode() == HttpStatus.FORBIDDEN) {
+							fieldsValidator = setResponse(e.getStatusCode(),fieldsValidator,response);
+							throw new InvalidApplicationException("Invalid NameSpace");
+						}else{
+							fieldsValidator = setResponse(e.getStatusCode(),fieldsValidator,response);
+							throw e;
+						}
+					}
+
+				}	
 				modifiedOnboardingApp.normalize();
 				fieldsValidator = appService.modifyOnboardingApp(modifiedOnboardingApp, user);
 				response.setStatus(fieldsValidator.httpStatusCode.intValue());
@@ -722,6 +772,8 @@ public class AppsController extends EPRestrictedBaseController {
 		return fieldsValidator;
 	}
 
+	
+	
 	/**
 	 * 
 	 * @param request
@@ -742,17 +794,58 @@ public class AppsController extends EPRestrictedBaseController {
 				EcompPortalUtils.setBadPermissions(user, response, "postOnboardingApps");
 			} else {
 				newOnboardingApp.normalize();
+				ResponseEntity<String> res = null;
+				try {
+					if( !(newOnboardingApp.nameSpace == null) && !newOnboardingApp.nameSpace.isEmpty()) 
+					    res = appService.checkIfNameSpaceIsValid(newOnboardingApp.nameSpace);
+				} catch (HttpClientErrorException e) {
+					logger.error(EELFLoggerDelegate.errorLogger, "checkIfNameSpaceExists failed", e);
+					EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+					if (e.getStatusCode() == HttpStatus.NOT_FOUND || e.getStatusCode() == HttpStatus.FORBIDDEN) {
+						fieldsValidator = setResponse(e.getStatusCode(),fieldsValidator,response);
+						throw new InvalidApplicationException("Invalid NameSpace");
+					}else{
+						fieldsValidator = setResponse(e.getStatusCode(),fieldsValidator,response);
+						throw e;
+					}
+				}
 				fieldsValidator = appService.addOnboardingApp(newOnboardingApp, user);
 				response.setStatus(fieldsValidator.httpStatusCode.intValue());
 			}
+			if(response.getStatus()==200) {
+				try {
+					String newvaluesAsJson = new ObjectMapper().writeValueAsString(newOnboardingApp);
+					logger.info(EELFLoggerDelegate.auditLogger, "/portalApi/onboardingApps, loginId="+user.getLoginId()+",  values ="+newvaluesAsJson);
+				} catch (JsonProcessingException e) {
+					logger.error(EELFLoggerDelegate.errorLogger, "postOnboardingApps failed", e);
+				}
+			}
 		} catch (Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, "postOnboardingApp failed", e);
+			logger.error(EELFLoggerDelegate.errorLogger, "postOnboardingApp failed", e);				
 		}
 
 		EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps", "POST result =",
 				response.getStatus());
 		return fieldsValidator;
 	}
+	
+	private FieldsValidator setResponse(HttpStatus statusCode,FieldsValidator fieldsValidator,HttpServletResponse response)
+	{
+		fieldsValidator = new FieldsValidator();
+		if (statusCode == HttpStatus.NOT_FOUND || statusCode == HttpStatus.FORBIDDEN) {
+			fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_NOT_FOUND);
+			logger.error(EELFLoggerDelegate.errorLogger, "setResponse failed"+ "invalid namespace");
+		}else if (statusCode == HttpStatus.UNAUTHORIZED) {
+			fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_UNAUTHORIZED);
+			logger.error(EELFLoggerDelegate.errorLogger, "setResponse failed"+ "unauthorized");
+		} else{
+			fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+			logger.error(EELFLoggerDelegate.errorLogger, "setResponse failed ",statusCode);
+
+		}
+		response.setStatus(fieldsValidator.httpStatusCode.intValue());
+		return fieldsValidator;
+	}
 
 	/**
 	 * REST endpoint to process a request to delete an on-boarded application.
@@ -778,11 +871,15 @@ public class AppsController extends EPRestrictedBaseController {
 				fieldsValidator = appService.deleteOnboardingApp(user, appId);
 				response.setStatus(fieldsValidator.httpStatusCode.intValue());
 			}
+			if (response.getStatus() == 200) {
+				logger.info(EELFLoggerDelegate.auditLogger,
+						"/portalApi/onboardingApps/" + appId + "deleted by user " + user.getLoginId());
+			}
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "deleteOnboardingApp failed", e);
 			response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 		}
-
+		
 		EcompPortalUtils.logAndSerializeObject(logger, "/portalApi/onboardingApps" + appId, "DELETE result =",
 				response.getStatus());
 		return fieldsValidator;
@@ -823,5 +920,6 @@ public class AppsController extends EPRestrictedBaseController {
 		header.setContentLength(app.getThumbnail().length);
 		return new HttpEntity<byte[]>(app.getThumbnail(), header);
 	}
+	
 
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/RoleManageController.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/RoleManageController.java
index 3fda5392..b50d1cf4 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/RoleManageController.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/RoleManageController.java
@@ -130,37 +130,36 @@ public class RoleManageController extends EPRestrictedBaseController {
 
 	@Autowired
 	private RoleListController roleListController;
-	
+
 	@Autowired
 	private EPAppService appService;
 
 	@Autowired
 	private AuditService auditService;
-	
+
 	@Autowired
 	private ExternalAccessRolesService externalAccessRolesService;
-	
-	
+
 	@Autowired
 	private AdminRolesService adminRolesService;
 
 	/**
 	 * Calls an SDK-Core library method that gets the available roles and writes
-	 * them to the request object. Portal specifies a Hibernate mappings from
-	 * the Role class to the fn_role_v view, which ensures that only Portal
-	 * (app_id is null) roles are fetched.
+	 * them to the request object. Portal specifies a Hibernate mappings from the
+	 * Role class to the fn_role_v view, which ensures that only Portal (app_id is
+	 * null) roles are fetched.
 	 * 
-	 * Any method declared void (no return value) or returning null causes the
-	 * audit log aspect method to declare failure. TODO: should return a JSON
-	 * string.
+	 * Any method declared void (no return value) or returning null causes the audit
+	 * log aspect method to declare failure. TODO: should return a JSON string.
 	 * 
 	 * @param request
 	 * @param response
-	 * @throws Exception 
+	 * @throws Exception
 	 */
-	
+
 	@RequestMapping(value = { "/portalApi/get_roles/{appId}" }, method = RequestMethod.GET)
-	public void getRoles(HttpServletRequest request, HttpServletResponse response, @PathVariable("appId") Long appId) throws Exception {
+	public void getRoles(HttpServletRequest request, HttpServletResponse response, @PathVariable("appId") Long appId)
+			throws Exception {
 		try {
 			EPUser user = EPUserUtils.getUserSession(request);
 			EPApp requestedApp = appService.getApp(appId);
@@ -186,12 +185,10 @@ public class RoleManageController extends EPRestrictedBaseController {
 			logger.error(EELFLoggerDelegate.errorLogger, "getRoles failed", e);
 		}
 	}
-	
-	
 
 	@RequestMapping(value = { "/portalApi/role_list/toggleRole/{appId}/{roleId}" }, method = RequestMethod.POST)
-	public Map<String, Object> toggleRole(HttpServletRequest request, HttpServletResponse response, @PathVariable("appId") Long appId,
-			@PathVariable("roleId") Long roleId) throws Exception {
+	public Map<String, Object> toggleRole(HttpServletRequest request, HttpServletResponse response,
+			@PathVariable("appId") Long appId, @PathVariable("roleId") Long roleId) throws Exception {
 		EPApp requestedApp = null;
 		String restcallStatus = null;
 		HashMap<String, Object> responseMap = new HashMap<>();
@@ -232,10 +229,10 @@ public class RoleManageController extends EPRestrictedBaseController {
 		}
 		return responseMap;
 	}
-	
+
 	@RequestMapping(value = { "/portalApi/role_list/removeRole/{appId}/{roleId}" }, method = RequestMethod.POST)
-	public Map<String, Object> removeRole(HttpServletRequest request, HttpServletResponse response, @PathVariable("appId") Long appId,
-			@PathVariable("roleId") Long roleId) throws Exception {
+	public Map<String, Object> removeRole(HttpServletRequest request, HttpServletResponse response,
+			@PathVariable("appId") Long appId, @PathVariable("roleId") Long roleId) throws Exception {
 
 		EPUser user = EPUserUtils.getUserSession(request);
 		EPApp requestedApp = null;
@@ -298,7 +295,7 @@ public class RoleManageController extends EPRestrictedBaseController {
 		}
 		return responseMap;
 	}
-	
+
 	@RequestMapping(value = { "/portalApi/role/saveRole/{appId}" }, method = RequestMethod.POST)
 	public Map<String, Object> saveRole(HttpServletRequest request, HttpServletResponse response,
 			@PathVariable("appId") Long appId) throws Exception {
@@ -353,9 +350,13 @@ public class RoleManageController extends EPRestrictedBaseController {
 								throw new InvalidRoleException("Invalid role function type:" + roleFunction.getType()
 										+ " and action: " + roleFunction.getAction() + " found while saving!");
 							}
-							roleFunction.setCode(externalAccessRolesService.encodeFunctionCode(roleFunction.getCode()));
-							roleFunction.setCode(roleFunction.getType() + PIPE + roleFunction.getCode() + PIPE
-									+ roleFunction.getAction());
+							if (EcompPortalUtils.checkFunctionCodeHasEncodePattern(roleFunction.getCode()))
+								roleFunction.setCode(roleFunction.getType() + PIPE
+										+ EcompPortalUtils.encodeFunctionCode(roleFunction.getCode()) + PIPE
+										+ roleFunction.getAction());
+							else
+								roleFunction.setCode(roleFunction.getType() + PIPE + roleFunction.getCode() + PIPE
+										+ roleFunction.getAction());
 							domainRole.addRoleFunction((CentralV2RoleFunction) roleFunction);
 						}
 					} else {
@@ -444,29 +445,29 @@ public class RoleManageController extends EPRestrictedBaseController {
 			@PathVariable("roleId") Long roleId) throws Exception {
 		try {
 			EPUser user = EPUserUtils.getUserSession(request);
-				ObjectMapper mapper = new ObjectMapper();
-				EPApp requestedApp = appService.getApp(appId);
-				if (isAuthorizedUser(user, requestedApp)) {
-					fieldsValidation(requestedApp);
-					if (requestedApp.getCentralAuth()) {
-						CentralV2Role answer = externalAccessRolesService.getRoleInfo(roleId, requestedApp.getUebKey());
-						logger.info(EELFLoggerDelegate.applicationLogger, "role_id" + roleId);
-						Map<String, Object> model = new HashMap<>();
-						model.put("availableRoleFunctions", mapper.writeValueAsString(
-								externalAccessRolesService.getRoleFuncList(requestedApp.getUebKey())));
-						model.put("availableRoles",
-								mapper.writeValueAsString(getAvailableChildRoles(requestedApp.getUebKey(), roleId)));
-						model.put("role", mapper.writeValueAsString(answer));
-						JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
-						JSONObject j = new JSONObject(msg);
-						response.getWriter().write(j.toString());
-					} else
-						throw new NonCentralizedAppException(requestedApp.getName());
-				} else {
-					logger.info(EELFLoggerDelegate.auditLogger,
-							"RoleManageController.getRoleFunctionList, Unauthorized user");
-					SendErrorForUnauthorizedUser(response, user);
-				}
+			ObjectMapper mapper = new ObjectMapper();
+			EPApp requestedApp = appService.getApp(appId);
+			if (isAuthorizedUser(user, requestedApp)) {
+				fieldsValidation(requestedApp);
+				if (requestedApp.getCentralAuth()) {
+					CentralV2Role answer = externalAccessRolesService.getRoleInfo(roleId, requestedApp.getUebKey());
+					logger.info(EELFLoggerDelegate.applicationLogger, "role_id" + roleId);
+					Map<String, Object> model = new HashMap<>();
+					model.put("availableRoleFunctions", mapper
+							.writeValueAsString(externalAccessRolesService.getRoleFuncList(requestedApp.getUebKey())));
+					model.put("availableRoles",
+							mapper.writeValueAsString(getAvailableChildRoles(requestedApp.getUebKey(), roleId)));
+					model.put("role", mapper.writeValueAsString(answer));
+					JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
+					JSONObject j = new JSONObject(msg);
+					response.getWriter().write(j.toString());
+				} else
+					throw new NonCentralizedAppException(requestedApp.getName());
+			} else {
+				logger.info(EELFLoggerDelegate.auditLogger,
+						"RoleManageController.getRoleFunctionList, Unauthorized user");
+				SendErrorForUnauthorizedUser(response, user);
+			}
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "getRole failed", e);
 			throw e;
@@ -478,26 +479,26 @@ public class RoleManageController extends EPRestrictedBaseController {
 			@PathVariable("appId") Long appId) throws Exception {
 		try {
 			EPUser user = EPUserUtils.getUserSession(request);
-				EPApp requestedApp = appService.getApp(appId);
-				if (isAuthorizedUser(user, requestedApp)) {
-					fieldsValidation(requestedApp);
-					if (requestedApp.getCentralAuth()) {
-						List<CentralV2RoleFunction> answer = null;
-						Map<String, Object> model = new HashMap<>();
-						ObjectMapper mapper = new ObjectMapper();
-						answer = externalAccessRolesService.getRoleFuncList(requestedApp.getUebKey());
-						model.put("availableRoleFunctions", answer);
-						JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
-						JSONObject j = new JSONObject(msg);
-						response.getWriter().write(j.toString());
-					} else
-						throw new NonCentralizedAppException(requestedApp.getName());
-				} else {
-					logger.info(EELFLoggerDelegate.auditLogger,
-							"RoleManageController.getRoleFunctionList, Unauthorized user");
-					EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
-					response.getWriter().write("Unauthorized User");
-				}
+			EPApp requestedApp = appService.getApp(appId);
+			if (isAuthorizedUser(user, requestedApp)) {
+				fieldsValidation(requestedApp);
+				if (requestedApp.getCentralAuth()) {
+					List<CentralV2RoleFunction> answer = null;
+					Map<String, Object> model = new HashMap<>();
+					ObjectMapper mapper = new ObjectMapper();
+					answer = externalAccessRolesService.getRoleFuncList(requestedApp.getUebKey());
+					model.put("availableRoleFunctions", answer);
+					JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model));
+					JSONObject j = new JSONObject(msg);
+					response.getWriter().write(j.toString());
+				} else
+					throw new NonCentralizedAppException(requestedApp.getName());
+			} else {
+				logger.info(EELFLoggerDelegate.auditLogger,
+						"RoleManageController.getRoleFunctionList, Unauthorized user");
+				EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
+				response.getWriter().write("Unauthorized User");
+			}
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunctionList failed", e);
 			throw e;
@@ -523,13 +524,14 @@ public class RoleManageController extends EPRestrictedBaseController {
 			if (isAuthorizedUser(user, requestedApp)) {
 				fieldsValidation(requestedApp);
 				if (requestedApp.getCentralAuth()) {
-					String code = roleFunc.getType()+PIPE+roleFunc.getCode()+PIPE+roleFunc.getAction();
+					String code = roleFunc.getType() + PIPE + roleFunc.getCode() + PIPE + roleFunc.getAction();
 					CentralV2RoleFunction domainRoleFunction = externalAccessRolesService.getRoleFunction(code,
 							requestedApp.getUebKey());
-					if(domainRoleFunction != null && (domainRoleFunction.getType() == null || domainRoleFunction.getAction() == null)) {
+					if (domainRoleFunction != null
+							&& (domainRoleFunction.getType() == null || domainRoleFunction.getAction() == null)) {
 						addIfTypeActionDoesNotExits(domainRoleFunction);
 					}
-					boolean isSave =  true;
+					boolean isSave = true;
 					if (domainRoleFunction != null && domainRoleFunction.getCode().equals(roleFunc.getCode())
 							&& domainRoleFunction.getType().equals(roleFunc.getType())
 							&& domainRoleFunction.getAction().equals(roleFunc.getAction())) {
@@ -545,16 +547,14 @@ public class RoleManageController extends EPRestrictedBaseController {
 					if (saveOrUpdateResponse) {
 						EPUser requestedUser = externalAccessRolesService.getUser(user.getOrgUserId()).get(0);
 						EPApp app = externalAccessRolesService.getApp(requestedApp.getUebKey()).get(0);
-						String activityCode = (isSave)
-								? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
+						String activityCode = (isSave) ? EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_ADD_FUNCTION
 								: EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_FUNCTION;
 						logExterlaAuthRoleFunctionActivity(code, requestedUser, app, activityCode);
 					}
 				} else
 					throw new NonCentralizedAppException(requestedApp.getName() + " is not Centralized Application");
 			} else {
-				logger.info(EELFLoggerDelegate.auditLogger,
-						"RoleManageController.saveRoleFunction, Unauthorized user");
+				logger.info(EELFLoggerDelegate.auditLogger, "RoleManageController.saveRoleFunction, Unauthorized user");
 				EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
 				return new PortalRestResponse<>(PortalRestStatusEnum.ERROR, "Unauthorized User", "Failure");
 			}
@@ -564,35 +564,29 @@ public class RoleManageController extends EPRestrictedBaseController {
 		}
 		return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Saved Successfully!", "Success");
 	}
-	
+
 	private void logExterlaAuthRoleFunctionActivity(String code, EPUser requestedUser, EPApp app, String activityCode) {
-		logger.info(EELFLoggerDelegate.applicationLogger,
-				"saveRoleFunction: succeeded for app {}, function {}", app.getId(), code);
+		logger.info(EELFLoggerDelegate.applicationLogger, "saveRoleFunction: succeeded for app {}, function {}",
+				app.getId(), code);
 		AuditLog auditLog = getAuditInfo(requestedUser, activityCode);
-		auditLog.setComments(EcompPortalUtils.truncateString("saveRoleFunction role for app:"
-				+ app.getId() + " and function:'" + code + "'",
+		auditLog.setComments(EcompPortalUtils.truncateString(
+				"saveRoleFunction role for app:" + app.getId() + " and function:'" + code + "'",
 				PortalConstants.AUDIT_LOG_COMMENT_SIZE));
 		auditService.logActivity(auditLog, null);
-		MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP,
-				EPEELFLoggerAdvice.getCurrentDateTimeUTC());
-		MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP,
-				EPEELFLoggerAdvice.getCurrentDateTimeUTC());
-		EcompPortalUtils.calculateDateTimeDifferenceForLog(
-				MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
+		MDC.put(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
+		MDC.put(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP, EPEELFLoggerAdvice.getCurrentDateTimeUTC());
+		EcompPortalUtils.calculateDateTimeDifferenceForLog(MDC.get(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP),
 				MDC.get(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP));
 		logger.info(EELFLoggerDelegate.auditLogger,
 				EPLogUtil.formatAuditLogMessage("RoleManageController.saveRoleFunction", activityCode,
-						String.valueOf(requestedUser.getId()), requestedUser.getOrgUserId(),
-						code));
+						String.valueOf(requestedUser.getId()), requestedUser.getOrgUserId(), code));
 		MDC.remove(EPCommonSystemProperties.AUDITLOG_BEGIN_TIMESTAMP);
 		MDC.remove(EPCommonSystemProperties.AUDITLOG_END_TIMESTAMP);
 		MDC.remove(SystemProperties.MDC_TIMER);
 	}
 
-
-
 	private void addIfTypeActionDoesNotExits(CentralV2RoleFunction domainRoleFunction) {
-		if(domainRoleFunction.getCode().contains(PIPE)) {
+		if (domainRoleFunction.getCode().contains(PIPE)) {
 			String newfunctionCodeFormat = EcompPortalUtils.getFunctionCode(domainRoleFunction.getCode());
 			String newfunctionTypeFormat = EcompPortalUtils.getFunctionType(domainRoleFunction.getCode());
 			String newfunctionActionFormat = EcompPortalUtils.getFunctionAction(domainRoleFunction.getCode());
@@ -697,19 +691,19 @@ public class RoleManageController extends EPRestrictedBaseController {
 				return null;
 			}
 		}
-
 		EPUser user = EPUserUtils.getUserSession(request);
 		List<CentralizedApp> applicationsList = null;
-			if (adminRolesService.isAccountAdmin(user) || adminRolesService.isSuperAdmin(user) || adminRolesService.isRoleAdmin(user)) {
-				applicationsList = externalAccessRolesService.getCentralizedAppsOfUser(userId);
-			} else {
-				logger.info(EELFLoggerDelegate.auditLogger,
-						"RoleManageController.getCentralizedAppRoles, Unauthorized user");
-				EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
-			}
+		if (adminRolesService.isAccountAdmin(user) || adminRolesService.isSuperAdmin(user)
+				|| adminRolesService.isRoleAdmin(user)) {
+			applicationsList = externalAccessRolesService.getCentralizedAppsOfUser(userId);
+		} else {
+			logger.info(EELFLoggerDelegate.auditLogger,
+					"RoleManageController.getCentralizedAppRoles, Unauthorized user");
+			EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
+		}
 		return applicationsList;
 	}
-	
+
 	public RoleListController getRoleListController() {
 		return roleListController;
 	}
@@ -726,7 +720,6 @@ public class RoleManageController extends EPRestrictedBaseController {
 		this.roleController = roleController;
 	}
 
-
 	@RequestMapping(value = { "/portalApi/syncRoles" }, method = RequestMethod.POST, produces = "application/json")
 	public PortalRestResponse<String> syncRoles(HttpServletRequest request, HttpServletResponse response,
 			@RequestBody Long appId) {
@@ -748,7 +741,7 @@ public class RoleManageController extends EPRestrictedBaseController {
 		}
 		return new PortalRestResponse<>(PortalRestStatusEnum.OK, "Sync roles completed successfully!", "Success");
 	}
-	
+
 	@RequestMapping(value = { "/portalApi/syncFunctions" }, method = RequestMethod.POST, produces = "application/json")
 	public PortalRestResponse<String> syncFunctions(HttpServletRequest request, HttpServletResponse response,
 			@RequestBody Long appId) {
@@ -798,30 +791,30 @@ public class RoleManageController extends EPRestrictedBaseController {
 		}
 		return allParentRoles;
 	}
-	
-	public AuditLog getAuditInfo(EPUser user, String activityCode)
-	{
+
+	public AuditLog getAuditInfo(EPUser user, String activityCode) {
 		AuditLog auditLog = new AuditLog();
 		auditLog.setUserId(user.getId());
 		auditLog.setActivityCode(activityCode);
 		auditLog.setAffectedRecordId(user.getOrgUserId());
-		
+
 		return auditLog;
 	}
-	
-	private void  fieldsValidation(EPApp app) throws Exception{
+
+	private void fieldsValidation(EPApp app) throws Exception {
 		app.getUebKey();
 		List<EPApp> appInfo = externalAccessRolesService.getApp(app.getUebKey());
-		if(appInfo.isEmpty()){
+		if (appInfo.isEmpty()) {
 			throw new InvalidApplicationException("Invalid credentials");
 		}
-		if(!appInfo.isEmpty() && EcompPortalUtils.checkIfRemoteCentralAccessAllowed() && appInfo.get(0).getCentralAuth()){
+		if (!appInfo.isEmpty() && EcompPortalUtils.checkIfRemoteCentralAccessAllowed()
+				&& appInfo.get(0).getCentralAuth()) {
 			ResponseEntity<String> response = externalAccessRolesService.getNameSpaceIfExists(appInfo.get(0));
 			if (response.getStatusCode().value() == HttpServletResponse.SC_NOT_FOUND)
 				throw new InvalidApplicationException("Invalid NameSpace");
 		}
 	}
-	
+
 	private boolean isAuthorizedUser(EPUser user, EPApp requestedApp) {
 		if (user != null && (adminRolesService.isAccountAdminOfApplication(user, requestedApp)
 				|| (adminRolesService.isSuperAdmin(user) && requestedApp.getId() == PortalConstants.PORTAL_APP_ID)))
@@ -833,8 +826,9 @@ public class RoleManageController extends EPRestrictedBaseController {
 		EcompPortalUtils.setBadPermissions(user, response, "createAdmin");
 		response.getWriter().write("Unauthorized User");
 	}
-	
-	@RequestMapping(value = { "/portalApi/uploadRoleFunction/{appId}" }, method = RequestMethod.POST, produces = "application/json")
+
+	@RequestMapping(value = {
+			"/portalApi/uploadRoleFunction/{appId}" }, method = RequestMethod.POST, produces = "application/json")
 	public PortalRestResponse<String> bulkUploadRoleFunc(HttpServletRequest request, HttpServletResponse response,
 			@RequestBody UploadRoleFunctionExtSystem data, @PathVariable("appId") Long appId) {
 		EPUser user = EPUserUtils.getUserSession(request);
@@ -843,9 +837,10 @@ public class RoleManageController extends EPRestrictedBaseController {
 			if (isAuthorizedUser(user, app)) {
 				fieldsValidation(app);
 				externalAccessRolesService.bulkUploadRoleFunc(data, app);
-				String activityCode =  EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
-				String code = data.getName()+","+data.getType()+ PIPE + data.getInstance() + PIPE + data.getAction();
-				logExterlaAuthRoleFunctionActivity(code , user, app, activityCode);
+				String activityCode = EcompAuditLog.CD_ACTIVITY_EXTERNAL_AUTH_UPDATE_ROLE_AND_FUNCTION;
+				String code = data.getName() + "," + data.getType() + PIPE + data.getInstance() + PIPE
+						+ data.getAction();
+				logExterlaAuthRoleFunctionActivity(code, user, app, activityCode);
 			} else {
 				logger.info(EELFLoggerDelegate.auditLogger,
 						"RoleManageController.syncRoles, Unauthorized user:{}", user != null ? user.getOrgUserId() : "");
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/SchedulerController.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/SchedulerController.java
index 0be83c97..af34176c 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/SchedulerController.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/SchedulerController.java
@@ -41,7 +41,9 @@ import java.text.DateFormat;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.UUID;
 
 import javax.servlet.http.HttpServletRequest;
@@ -49,8 +51,10 @@ import javax.servlet.http.HttpServletResponse;
 
 import org.json.simple.JSONObject;
 import org.onap.portalapp.controller.EPRestrictedBaseController;
+import org.onap.portalapp.portal.domain.EPUser;
 import org.onap.portalapp.portal.ecomp.model.PortalRestResponse;
 import org.onap.portalapp.portal.ecomp.model.PortalRestStatusEnum;
+import org.onap.portalapp.portal.exceptions.RoleFunctionException;
 import org.onap.portalapp.portal.logging.aop.EPAuditLog;
 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
 import org.onap.portalapp.portal.scheduler.SchedulerProperties;
@@ -62,8 +66,11 @@ import org.onap.portalapp.portal.scheduler.restobjects.PostSubmitVnfChangeRestOb
 import org.onap.portalapp.portal.scheduler.wrapper.GetTimeSlotsWrapper;
 import org.onap.portalapp.portal.scheduler.wrapper.PostCreateNewVnfWrapper;
 import org.onap.portalapp.portal.scheduler.wrapper.PostSubmitVnfChangeTimeSlotsWrapper;
+import org.onap.portalapp.portal.service.AdminRolesService;
 import org.onap.portalapp.portal.utils.PortalConstants;
+import org.onap.portalapp.util.EPUserUtils;
 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
+import org.onap.portalsdk.core.service.DataAccessService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.EnableAspectJAutoProxy;
@@ -84,6 +91,9 @@ public class SchedulerController extends EPRestrictedBaseController {
 
 	@Autowired
 	private SchedulerRestInterface schedulerRestController;
+	
+	@Autowired
+	private AdminRolesService adminRolesService;
 
 	private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(SchedulerController.class);
 
@@ -93,33 +103,36 @@ public class SchedulerController extends EPRestrictedBaseController {
 	@RequestMapping(value = "/get_time_slots/{scheduler_request}", method = RequestMethod.GET, produces = "application/json")
 	public ResponseEntity<String> getTimeSlots(HttpServletRequest request,
 			@PathVariable("scheduler_request") String scheduler_request) throws Exception {
-		try {
-
-			Date startingTime = new Date();
-			String startTimeRequest = requestDateFormat.format(startingTime);
-			logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler GET Timeslots for startTimeRequest: ",
-					startTimeRequest);
-			logger.debug(EELFLoggerDelegate.debugLogger, "Original Request = {} ", scheduler_request);
-
-			String path = SchedulerProperties.getProperty(SchedulerProperties.SCHEDULER_GET_TIME_SLOTS)
-					+ scheduler_request;
-
-			GetTimeSlotsWrapper schedulerResWrapper = getTimeSlots(scheduler_request, path, scheduler_request);
-
-			Date endTime = new Date();
-			String endTimeRequest = requestDateFormat.format(endTime);
-			logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler - GET for EndTimeRequest = {}",
-					endTimeRequest);
-			return (new ResponseEntity<String>(schedulerResWrapper.getResponse(),
-					HttpStatus.valueOf(schedulerResWrapper.getStatus())));
-		} catch (Exception e) {
-			GetTimeSlotsWrapper schedulerResWrapper=new GetTimeSlotsWrapper();
-			schedulerResWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
-			schedulerResWrapper.setEntity(e.getMessage());
-			logger.error(EELFLoggerDelegate.errorLogger, "Exception with getTimeslots", e);
-			return (new ResponseEntity<String>(schedulerResWrapper.getResponse(), HttpStatus.INTERNAL_SERVER_ERROR));
+		if (checkIfUserISValidToMakeSchedule(request)) {
+			try {
+				Date startingTime = new Date();
+				String startTimeRequest = requestDateFormat.format(startingTime);
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"Controller Scheduler GET Timeslots for startTimeRequest: ", startTimeRequest);
+				logger.debug(EELFLoggerDelegate.debugLogger, "Original Request = {} ", scheduler_request);
+
+				String path = SchedulerProperties.getProperty(SchedulerProperties.SCHEDULER_GET_TIME_SLOTS)
+						+ scheduler_request;
+
+				GetTimeSlotsWrapper schedulerResWrapper = getTimeSlots(scheduler_request, path, scheduler_request);
+
+				Date endTime = new Date();
+				String endTimeRequest = requestDateFormat.format(endTime);
+				logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler - GET for EndTimeRequest = {}",
+						endTimeRequest);
+				return (new ResponseEntity<String>(schedulerResWrapper.getResponse(),
+						HttpStatus.valueOf(schedulerResWrapper.getStatus())));
+			} catch (Exception e) {
+				GetTimeSlotsWrapper schedulerResWrapper = new GetTimeSlotsWrapper();
+				schedulerResWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+				schedulerResWrapper.setEntity(e.getMessage());
+				logger.error(EELFLoggerDelegate.errorLogger, "Exception with getTimeslots", e);
+				return (new ResponseEntity<String>(schedulerResWrapper.getResponse(),
+						HttpStatus.INTERNAL_SERVER_ERROR));
+			}
+		}else{
+			return (new ResponseEntity<String>("User is unauthorized to make this call", HttpStatus.UNAUTHORIZED));
 		}
-
 	}
 
 	protected GetTimeSlotsWrapper getTimeSlots(String request, String path, String uuid) throws Exception {
@@ -157,41 +170,45 @@ public class SchedulerController extends EPRestrictedBaseController {
 	@RequestMapping(value = "/post_create_new_vnf_change", method = RequestMethod.POST, produces = "application/json")
 	public ResponseEntity<String> postCreateNewVNFChange(HttpServletRequest request,
 			@RequestBody JSONObject scheduler_request) throws Exception {
-		try {
-			Date startingTime = new Date();
-			String startTimeRequest = requestDateFormat.format(startingTime);
+		if (checkIfUserISValidToMakeSchedule(request)) {
+			try {
+				Date startingTime = new Date();
+				String startTimeRequest = requestDateFormat.format(startingTime);
 
-			logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler POST : post_create_new_vnf_change",
-					startTimeRequest);
+				logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler POST : post_create_new_vnf_change",
+						startTimeRequest);
 
-			// Generating uuid
-			String uuid = UUID.randomUUID().toString();
+				// Generating uuid
+				String uuid = UUID.randomUUID().toString();
 
-			scheduler_request.put("scheduleId", uuid);
-			logger.debug(EELFLoggerDelegate.debugLogger, "UUID = {} ", uuid);
+				scheduler_request.put("scheduleId", uuid);
+				logger.debug(EELFLoggerDelegate.debugLogger, "UUID = {} ", uuid);
 
-			// adding uuid to the request payload
-			scheduler_request.put("scheduleId", uuid);
-			logger.debug(EELFLoggerDelegate.debugLogger, "Original Request = {}", scheduler_request.toString());
+				// adding uuid to the request payload
+				scheduler_request.put("scheduleId", uuid);
+				logger.debug(EELFLoggerDelegate.debugLogger, "Original Request = {}", scheduler_request.toString());
 
-			String path = SchedulerProperties
-					.getProperty(SchedulerProperties.SCHEDULER_CREATE_NEW_VNF_CHANGE_INSTANCE_VAL) + uuid;
+				String path = SchedulerProperties
+						.getProperty(SchedulerProperties.SCHEDULER_CREATE_NEW_VNF_CHANGE_INSTANCE_VAL) + uuid;
 
-			PostCreateNewVnfWrapper responseWrapper = postSchedulingRequest(scheduler_request, path, uuid);
+				PostCreateNewVnfWrapper responseWrapper = postSchedulingRequest(scheduler_request, path, uuid);
 
-			Date endTime = new Date();
-			String endTimeRequest = requestDateFormat.format(endTime);
-			logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler - POST= {}", endTimeRequest);
+				Date endTime = new Date();
+				String endTimeRequest = requestDateFormat.format(endTime);
+				logger.debug(EELFLoggerDelegate.debugLogger, "Controller Scheduler - POST= {}", endTimeRequest);
 
-			return new ResponseEntity<String>(responseWrapper.getResponse(),
-					HttpStatus.valueOf(responseWrapper.getStatus()));
-		} catch (Exception e) {
-			PostCreateNewVnfWrapper responseWrapper=new PostCreateNewVnfWrapper();
-			responseWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
-			responseWrapper.setEntity(e.getMessage());
-			logger.error(EELFLoggerDelegate.errorLogger, "Exception with postCreateNewVNFChange ", e);
-			return (new ResponseEntity<String>(responseWrapper.getResponse(), HttpStatus.INTERNAL_SERVER_ERROR));
+				return new ResponseEntity<String>(responseWrapper.getResponse(),
+						HttpStatus.valueOf(responseWrapper.getStatus()));
+			} catch (Exception e) {
+				PostCreateNewVnfWrapper responseWrapper = new PostCreateNewVnfWrapper();
+				responseWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+				responseWrapper.setEntity(e.getMessage());
+				logger.error(EELFLoggerDelegate.errorLogger, "Exception with postCreateNewVNFChange ", e);
+				return (new ResponseEntity<String>(responseWrapper.getResponse(), HttpStatus.INTERNAL_SERVER_ERROR));
 
+			}
+		}else{
+			return (new ResponseEntity<String>("User is unauthorized to make this call",HttpStatus.UNAUTHORIZED));
 		}
 
 	}
@@ -233,6 +250,7 @@ public class SchedulerController extends EPRestrictedBaseController {
 	@RequestMapping(value = "/submit_vnf_change_timeslots", method = RequestMethod.POST, produces = "application/json")
 	public ResponseEntity<String> postSubmitVnfChangeTimeslots(HttpServletRequest request,
 			@RequestBody JSONObject scheduler_request) throws Exception {
+		if (checkIfUserISValidToMakeSchedule(request)) {
 		try {
 			Date startingTime = new Date();
 			String startTimeRequest = requestDateFormat.format(startingTime);
@@ -259,13 +277,16 @@ public class SchedulerController extends EPRestrictedBaseController {
 					endTimeRequest);
 
 			return (new ResponseEntity<String>(responseWrapper.getResponse(),HttpStatus.valueOf(responseWrapper.getStatus())));
-		} catch (Exception e) {
-			PostSubmitVnfChangeTimeSlotsWrapper responseWrapper=new PostSubmitVnfChangeTimeSlotsWrapper();
-			responseWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
-			responseWrapper.setEntity(e.getMessage());
-			logger.error(EELFLoggerDelegate.errorLogger, "Exception with Post submit Vnf change Timeslots", e);
-			return (new ResponseEntity<String>(responseWrapper.getResponse(), HttpStatus.INTERNAL_SERVER_ERROR));
+			} catch (Exception e) {
+				PostSubmitVnfChangeTimeSlotsWrapper responseWrapper = new PostSubmitVnfChangeTimeSlotsWrapper();
+				responseWrapper.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+				responseWrapper.setEntity(e.getMessage());
+				logger.error(EELFLoggerDelegate.errorLogger, "Exception with Post submit Vnf change Timeslots", e);
+				return (new ResponseEntity<String>(responseWrapper.getResponse(), HttpStatus.INTERNAL_SERVER_ERROR));
 
+			}
+		}else{
+			return (new ResponseEntity<String>("User is unauthorized to make this call",HttpStatus.UNAUTHORIZED));
 		}
 	}
 
@@ -310,43 +331,74 @@ public class SchedulerController extends EPRestrictedBaseController {
 	 * Get Scheduler UI constant values from properties file
 	 * 
 	 * @return Rest response wrapped around a String; e.g., "success" or "ERROR"
+	 * @throws Exception 
 	 */
 	@RequestMapping(value = "/get_scheduler_constant", method = RequestMethod.GET, produces = "application/json")
 	public PortalRestResponse<Map<String, String>> getSchedulerConstant(HttpServletRequest request,
-			HttpServletResponse response) {
+			HttpServletResponse response) throws Exception {
 		logger.debug(EELFLoggerDelegate.debugLogger, "get scheduler constant");
 
 		PortalRestResponse<Map<String, String>> portalRestResponse = null;
-		String errorMsg = " is not defined in property file. Please check the property file and make sure all the schedule constant values are defined";
-		HashMap<String, String> constantMap = new HashMap<>();
-		constantMap.put(SchedulerProperties.SCHEDULER_DOMAIN_NAME, "domainName");
-		constantMap.put(SchedulerProperties.SCHEDULER_SCHEDULE_NAME, "scheduleName");
-		constantMap.put(SchedulerProperties.SCHEDULER_WORKFLOW_NAME, "workflowName");
-		constantMap.put(SchedulerProperties.SCHEDULER_CALLBACK_URL, "callbackUrl");
-		constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_TYPE, "approvalType");
-		constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_SUBMIT_STATUS, "approvalSubmitStatus");
-		constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_REJECT_STATUS, "approvalRejectStatus");
-		constantMap.put(SchedulerProperties.SCHEDULER_POLICY_NAME, "policyName");
-		constantMap.put(SchedulerProperties.SCHEDULER_INTERVAL_GET_TIMESLOT_RATE, "intervalRate");
-		constantMap.put(SchedulerProperties.SCHEDULER_GROUP_ID, "groupId");
-		try {
-			Map<String, String> map = new HashMap<>();
-			for (Map.Entry<String, String> entry : constantMap.entrySet()) {
-				if (SchedulerProperties.containsProperty(entry.getKey()))
-					map.put(entry.getValue(), SchedulerProperties.getProperty(entry.getKey()));
-				else
-					throw new Exception(entry.getKey() + errorMsg);
+
+		if (checkIfUserISValidToMakeSchedule(request)) {
+			String errorMsg = " is not defined in property file. Please check the property file and make sure all the schedule constant values are defined";
+			HashMap<String, String> constantMap = new HashMap<>();
+			constantMap.put(SchedulerProperties.SCHEDULER_DOMAIN_NAME, "domainName");
+			constantMap.put(SchedulerProperties.SCHEDULER_SCHEDULE_NAME, "scheduleName");
+			constantMap.put(SchedulerProperties.SCHEDULER_WORKFLOW_NAME, "workflowName");
+			constantMap.put(SchedulerProperties.SCHEDULER_CALLBACK_URL, "callbackUrl");
+			constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_TYPE, "approvalType");
+			constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_SUBMIT_STATUS, "approvalSubmitStatus");
+			constantMap.put(SchedulerProperties.SCHEDULER_APPROVAL_REJECT_STATUS, "approvalRejectStatus");
+			constantMap.put(SchedulerProperties.SCHEDULER_POLICY_NAME, "policyName");
+			constantMap.put(SchedulerProperties.SCHEDULER_INTERVAL_GET_TIMESLOT_RATE, "intervalRate");
+			constantMap.put(SchedulerProperties.SCHEDULER_GROUP_ID, "groupId");
+			try {
+				Map<String, String> map = new HashMap<>();
+				for (Map.Entry<String, String> entry : constantMap.entrySet()) {
+					if (SchedulerProperties.containsProperty(entry.getKey()))
+						map.put(entry.getValue(), SchedulerProperties.getProperty(entry.getKey()));
+					else
+						throw new Exception(entry.getKey() + errorMsg);
+				}
+				logger.debug(EELFLoggerDelegate.debugLogger, " portalRestResponse - getSchedulerConstant= {}", map);
+				portalRestResponse = new PortalRestResponse<Map<String, String>>(PortalRestStatusEnum.OK, "success",
+						map);
+
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger, "getSchedulerConstant failed", e);
+				portalRestResponse = new PortalRestResponse<Map<String, String>>(PortalRestStatusEnum.ERROR,
+						e.getMessage(), null);
 			}
-			logger.debug(EELFLoggerDelegate.debugLogger, " portalRestResponse - getSchedulerConstant= {}",
-					map);
-			portalRestResponse = new PortalRestResponse<Map<String, String>>(PortalRestStatusEnum.OK, "success", map);
-			
-		} catch (Exception e) {
-			logger.error(EELFLoggerDelegate.errorLogger, "getSchedulerConstant failed", e);
-			portalRestResponse = new PortalRestResponse<Map<String, String>>(PortalRestStatusEnum.ERROR, e.getMessage(),
-					null);
+
 		}
-		return portalRestResponse;
+        else{
+			logger.error(EELFLoggerDelegate.errorLogger, "getSchedulerConstant failed: User unauthorized to make this call");
+        	portalRestResponse = new PortalRestResponse<Map<String, String>>(PortalRestStatusEnum.ERROR, "failed : Unauthorized", null);
+        }
+				return portalRestResponse;
 	}
 
+	private String getPath(HttpServletRequest request)
+	{
+		String requestURI = request.getRequestURI();
+		String portalApiPath = "";
+		if (requestURI != null) {
+			String[] uriArray = requestURI.split("/portalApi/");
+			if (uriArray.length > 1) {
+				portalApiPath = uriArray[1];
+			}
+		}
+		return portalApiPath;
+	}
+	
+	private boolean checkIfUserISValidToMakeSchedule(HttpServletRequest request) throws Exception
+	{
+		EPUser user = EPUserUtils.getUserSession(request);
+		String portalApiPath = getPath(request);
+		Set<String> functionCodeList = adminRolesService.getAllAppsFunctionsOfUser(user.getId().toString());
+		boolean isValidUser =	EPUserUtils.matchRoleFunctions(portalApiPath, functionCodeList);
+//		boolean isValidUser = functionCodeList.stream().anyMatch(x -> functionCodeList.contains(portalApiPath));
+		return isValidUser;
+	}
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/UserRolesController.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/UserRolesController.java
index 72ae07da..97888e56 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/UserRolesController.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/controller/UserRolesController.java
@@ -285,7 +285,7 @@ public class UserRolesController extends EPRestrictedBaseController {
 	@RequestMapping(value = { "/portalApi/userAppRoles" }, method = {
 			RequestMethod.GET }, produces = "application/json")
 	public List<RoleInAppForUser> getAppRolesForUser(HttpServletRequest request, @RequestParam("user") String orgUserId,
-			@RequestParam("app") Long appid, @RequestParam("externalRequest") Boolean extRequestValue,
+			@RequestParam("app") Long appid, @RequestParam("externalRequest") Boolean extRequestValue,@RequestParam("isSystemUser") Boolean isSystemUser,
 			HttpServletResponse response) {
 		EPUser user = EPUserUtils.getUserSession(request);
 		List<RoleInAppForUser> result = null;
@@ -295,7 +295,7 @@ public class UserRolesController extends EPRestrictedBaseController {
 			EcompPortalUtils.setBadPermissions(user, response, "getAppRolesForUser");
 			feErrorString = EcompPortalUtils.getFEErrorString(true, response.getStatus());
 		} else {
-			if (EcompPortalUtils.legitimateUserId(orgUserId)) {
+			if ((!isSystemUser && EcompPortalUtils.legitimateUserId(orgUserId)) || isSystemUser) {
 				result = userRolesService.getAppRolesForUser(appid, orgUserId, extRequestValue, user);
 				logger.debug(EELFLoggerDelegate.debugLogger, "getAppRolesForUser: result {}, appId {}", result , appid);
 				int responseCode = EcompPortalUtils.getExternalAppResponseCode();
@@ -561,4 +561,16 @@ public class UserRolesController extends EPRestrictedBaseController {
 		return result;
 	}
 
+	@RequestMapping(value = { "/portalApi/checkIfUserIsSuperAdmin" }, method = RequestMethod.GET, produces = "application/json")
+	public boolean checkIfUserIsSuperAdmin(HttpServletRequest request,
+			HttpServletResponse response) {
+		EPUser user = EPUserUtils.getUserSession(request);
+		boolean isSuperAdmin = false;
+		try {
+			isSuperAdmin = adminRolesService.isSuperAdmin(user) ;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "checkIfUserIsSuperAdmin failed: " + e.getMessage());
+		}
+		return isSuperAdmin;
+	}
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/domain/EPUser.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/domain/EPUser.java
index dff5601b..a3c9c481 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/domain/EPUser.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/domain/EPUser.java
@@ -135,9 +135,11 @@ public class EPUser extends User {
 	    private boolean online;
 	    @SafeHtml
 	    private String chatId;
+	    private boolean systemUser;
 	    private Integer languageId;
 	    private static final long serialVersionUID = 1L;
 
+
 	    private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(EPUser.class);
 		private static final String ECOMP_PORTAL_NAME = "ECOMP";
 		private boolean isGuest = false;
@@ -691,6 +693,14 @@ public class EPUser extends User {
 	public void setGuest(boolean isGuest) {
 		this.isGuest = isGuest;
 	}
+	
+	public boolean isSystemUser() {
+		return systemUser;
+	}
+
+	public void setSystemUser(boolean systemUser) {
+		this.systemUser = systemUser;
+	}
 
 	@Override
 	public String toString() {
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/interceptor/PortalResourceInterceptor.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/interceptor/PortalResourceInterceptor.java
index b1439060..146050a4 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/interceptor/PortalResourceInterceptor.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/interceptor/PortalResourceInterceptor.java
@@ -154,8 +154,8 @@ public class PortalResourceInterceptor extends ResourceInterceptor {
 									SystemProperties.getProperty(SystemProperties.USER_ATTRIBUTE_NAME));
 							//RoleAdmin check is being added because the role belongs to partner application 
 							//inorder to access portal api's, bypassing this with isRoleAdmin Check
-							if ((matchRoleFunctions(portalApiPath, allRoleFunctions)
-									&& !matchRoleFunctions(portalApiPath, roleFunctions)) && !adminRolesService.isRoleAdmin(user)) {
+							if ((EPUserUtils.matchRoleFunctions(portalApiPath, allRoleFunctions)
+									&& !EPUserUtils.matchRoleFunctions(portalApiPath, roleFunctions)) && !adminRolesService.isRoleAdmin(user)) {
 								logger.error(EELFLoggerDelegate.errorLogger,
 										"preHandle: User {} not authorized for path {} ", user.getOrgUserId(),
 										portalApiPath);
@@ -296,9 +296,13 @@ public class PortalResourceInterceptor extends ResourceInterceptor {
 		}catch(ClassCastException e){
 			logger.debug(EELFLoggerDelegate.debugLogger, "Entering in the classcastexception block if the UN is not the mechid : {}");
 
-			
+			String secretKey = null;
 			// Unauthorized access due to missing HTTP Authorization request header
 			if (authHeader == null) {
+				if (remoteWebServiceCallService.verifyRESTCredential(secretKey, request.getHeader(EPCommonSystemProperties.UEB_KEY),
+						request.getHeader("username"), request.getHeader("password"))) {
+					return true;
+				}
 				final String msg = "no authorization found";
 				logger.debug(EELFLoggerDelegate.debugLogger, "checkBasicAuth: {}", msg);
 				sendErrorResponse(response, HttpServletResponse.SC_UNAUTHORIZED, msg);
@@ -396,42 +400,6 @@ public class PortalResourceInterceptor extends ResourceInterceptor {
 		return result;
 	}
 
-	private Boolean matchRoleFunctions(String portalApiPath, Set<? extends String> roleFunctions) {
-		String[] path = portalApiPath.split("/");
-		List<String> roleFunList = new ArrayList<>();
-		if (path.length > 1) {
-			roleFunList = roleFunctions.stream().filter(item -> item.startsWith(path[0])).collect(Collectors.toList());
-			if (roleFunList.size() >= 1) {
-				for (String roleFunction : roleFunList) {
-					String[] roleFunctionArray = roleFunction.split("/");
-					boolean b = true;
-					if (roleFunctionArray.length == path.length) {
-						for (int i = 0; i < roleFunctionArray.length; i++) {
-							if (b) {
-								if (!roleFunctionArray[i].equals("*")) {
-									Pattern p = Pattern.compile(Pattern.quote(path[i]), Pattern.CASE_INSENSITIVE);
-									Matcher m = p.matcher(roleFunctionArray[i]);
-									b = m.matches();
-
-								}
-							}
-						}
-							if (b)
-								return b;
-					}
-				}
-			}
-		} else {
-			for (String roleFunction : roleFunctions) {
-				if (portalApiPath.matches(roleFunction))
-					return true;
-			}
-		}
-		return false;
-	}
-	
-	
-
 	protected void handleSessionUpdates(HttpServletRequest request) {
 		PortalTimeoutHandler.handleSessionUpdatesNative(request, null, null, null, null, manageService);
 	}
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/HealthMonitor.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/HealthMonitor.java
index 891da3b7..45b5323c 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/HealthMonitor.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/HealthMonitor.java
@@ -333,7 +333,7 @@ public class HealthMonitor {
 							zkNodeStatistics.indexOf("Node"));
 					logger.info(EELFLoggerDelegate.applicationLogger,
 							"Getting Status for zookeeper :" + zookeeperNodes[i].trim() + ":------:" + state);
-					if (state.contains("leader"))
+					if (state.contains("leader") || state.contains("follower"))
 						return true;
 				}
 			} catch (Exception e) {
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/UserSessionListener.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/UserSessionListener.java
index aa97d0b3..7dbcc025 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/UserSessionListener.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/listener/UserSessionListener.java
@@ -109,7 +109,8 @@ public class UserSessionListener implements HttpSessionListener {
 
 				// Clean the shared context each time a session is destroyed.
 				// TODO: move the threshold to configuration file.
-				getSharedContextService().expireSharedContexts(60 * 60 * 8);
+				//June2019:Commented as sharedContext is no more needed.			
+//				getSharedContextService().expireSharedContexts(60 * 60 * 8);
 			}
 
 			logger.info(EELFLoggerDelegate.debugLogger, "Session Destroyed : " + session.getId());
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesService.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesService.java
index a9d55fc8..3c228dff 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesService.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesService.java
@@ -38,10 +38,12 @@
 package org.onap.portalapp.portal.service;
 
 import java.util.List;
+import java.util.Set;
 
 import org.onap.portalapp.portal.domain.EPApp;
 import org.onap.portalapp.portal.domain.EPRole;
 import org.onap.portalapp.portal.domain.EPUser;
+import org.onap.portalapp.portal.exceptions.RoleFunctionException;
 import org.onap.portalapp.portal.transport.AppsListWithAdminRole;
 
 public interface AdminRolesService {
@@ -78,4 +80,7 @@ public interface AdminRolesService {
 	List<EPRole> getRolesByApp(EPUser user, Long appId);
 	
 	public boolean isAccountAdminOfApplication(EPUser user, EPApp app);
+	public Set<String> getAllAppsFunctionsOfUser(String OrgUserId)throws RoleFunctionException;
+
+	boolean isAccountAdminOfAnyActiveorInactiveApplication(EPUser user, EPApp app);
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesServiceImpl.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesServiceImpl.java
index 7099eda5..18aac6f4 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesServiceImpl.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/AdminRolesServiceImpl.java
@@ -65,6 +65,7 @@ import org.onap.portalapp.portal.domain.EPUser;
 import org.onap.portalapp.portal.domain.EPUserApp;
 import org.onap.portalapp.portal.domain.UserIdRoleId;
 import org.onap.portalapp.portal.domain.UserRole;
+import org.onap.portalapp.portal.exceptions.RoleFunctionException;
 import org.onap.portalapp.portal.logging.aop.EPMetricsLog;
 import org.onap.portalapp.portal.logging.format.EPAppMessagesEnum;
 import org.onap.portalapp.portal.logging.logic.EPLogUtil;
@@ -77,6 +78,7 @@ import org.onap.portalapp.portal.utils.EcompPortalUtils;
 import org.onap.portalapp.portal.utils.PortalConstants;
 import org.onap.portalapp.util.EPUserUtils;
 import org.onap.portalsdk.core.domain.RoleFunction;
+import org.onap.portalsdk.core.domain.User;
 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
 import org.onap.portalsdk.core.restful.domain.EcompRole;
 import org.onap.portalsdk.core.service.DataAccessService;
@@ -168,8 +170,10 @@ public class AdminRolesServiceImpl implements AdminRolesService {
 			appsListWithAdminRole.orgUserId = orgUserId;
 			List<EPApp> appsList = null;
 			try {
-				appsList = dataAccessService.getList(EPApp.class,
-						"  where ( enabled = 'Y' or id = " + ECOMP_APP_ID + ")", null, null);
+//				appsList = dataAccessService.getList(EPApp.class,
+//						null, null, null);
+				
+				appsList = dataAccessService.getList(EPApp.class, null);
 			} catch (Exception e) {
 				logger.error(EELFLoggerDelegate.errorLogger, "getAppsWithAdminRoleStateForUser 2 failed", e);
 				EPLogUtil.logEcompError(EPAppMessagesEnum.BeDaoSystemError);
@@ -202,9 +206,9 @@ public class AdminRolesServiceImpl implements AdminRolesService {
 				List<EPApp> apps = appsService.getAppsFullList();
 				HashMap<Long, EPApp> enabledApps = new HashMap<Long, EPApp>();
 				for (EPApp app : apps) {
-					if (app.getEnabled().booleanValue() || app.getId() == ECOMP_APP_ID) {
+//					if (app.getEnabled().booleanValue() || app.getId() == ECOMP_APP_ID) {
 						enabledApps.put(app.getId(), app);
-					}
+//					}
 				}
 				List<AppNameIdIsAdmin> newAppsWhereUserIsAdmin = new ArrayList<AppNameIdIsAdmin>();
 				for (AppNameIdIsAdmin adminRole : newAppsListWithAdminRoles.appsRoles) {
@@ -499,18 +503,13 @@ public class AdminRolesServiceImpl implements AdminRolesService {
 							String type = externalAccessRolesService.getFunctionCodeType(roleFunction);
 							getRoleFuncListOfPortalSet1.add(type);
 						}
+				
+					boolean checkIfFunctionsExits = getRoleFuncListOfPortalSet1.stream()
+							.anyMatch(roleFunction -> roleFunction.equalsIgnoreCase("Approver"));
+					logger.debug(EELFLoggerDelegate.debugLogger, "Checking if user has approver rolefunction" , checkIfFunctionsExits);
 
-					for (String rolefunc : getRoleFuncListOfPortalSet1) {
-						logger.debug(EELFLoggerDelegate.debugLogger, "Checking if user has approver rolefunction" , rolefunc);
-				        if (rolefunc.equalsIgnoreCase(TYPE_APPROVER)) {
-							logger.debug(EELFLoggerDelegate.debugLogger, "Checking if user has approver rolefunction" , rolefunc);
-				            return true;
-				        }else{
-						       return false;
-
-				        }
-				    }
-
+					return checkIfFunctionsExits;
+		
 		} catch (Exception e) {
 			EPLogUtil.logEcompError(logger, EPAppMessagesEnum.BeDaoSystemError, e);
 			logger.error(EELFLoggerDelegate.errorLogger, "Exception occurred while executing isRoleAdmin operation",
@@ -578,4 +577,52 @@ public class AdminRolesServiceImpl implements AdminRolesService {
 		return isApplicationAccountAdmin;
 
 	}
+
+	@Override
+	public Set<String> getAllAppsFunctionsOfUser(String OrgUserId) throws RoleFunctionException {
+		final Map<String, String> params = new HashMap<>();
+		params.put("userId", OrgUserId);
+		List getRoleFuncListOfPortal = dataAccessService.executeNamedQuery("getAllAppsFunctionsOfUser", params, null);
+		Set<String> getRoleFuncListOfPortalSet = new HashSet<>(getRoleFuncListOfPortal);
+		Set<String> roleFunSet = new HashSet<>();
+		roleFunSet = getRoleFuncListOfPortalSet.stream().filter(x -> x.contains("|")).collect(Collectors.toSet());
+		if (roleFunSet.size() > 0)
+			for (String roleFunction : roleFunSet) {
+				String roleFun = EcompPortalUtils.getFunctionCode(roleFunction);
+				getRoleFuncListOfPortalSet.remove(roleFunction);
+				getRoleFuncListOfPortalSet.add(roleFun);
+			}
+
+		Set<String> finalRoleFunctionSet = new HashSet<>();
+		for (String roleFn : getRoleFuncListOfPortalSet) {
+			finalRoleFunctionSet.add(EPUserUtils.decodeFunctionCode(roleFn));
+		}
+		
+//		List<String> functionsOfUser = new ArrayList<>(getRoleFuncListOfPortal);
+		return finalRoleFunctionSet;
+	}
+
+	
+	@Override
+	public boolean isAccountAdminOfAnyActiveorInactiveApplication(EPUser user, EPApp app) {
+		Boolean isApplicationAccountAdmin=false;
+		try {
+					final Map<String, Long> userParams = new HashMap<>();
+					userParams.put("userId", user.getId());	
+					logger.debug(EELFLoggerDelegate.debugLogger, "Is account admin for user {}", user.getId());
+					List<Integer> userAdminApps = new ArrayList<>();
+					userAdminApps =dataAccessService.executeNamedQuery("getAllAdminAppsofTheUser", userParams, null);
+					if(userAdminApps.size()>=1){
+					isApplicationAccountAdmin=userAdminApps.contains((int) (long) app.getId());
+					logger.debug(EELFLoggerDelegate.debugLogger, "Is account admin for user is true{} ,appId {}", user.getId(),app.getId());
+					}					
+			} catch (Exception e) {
+			EPLogUtil.logEcompError(logger, EPAppMessagesEnum.BeDaoSystemError, e);
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"Exception occurred while executing isAccountAdminOfApplication operation", e);
+		}
+		logger.debug(EELFLoggerDelegate.debugLogger, "In AdminRolesServiceImpl() - isAccountAdminOfApplication = {} and userId ={} ", isApplicationAccountAdmin, user.getOrgUserId());
+		return isApplicationAccountAdmin;
+
+	}
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppCommonServiceImpl.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppCommonServiceImpl.java
index bbb83827..c3cc2864 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppCommonServiceImpl.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppCommonServiceImpl.java
@@ -50,6 +50,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import javax.annotation.PostConstruct;
 import javax.servlet.http.HttpServletResponse;
@@ -60,6 +61,8 @@ import org.hibernate.SessionFactory;
 import org.hibernate.Transaction;
 import org.hibernate.criterion.Criterion;
 import org.hibernate.criterion.Restrictions;
+import org.json.JSONArray;
+import org.json.JSONObject;
 import org.onap.portalapp.portal.domain.AdminUserApp;
 import org.onap.portalapp.portal.domain.AdminUserApplications;
 import org.onap.portalapp.portal.domain.AppIdAndNameTransportModel;
@@ -96,6 +99,13 @@ import org.onap.portalsdk.core.onboarding.util.PortalApiProperties;
 import org.onap.portalsdk.core.service.DataAccessService;
 import org.onap.portalsdk.core.util.SystemProperties;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpClientErrorException;
+import org.springframework.web.client.RestTemplate;
 
 import com.att.nsa.apiClient.http.HttpException;
 import com.att.nsa.cambria.client.CambriaClient.CambriaApiException;
@@ -110,7 +120,9 @@ public class EPAppCommonServiceImpl implements EPAppService {
 	protected String ACCOUNT_ADMIN_ROLE_ID = "999";
 	protected String RESTRICTED_APP_ROLE_ID = "900";
 
-	private static final String urlField = "url";
+	//private static final String urlField = "url";
+	private static final String nameSpaceField = "url";
+
 	private static final String nameField = "name";
 
 	private EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(EPAppCommonServiceImpl.class);
@@ -121,6 +133,8 @@ public class EPAppCommonServiceImpl implements EPAppService {
 	protected SessionFactory sessionFactory;
 	@Autowired
 	private DataAccessService dataAccessService;	
+	
+	RestTemplate template = new RestTemplate();
 
 	@PostConstruct
 	private void init() {
@@ -129,6 +143,65 @@ public class EPAppCommonServiceImpl implements EPAppService {
 		ECOMP_APP_ID = SystemProperties.getProperty(EPCommonSystemProperties.ECOMP_APP_ID);
 		RESTRICTED_APP_ROLE_ID = SystemProperties.getProperty(EPCommonSystemProperties.RESTRICTED_APP_ROLE_ID);
 	}
+	
+	public Boolean onboardingAppFieldsValidation(OnboardingApp onboardingApp) {
+		//FieldsValidator fieldsValidator = new FieldsValidator();
+
+		if ((!onboardingApp.restrictedApp) &&( onboardingApp.name == null || onboardingApp.name.length() == 0 || onboardingApp.restrictedApp == null
+				|| onboardingApp.url == null || onboardingApp.url.length() == 0 || onboardingApp.restUrl == null || onboardingApp.restUrl.length() == 0
+			    || onboardingApp.username == null || onboardingApp.username.length() == 0
+				|| onboardingApp.isOpen == null
+				|| (onboardingApp.id != null && onboardingApp.id.equals(ECOMP_APP_ID)))
+				// For a normal app (appType == PortalConstants.PortalAppId),
+				// these fields must be filled
+				// in.
+				// For a restricted app (appType==2), they will be empty.
+				|| ((onboardingApp.restrictedApp) && (onboardingApp.name == null || onboardingApp.name.length() == 0
+						|| onboardingApp.url == null || onboardingApp.url.length() == 0 || onboardingApp.isOpen == null))) {
+			return false;
+		}
+		return true;
+		
+	}
+	
+	private Boolean onboardingInactiveAppFieldsForValidation(OnboardingApp onboardingApp) {
+		if (onboardingApp.name == null || onboardingApp.name.length() == 0
+				|| onboardingApp.isOpen == null) {
+			return false;
+		}
+		return true;
+	}
+
+	protected FieldsValidator onboardingAppFieldsChecker(OnboardingApp onboardingApp) {
+		FieldsValidator fieldsValidator = new FieldsValidator();
+		if (onboardingApp.isCentralAuth) {
+			if (!onboardingApp.isEnabled) {
+				if (!onboardingInactiveAppFieldsForValidation(onboardingApp)) {
+					fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+				}
+			} else if (onboardingApp.isEnabled) {
+				if (onboardingAppFieldsValidation(onboardingApp) == false || onboardingApp.nameSpace == null
+						|| onboardingApp.nameSpace.length() == 0) {
+					fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+				}
+			}
+		} else {
+			if (!onboardingApp.isEnabled) {
+				if (!onboardingInactiveAppFieldsForValidation(onboardingApp)) {
+					fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+				}
+			} else if (onboardingApp.isEnabled) {
+				if(onboardingApp.restrictedApp && onboardingAppFieldsValidation(onboardingApp) == false){
+					fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+				}
+				else if (!onboardingApp.restrictedApp && (onboardingAppFieldsValidation(onboardingApp) == false || onboardingApp.appPassword == null
+						|| onboardingApp.appPassword.length() == 0)) {
+					fieldsValidator.httpStatusCode = new Long(HttpServletResponse.SC_BAD_REQUEST);
+				}
+			}
+		}
+		return fieldsValidator;
+	}
 
 	@Override
 	public List<EPApp> getUserAsAdminApps(EPUser user) {
@@ -406,6 +479,23 @@ public class EPAppCommonServiceImpl implements EPAppService {
 		return appsModified;
 	}
 
+	
+	@Override
+	public List<AppsResponse> getAllApplications(Boolean all) {
+		// If all is true, return both active and inactive apps. Otherwise, just
+		// active apps.
+		@SuppressWarnings("unchecked")
+		// Sort the list by application name so the drop-down looks pretty.
+		List<EPApp> apps = all
+				? (List<EPApp>) dataAccessService.getList(EPApp.class, " where id != " + ECOMP_APP_ID, "name", null)
+						:dataAccessService.getList(EPApp.class, null);
+
+		List<AppsResponse> appsModified = new ArrayList<AppsResponse>();
+		for (EPApp app : apps) {
+			appsModified.add(new AppsResponse(app.getId(), app.getName(), app.isRestrictedApp(), app.getEnabled()));
+		}
+		return appsModified;
+	}
 	@Override
 	public UserRoles getUserProfile(String loginId) {
 		final Map<String, String> params = new HashMap<>();
@@ -488,7 +578,7 @@ public class EPAppCommonServiceImpl implements EPAppService {
 		return query.toString();
 	}
 
-	protected FieldsValidator onboardingAppFieldsChecker(OnboardingApp onboardingApp) {
+	/*protected FieldsValidator onboardingAppFieldsChecker(OnboardingApp onboardingApp) {
 		FieldsValidator fieldsValidator = new FieldsValidator();
 		if(onboardingApp.isCentralAuth){
 		if (onboardingApp.name == null || onboardingApp.name.length() == 0 || onboardingApp.url == null
@@ -526,7 +616,7 @@ public class EPAppCommonServiceImpl implements EPAppService {
 			
 		}
 		return fieldsValidator;
-	}
+	}*/
 
 	@Override
 	public List<EPApp> getUserApps(EPUser user) {
@@ -739,6 +829,27 @@ public class EPAppCommonServiceImpl implements EPAppService {
 		}
 		return onboardingAppsList;
 	}
+	
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<OnboardingApp> getAdminAppsOfUser(EPUser user) {
+		
+		List<OnboardingApp> onboardingAppsList = new ArrayList<OnboardingApp>();
+		List<Integer> userAdminApps = new ArrayList<>();
+		final Map<String, Long> userParams = new HashMap<>();
+		userParams.put("userId", user.getId());	
+		userAdminApps =  dataAccessService.executeNamedQuery("getAllAdminAppsofTheUser", userParams, null);
+		
+//		userAdminApps.removeIf(x -> x == Integer.valueOf(ECOMP_APP_ID));
+		
+		logger.debug(EELFLoggerDelegate.debugLogger, "Is account admin for userAdminApps() - for user {}, found userAdminAppsSize {}", user.getOrgUserId(), userAdminApps.size());
+		onboardingAppsList = getOnboardingApps();
+		
+		final List<Integer> userAdminApps1 = userAdminApps;
+		List<OnboardingApp> userApplicationAdmins = onboardingAppsList.stream().filter(x -> userAdminApps1.contains((int) (long)x.id)).collect(Collectors.toList());
+		
+        return userApplicationAdmins;
+	}
 
 	@Override
 	public List<OnboardingApp> getEnabledNonOpenOnboardingApps() {
@@ -757,25 +868,33 @@ public class EPAppCommonServiceImpl implements EPAppService {
 
 	@SuppressWarnings("unchecked")
 	private void validateOnboardingApp(OnboardingApp onboardingApp, FieldsValidator fieldsValidator) {
-		boolean duplicatedUrl = false;
+		boolean duplicatedNameSpace = false;
 		boolean duplicatedName = false;
 		List<EPApp> apps;
 		if (onboardingApp.id == null) {
 			List<Criterion> restrictionsList = new ArrayList<Criterion>();
-			Criterion urlCrit =Restrictions.eq("url", onboardingApp.url);
-			Criterion nameCrit = Restrictions.eq("name",onboardingApp.name);			
-			Criterion orCrit = Restrictions.or(urlCrit, nameCrit);
-			
+			Criterion nameCrit = Restrictions.eq("name",onboardingApp.name);
+			Criterion nameSpaceCrit = null;
+			Criterion	orCrit = null;
+			if (onboardingApp.isCentralAuth) {
+				nameSpaceCrit = Restrictions.eq("nameSpace", onboardingApp.nameSpace);
+				orCrit = Restrictions.or(nameCrit, nameSpaceCrit);
+			} else
+				orCrit = Restrictions.or(nameCrit);
 			restrictionsList.add(orCrit);
 			apps = (List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null);
-			
-			
 		} else {
 			List<Criterion> restrictionsList = new ArrayList<Criterion>();
 			Criterion idCrit =Restrictions.eq("id", onboardingApp.id);
-			Criterion urlCrit =Restrictions.eq("url", onboardingApp.url);
-			Criterion nameCrit = Restrictions.eq("name",onboardingApp.name);			
-			Criterion orCrit = Restrictions.or(idCrit, urlCrit, nameCrit);
+			Criterion nameCrit = Restrictions.eq("name",onboardingApp.name);
+			Criterion nameSpaceCrit = null;
+			Criterion orCrit= null;
+			if (onboardingApp.isCentralAuth) {
+				nameSpaceCrit = Restrictions.eq("nameSpace",onboardingApp.nameSpace);
+				orCrit = Restrictions.or(idCrit, nameSpaceCrit, nameCrit);
+			}
+			else
+			 orCrit = Restrictions.or(idCrit, nameCrit);
 			
 			restrictionsList.add(orCrit);
 			apps = (List<EPApp>) dataAccessService.getList(EPApp.class, null, restrictionsList, null);
@@ -785,22 +904,23 @@ public class EPAppCommonServiceImpl implements EPAppService {
 			if (onboardingApp.id != null && onboardingApp.id.equals(app.getId())) {
 				continue;
 			}
-			if (!duplicatedUrl && app.getUrl().equalsIgnoreCase(onboardingApp.url)) {
-				duplicatedUrl = true;
+			if (!duplicatedName && app.getName().equalsIgnoreCase(onboardingApp.name)) {
+				duplicatedName = true;
 				if (duplicatedName) {
 					break;
 				}
 			}
-			if (!duplicatedName && app.getName().equalsIgnoreCase(onboardingApp.name)) {
-				duplicatedName = true;
-				if (duplicatedUrl) {
+			if (!duplicatedNameSpace && app.getNameSpace().equalsIgnoreCase(onboardingApp.nameSpace)) {
+				duplicatedNameSpace = true;
+				if (duplicatedNameSpace) {
 					break;
 				}
 			}
+			
 		}
-		if (duplicatedUrl || duplicatedName) {
-			if (duplicatedUrl) {
-				fieldsValidator.addProblematicFieldName(urlField);
+		if (duplicatedNameSpace || duplicatedName) {
+			if (duplicatedNameSpace) {
+				fieldsValidator.addProblematicFieldName(nameSpaceField);
 			}
 			if (duplicatedName) {
 				fieldsValidator.addProblematicFieldName(nameField);
@@ -1801,4 +1921,57 @@ public class EPAppCommonServiceImpl implements EPAppService {
 		return userAndRoles;
 		
 	}
+
+	@SuppressWarnings("unused")
+	@Override
+	public ResponseEntity<String> checkIfNameSpaceIsValid(String namespace) throws Exception {
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists: Connecting to External Auth system for : "+namespace);
+		ResponseEntity<String> response = null;
+		try {
+			response = template
+					.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+							+ "nss/" + namespace, HttpMethod.GET, entity, String.class);
+			logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists for"+ namespace ,
+					response.getStatusCode().value());
+			if (response.getStatusCode().value() == 200) {
+				String res = response.getBody();
+				JSONObject jsonObj = new JSONObject(res);
+				JSONArray namespaceArray = jsonObj.getJSONArray("ns");
+				if(!namespaceArray.getJSONObject(0).has("admin")){
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"No admins are available for requested namespace:" + namespace);		
+					throw new HttpClientErrorException(HttpStatus.UNAUTHORIZED,
+							"Portal Mechid is not an admin of" + namespace);
+				}
+				
+				JSONArray namespaceAdminArray = namespaceArray.getJSONObject(0).getJSONArray("admin");
+				ArrayList<String> list = new ArrayList<String>();
+				if (namespaceAdminArray != null) {
+					int len = namespaceAdminArray.length();
+					for (int i = 0; i < len; i++) {
+						list.add(namespaceAdminArray.get(i).toString());
+					}
+				}
+				logger.debug(EELFLoggerDelegate.debugLogger, "List of Admins of requested namespace" + list);
+				final String userName = SystemProperties
+						.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_AUTH_USER_NAME);
+				boolean idExists = list.stream().anyMatch(t -> userName.equals(t));
+				if (false) {
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"Portal mechid is not admin of requested namespace:" + namespace);
+					throw new HttpClientErrorException(HttpStatus.UNAUTHORIZED,
+							"Portal Mechid is not an admin of" + namespace);
+				}
+			}
+			
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "checkIfNameSpaceExists failed", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+				throw e;
+		}
+		return response;
+
+	}
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppService.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppService.java
index b314adec..6838ae4a 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppService.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/EPAppService.java
@@ -54,6 +54,7 @@ import org.onap.portalapp.portal.transport.EPWidgetsSortPreference;
 import org.onap.portalapp.portal.transport.FieldsValidator;
 import org.onap.portalapp.portal.transport.LocalRole;
 import org.onap.portalapp.portal.transport.OnboardingApp;
+import org.springframework.http.ResponseEntity;
 
 public interface EPAppService {
 
@@ -244,5 +245,10 @@ public interface EPAppService {
 	UserRoles getUserProfileForRolesLeftMenu(String loginId);
 
 	UserRoles getUserProfileNormalizedForRolesLeftMenu(EPUser user);
+	public List<OnboardingApp> getAdminAppsOfUser(EPUser user);
+	
+	public ResponseEntity<String> checkIfNameSpaceIsValid(String namespace) throws Exception ;
+
+	List<AppsResponse> getAllApplications(Boolean all);
 
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesService.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesService.java
index ee960c40..d064545d 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesService.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesService.java
@@ -416,13 +416,6 @@ public interface ExternalAccessRolesService {
 	public JSONArray getAppRolesJSONFromExtAuthSystem(EPApp app) throws Exception;
 	
 	/**
-	 * It encodes the function code  based on Hex encoding
-	 * @param funCode
-	 * 
-	 */
-	public String encodeFunctionCode(String funCode);
-	
-	/**
 	 * 
 	 * It returns list of ExternalRoleDetails which is converted from JSON array of roles
 	 * 
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImpl.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImpl.java
index 7bb9995b..786ad429 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImpl.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/ExternalAccessRolesServiceImpl.java
@@ -47,11 +47,9 @@ import java.util.Map;
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
-import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
 import org.apache.commons.codec.DecoderException;
-import org.apache.commons.codec.binary.Hex;
 import org.hibernate.Query;
 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
@@ -113,3742 +111,3682 @@ import com.fasterxml.jackson.databind.type.TypeFactory;
 @EPMetricsLog
 @EPAuditLog
 public class ExternalAccessRolesServiceImpl implements ExternalAccessRolesService {
-    private static final String APP_ROLE_NAME_PARAM = "appRoleName";
-    private static final String GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM = "getRoletoUpdateInExternalAuthSystem";
-    private static final String GET_PORTAL_APP_ROLES_QUERY = "getPortalAppRoles";
-    private static final String GET_ROLE_FUNCTION_QUERY = "getRoleFunction";
-    private static final String FUNCTION_CODE_PARAMS = "functionCode";
-    private static final String AND_FUNCTION_CD_EQUALS = " and function_cd = '";
-    private static final String OWNER = ".owner";
-    private static final String ADMIN = ".admin";
-    private static final String ACCOUNT_ADMINISTRATOR = ".Account_Administrator";
-    private static final String FUNCTION_PIPE = "|";
-    private static final String EXTERNAL_AUTH_PERMS = "perms";
-    private static final String EXTERNAL_AUTH_ROLE_DESCRIPTION = "description";
-    private static final String IS_EMPTY_JSON_STRING = "{}";
-    private static final String CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE = "Connecting to External Auth system";
-    private static final String APP_ID = "appId";
-    private static final String ROLE_NAME = "name";
-    private static final String APP_ID_EQUALS = " app_id = ";
-    private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesServiceImpl.class);
-    @Autowired
-    private DataAccessService dataAccessService;
-    @Autowired
-    private EPAppService epAppService;
-    @Autowired
-    private SessionFactory sessionFactory;
-    @Autowired
-    EPRoleService ePRoleService;
-    RestTemplate template = new RestTemplate();
-    // These decode values are based on HexDecoder
-    static final String decodeValueOfForwardSlash = "2f";
-    static final String decodeValueOfHiphen = "2d";
-    static final String decodeValueOfStar = "2a";
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<EPRole> getAppRoles(Long appId) throws Exception {
-        List<EPRole> applicationRoles = null;
-        final Map<String, Long> appParams = new HashMap<>();
-        try {
-            if (appId == 1) {
-                applicationRoles = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
-            } else {
-                appParams.put("appId", appId);
-                applicationRoles = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getAppRoles: failed", e);
-            throw e;
-        }
-        return applicationRoles;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<EPApp> getApp(String uebkey) throws Exception {
-        List<EPApp> app = null;
-        try {
-            final Map<String, String> appUebkeyParams = new HashMap<>();
-            appUebkeyParams.put("appKey", uebkey);
-            app = dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null);
-            if (!app.isEmpty() && !app.get(0).getEnabled()
-                    && !app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                throw new InactiveApplicationException("Application:" + app.get(0).getName() + " is Unavailable");
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getApp: failed", e);
-            throw e;
-        }
-        return app;
-    }
-
-    /**
-     * It returns single application role from external auth system
-     * 
-     * @param addRole
-     * @param app
-     * @return JSON string which contains application role details
-     * @throws Exception
-     */
-    private String getSingleAppRole(String addRole, EPApp app) throws Exception {
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        ResponseEntity<String> response = null;
-        logger.debug(EELFLoggerDelegate.debugLogger, "getSingleAppRole: Connecting to External Auth system");
-        response = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "roles/"
-                        + app.getNameSpace() + "." + addRole
-                                .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                HttpMethod.GET, entity, String.class);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "getSingleAppRole: Finished GET app role from External Auth system and status code: {} ",
-                response.getStatusCode().value());
-        return response.getBody();
-    }
-
-    @Override
-    public boolean addRole(Role addRole, String uebkey) throws Exception {
-        boolean response = false;
-        ResponseEntity<String> addResponse = null;
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        EPApp app = getApp(uebkey).get(0);
-        String newRole = updateExistingRoleInExternalSystem(addRole, app);
-        HttpEntity<String> entity = new HttpEntity<>(newRole, headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "addRole: Connecting to External Auth system");
-        addResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
-                HttpMethod.POST, entity, String.class);
-        if (addResponse.getStatusCode().value() == 201) {
-            response = true;
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "addRole: Finished adding role in the External Auth system  and response code: {} ",
-                    addResponse.getStatusCode().value());
-        }
-        if (addResponse.getStatusCode().value() == 406) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "addRole: Failed to add in the External Auth system due to {} and status code: {}",
-                    addResponse.getBody(), addResponse.getStatusCode().value());
-        }
-        return response;
-    }
-
-    /**
-     * 
-     * It deletes record in external auth system
-     * 
-     * @param delRole
-     * @return JSON String which has status code and response body
-     * @throws Exception
-     */
-    private ResponseEntity<String> deleteRoleInExternalSystem(String delRole) throws Exception {
-        ResponseEntity<String> delResponse = null;
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(delRole, headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleInExternalSystem: {} for DELETE: {}",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, delRole);
-        delResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role?force=true",
-                HttpMethod.DELETE, entity, String.class);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "deleteRoleInExternalSystem: Finished DELETE operation in the External Auth system {} and status code: {} ",
-                delRole, delResponse.getStatusCode().value());
-        return delResponse;
-    }
-
-    /**
-     * It updates role in external auth system
-     * 
-     * @param updateExtRole
-     * @param app
-     * @return true if success else false
-     * @throws Exception If updateRoleInExternalSystem fails we catch it in logger for detail message
-     */
-    private boolean updateRoleInExternalSystem(Role updateExtRole, EPApp app, boolean isGlobalRole) throws Exception {
-        boolean response = false;
-        ObjectMapper mapper = new ObjectMapper();
-        ResponseEntity<String> deleteResponse = null;
-        List<EPRole> epRoleList = null;
-        if (app.getId().equals(PortalConstants.PORTAL_APP_ID)
-                || (isGlobalRole && !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
-            epRoleList = getPortalAppRoleInfo(updateExtRole.getId());
-        } else {
-            epRoleList = getPartnerAppRoleInfo(updateExtRole.getId(), app);
-        }
-        // Assigning functions to global role
-        if ((isGlobalRole && !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
-            List<RoleFunction> globalRoleFunctionListNew = convertSetToListOfRoleFunctions(updateExtRole);
-            EPApp portalAppInfo = epAppService.getApp(PortalConstants.PORTAL_APP_ID);
-            addFunctionsTOGlobalRole(epRoleList, updateExtRole, globalRoleFunctionListNew, mapper, app, portalAppInfo);
-            response = true;
-        } else {
-            String appRole = getSingleAppRole(epRoleList.get(0).getName(), app);
-            List<RoleFunction> roleFunctionListNew = convertSetToListOfRoleFunctions(updateExtRole);
-            if (!appRole.equals(IS_EMPTY_JSON_STRING)) {
-                JSONObject jsonObj = new JSONObject(appRole);
-                JSONArray extRole = jsonObj.getJSONArray("role");
-                if (!extRole.getJSONObject(0).has(EXTERNAL_AUTH_ROLE_DESCRIPTION)) {
-                    String roleName = extRole.getJSONObject(0).getString(ROLE_NAME);
-                    Map<String, String> delRoleKeyMapper = new HashMap<>();
-                    delRoleKeyMapper.put(ROLE_NAME, roleName);
-                    String delRoleKeyValue = mapper.writeValueAsString(delRoleKeyMapper);
-                    deleteResponse = deleteRoleInExternalSystem(delRoleKeyValue);
-                    if (deleteResponse.getStatusCode().value() != 200) {
-                        throw new ExternalAuthSystemException(deleteResponse.getBody());
-                    }
-                    addRole(updateExtRole, app.getUebKey());
-                } else {
-                    String desc = extRole.getJSONObject(0).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
-                    String name = extRole.getJSONObject(0).getString(ROLE_NAME);
-                    List<ExternalAccessPerms> list = new ArrayList<>();
-                    if (extRole.getJSONObject(0).has(EXTERNAL_AUTH_PERMS)) {
-                        JSONArray perms = extRole.getJSONObject(0).getJSONArray(EXTERNAL_AUTH_PERMS);
-                        list = mapper.readValue(perms.toString(), TypeFactory.defaultInstance()
-                                .constructCollectionType(List.class, ExternalAccessPerms.class));
-                    }
-                    // If role name or role functions are updated then delete
-                    // record in External System and add new record to avoid
-                    // conflicts
-                    boolean isRoleNameChanged = false;
-                    if (!desc.equals(updateExtRole.getName())) {
-                        isRoleNameChanged = true;
-                        deleteRoleInExtSystem(mapper, name);
-                        addRole(updateExtRole, app.getUebKey());
-                        // add partner functions to the global role in External
-                        // Auth System
-                        if (!list.isEmpty() && isGlobalRole) {
-                            addPartnerHasRoleFunctionsToGlobalRole(list, mapper, app, updateExtRole);
-                        }
-                        list.removeIf(
-                                perm -> EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace()));
-                        // if role name is changes please ignore the previous
-                        // functions in External Auth
-                        // and update with user requested functions
-                        addRemoveFunctionsToRole(updateExtRole, app, mapper, roleFunctionListNew, name, list);
-                    }
-                    // Delete role in External System if role is inactive
-                    if (!updateExtRole.getActive()) {
-                        deleteRoleInExtSystem(mapper, name);
-                    }
-                    if (!isRoleNameChanged) {
-                        response =
-                                addRemoveFunctionsToRole(updateExtRole, app, mapper, roleFunctionListNew, name, list);
-                    }
-                }
-            } else {
-                // It seems like role exists in local DB but not in External
-                // Access system
-                if (updateExtRole.getActive()) {
-                    addRole(updateExtRole, app.getUebKey());
-                    ExternalAccessRolePerms extAddRolePerms = null;
-                    ExternalAccessPerms extAddPerms = null;
-                    List<RoleFunction> roleFunctionListAdd = convertSetToListOfRoleFunctions(updateExtRole);
-                    HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-                    for (RoleFunction roleFunc : roleFunctionListAdd) {
-                        extAddPerms = new ExternalAccessPerms(app.getNameSpace() + "." + roleFunc.getType(),
-                                roleFunc.getCode(), roleFunc.getAction());
-                        extAddRolePerms =
-                                new ExternalAccessRolePerms(extAddPerms,
-                                        app.getNameSpace() + "." + updateExtRole.getName().replaceAll(
-                                                EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS,
-                                                "_"));
-                        response = addRoleFuncExtSysRestAPI(mapper, extAddRolePerms, headers);
-                    }
-                }
-            }
-        }
-        return response;
-    }
-
-    private void deleteRoleInExtSystem(ObjectMapper mapper, String name)
-            throws JsonProcessingException, Exception, ExternalAuthSystemException {
-        ResponseEntity<String> deleteResponse;
-        Map<String, String> delRoleKeyMapper = new HashMap<>();
-        delRoleKeyMapper.put(ROLE_NAME, name);
-        String delRoleKeyValue = mapper.writeValueAsString(delRoleKeyMapper);
-        deleteResponse = deleteRoleInExternalSystem(delRoleKeyValue);
-        if (deleteResponse.getStatusCode().value() != 200) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "updateRoleInExternalSystem:  Failed to delete role in external system due to {} ",
-                    deleteResponse.getBody());
-            throw new ExternalAuthSystemException(deleteResponse.getBody());
-        }
-    }
-
-    private boolean addRemoveFunctionsToRole(Role updateExtRole, EPApp app, ObjectMapper mapper,
-            List<RoleFunction> roleFunctionListNew, String name, List<ExternalAccessPerms> list) throws Exception {
-        boolean response;
-        Map<String, RoleFunction> updateRoleFunc = new HashMap<>();
-        for (RoleFunction addPerm : roleFunctionListNew) {
-            updateRoleFunc.put(addPerm.getCode(), addPerm);
-        }
-        final Map<String, ExternalAccessPerms> extRolePermMap = new HashMap<>();
-        final Map<String, ExternalAccessPerms> extRolePermMapPipes = new HashMap<>();
-        list.removeIf(perm -> !EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace()));
-        // Update permissions in the ExternalAccess System
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        if (!list.isEmpty()) {
-            for (ExternalAccessPerms perm : list) {
-                RoleFunction roleFunc = updateRoleFunc.get(perm.getType().substring(app.getNameSpace().length() + 1)
-                        + FUNCTION_PIPE + perm.getInstance() + FUNCTION_PIPE + perm.getAction());
-                if (roleFunc == null) {
-                    RoleFunction roleFuncPipeFilter = updateRoleFunc.get(perm.getInstance());
-                    if (roleFuncPipeFilter == null)
-                        removePermForRole(perm, mapper, name, headers);
-                }
-                extRolePermMap.put(perm.getInstance(), perm);
-                extRolePermMapPipes.put(perm.getType().substring(app.getNameSpace().length() + 1) + FUNCTION_PIPE
-                        + perm.getInstance() + FUNCTION_PIPE + perm.getAction(), perm);
-            }
-        }
-        response = true;
-        if (!roleFunctionListNew.isEmpty()) {
-            for (RoleFunction roleFunc : roleFunctionListNew) {
-                if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
-                    ExternalAccessPerms perm = extRolePermMapPipes.get(roleFunc.getCode());
-                    if (perm == null) {
-                        response =
-                                addFunctionsToRoleInExternalAuthSystem(updateExtRole, app, mapper, headers, roleFunc);
-                    }
-                } else {
-                    if (!extRolePermMap.containsKey(EcompPortalUtils.getFunctionCode(roleFunc.getCode()))) {
-                        response =
-                                addFunctionsToRoleInExternalAuthSystem(updateExtRole, app, mapper, headers, roleFunc);
-                    }
-                }
-            }
-        }
-        return response;
-    }
-
-    /*
-     * Adds function to the role in the external auth system while editing a role or updating new
-     * functions to a role
-     *
-     */
-    private boolean addFunctionsToRoleInExternalAuthSystem(Role updateExtRole, EPApp app, ObjectMapper mapper,
-            HttpHeaders headers, RoleFunction roleFunc) throws JsonProcessingException {
-        boolean response;
-        ExternalAccessRolePerms extRolePerms;
-        ExternalAccessPerms extPerms;
-        String code = "";
-        String type = "";
-        String action = "";
-        if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
-            code = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-            type = EcompPortalUtils.getFunctionType(roleFunc.getCode());
-            action = getFunctionCodeAction(roleFunc.getCode());
-        } else {
-            code = roleFunc.getCode();
-            type = roleFunc.getCode().contains("menu") ? "menu" : "url";
-            action = "*";
-        }
-        extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, code, action);
-        extRolePerms = new ExternalAccessRolePerms(extPerms, app.getNameSpace() + "." + updateExtRole.getName()
-                .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-        String updateRolePerms = mapper.writeValueAsString(extRolePerms);
-        HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "updateRoleInExternalSystem: {} for POST: {}",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
-        ResponseEntity<String> addResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
-                HttpMethod.POST, entity, String.class);
-        if (addResponse.getStatusCode().value() != 201 && addResponse.getStatusCode().value() != 409) {
-            response = false;
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "updateRoleInExternalSystem: Connected to External Auth system but something went wrong! due to {} and statuscode: {}",
-                    addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
-        } else {
-            response = true;
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "updateRoleInExternalSystem: Finished adding permissions to roles in External Auth system {} and status code: {} ",
-                    updateRolePerms, addResponse.getStatusCode().value());
-        }
-        return response;
-    }
-
-    private void addPartnerHasRoleFunctionsToGlobalRole(List<ExternalAccessPerms> permslist, ObjectMapper mapper,
-            EPApp app, Role updateExtRole) throws Exception {
-        for (ExternalAccessPerms perm : permslist) {
-            if (!EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace())) {
-                ExternalAccessRolePerms extAddGlobalRolePerms = null;
-                ExternalAccessPerms extAddPerms = null;
-                extAddPerms = new ExternalAccessPerms(perm.getType(), perm.getInstance(), perm.getAction());
-                extAddGlobalRolePerms = new ExternalAccessRolePerms(extAddPerms,
-                        app.getNameSpace() + "." + updateExtRole.getName().replaceAll(
-                                EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-                String addPerms = mapper.writeValueAsString(extAddGlobalRolePerms);
-                HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-                HttpEntity<String> entity = new HttpEntity<>(addPerms, headers);
-                logger.debug(EELFLoggerDelegate.debugLogger, "addPartnerHasRoleFunctionsToGlobalRole: {} ",
-                        CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-                try {
-                    ResponseEntity<String> addResponse = template
-                            .exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                                    + "role/perm", HttpMethod.POST, entity, String.class);
-                    if (addResponse.getStatusCode().value() != 201) {
-                        logger.debug(EELFLoggerDelegate.debugLogger,
-                                "addPartnerHasRoleFunctionsToGlobalRole: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
-                                addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
-                    } else {
-                        logger.debug(EELFLoggerDelegate.debugLogger,
-                                "addPartnerHasRoleFunctionsToGlobalRole: Finished adding permissions to roles in External Auth system and status code: {} ",
-                                addResponse.getStatusCode().value());
-                    }
-                } catch (Exception e) {
-                    logger.error(EELFLoggerDelegate.errorLogger,
-                            "addPartnerHasRoleFunctionsToGlobalRole: Failed for POST request: {} due to ", addPerms, e);
-                }
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private void addFunctionsTOGlobalRole(List<EPRole> epRoleList, Role updateExtRole,
-            List<RoleFunction> roleFunctionListNew, ObjectMapper mapper, EPApp app, EPApp portalAppInfo)
-            throws Exception {
-        try {
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addFunctionsTOGlobalRole");
-            // GET Permissions from External Auth System
-            JSONArray extPerms = getExtAuthPermissions(app);
-            List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPerms);
-            final Map<String, ExternalAccessPermsDetail> existingPermsWithRoles = new HashMap<>();
-            final Map<String, ExternalAccessPermsDetail> existingPermsWithRolesWithPipes = new HashMap<>();
-            final Map<String, RoleFunction> userRquestedFunctionsMap = new HashMap<>();
-            final Map<String, RoleFunction> userRquestedFunctionsMapPipesFilter = new HashMap<>();
-            for (ExternalAccessPermsDetail permDetail : permsDetailList) {
-                existingPermsWithRoles.put(EcompPortalUtils.getFunctionCode(permDetail.getInstance()), permDetail);
-                existingPermsWithRolesWithPipes.put(permDetail.getInstance(), permDetail);
-            }
-            // Add If function does not exists for role in External Auth System
-            for (RoleFunction roleFunc : roleFunctionListNew) {
-                String roleFuncCode = "";
-                ExternalAccessPermsDetail permsDetail;
-                if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
-                    roleFuncCode = roleFunc.getCode();
-                    permsDetail = existingPermsWithRolesWithPipes.get(roleFunc.getCode());
-                } else {
-                    roleFuncCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-                    permsDetail = existingPermsWithRoles.get(roleFuncCode);
-                }
-                if (null == permsDetail.getRoles()
-                        || !permsDetail.getRoles()
-                                .contains(portalAppInfo.getNameSpace() + FUNCTION_PIPE
-                                        + epRoleList.get(0).getName().replaceAll(
-                                                EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS,
-                                                "_"))) {
-                    addRoleFunctionsToGlobalRoleInExternalSystem(roleFunc, updateExtRole, mapper, app, portalAppInfo);
-                }
-                userRquestedFunctionsMap.put(roleFuncCode, roleFunc);
-                userRquestedFunctionsMapPipesFilter.put(EcompPortalUtils.getFunctionCode(roleFuncCode), roleFunc);
-            }
-            // Delete functions if exists in External Auth System but not in
-            // incoming
-            // request
-            final Map<String, Long> epAppRoleFuncParams = new HashMap<>();
-            epAppRoleFuncParams.put("requestedAppId", app.getId());
-            epAppRoleFuncParams.put("roleId", updateExtRole.getId());
-            List<GlobalRoleWithApplicationRoleFunction> globalRoleFunctionList =
-                    dataAccessService.executeNamedQuery("getGlobalRoleForRequestedApp", epAppRoleFuncParams, null);
-            for (GlobalRoleWithApplicationRoleFunction globalRoleFunc : globalRoleFunctionList) {
-                String globalRoleFuncWithoutPipes = "";
-                RoleFunction roleFunc = null;
-                if (globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
-                    globalRoleFuncWithoutPipes = globalRoleFunc.getFunctionCd();
-                    roleFunc = userRquestedFunctionsMap.get(globalRoleFuncWithoutPipes);
-                } else {
-                    globalRoleFuncWithoutPipes = EcompPortalUtils.getFunctionCode(globalRoleFunc.getFunctionCd());
-                    roleFunc = userRquestedFunctionsMapPipesFilter.get(globalRoleFuncWithoutPipes);
-                }
-                if (roleFunc == null) {
-                    ExternalAccessPermsDetail permDetailFromMap = globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)
-                            ? existingPermsWithRolesWithPipes.get(globalRoleFuncWithoutPipes)
-                            : existingPermsWithRoles.get(globalRoleFuncWithoutPipes);
-                    ExternalAccessPerms perm = new ExternalAccessPerms(permDetailFromMap.getType(),
-                            EcompPortalUtils.getFunctionCode(permDetailFromMap.getInstance()),
-                            permDetailFromMap.getAction());
-                    String roleName = portalAppInfo.getNameSpace() + "." + globalRoleFunc.getRoleName()
-                            .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_");
-                    HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-                    removePermForRole(perm, mapper, roleName, headers);
-                }
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger, "Finished addFunctionsTOGlobalRole");
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addFunctionsTOGlobalRole: Failed", e);
-            throw e;
-        }
-    }
-
-    private void addRoleFunctionsToGlobalRoleInExternalSystem(RoleFunction addFunction, Role globalRole,
-            ObjectMapper mapper, EPApp app, EPApp portalAppInfo) throws Exception {
-        try {
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addRoleFunctionsToGlobalRoleInExternalSystem");
-            ExternalAccessRolePerms extAddRolePerms = null;
-            ExternalAccessPerms extAddPerms = null;
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            String code = "";
-            String type = "";
-            String action = "";
-            if (addFunction.getCode().contains(FUNCTION_PIPE)) {
-                code = EcompPortalUtils.getFunctionCode(addFunction.getCode());
-                type = getFunctionCodeType(addFunction.getCode());
-                action = getFunctionCodeAction(addFunction.getCode());
-            } else {
-                code = addFunction.getCode();
-                type = addFunction.getCode().contains("menu") ? "menu" : "url";
-                action = "*";
-            }
-            extAddPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, code, action);
-            extAddRolePerms = new ExternalAccessRolePerms(extAddPerms, portalAppInfo.getNameSpace() + "." + globalRole
-                    .getName().replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-            String updateRolePerms = mapper.writeValueAsString(extAddRolePerms);
-            HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionsInExternalSystem: {} ",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-            ResponseEntity<String> addResponse = template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
-                    HttpMethod.POST, entity, String.class);
-            if (addResponse.getStatusCode().value() != 201) {
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "addRoleFunctionsInExternalSystem: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
-                        addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
-            } else {
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "addRoleFunctionsInExternalSystem: Finished adding permissions to roles in External Auth system and status code: {} ",
-                        addResponse.getStatusCode().value());
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger, "Finished addRoleFunctionsToGlobalRoleInExternalSystem");
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addRoleFunctionsToGlobalRoleInExternalSystem: Failed", e);
-            throw e;
-        }
-    }
-
-    private boolean addRoleFuncExtSysRestAPI(ObjectMapper addPermsMapper, ExternalAccessRolePerms extAddRolePerms,
-            HttpHeaders headers) throws JsonProcessingException {
-        boolean response;
-        String updateRolePerms = addPermsMapper.writeValueAsString(extAddRolePerms);
-        HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionsInExternalSystem: {} for POST: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
-        ResponseEntity<String> addResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
-                HttpMethod.POST, entity, String.class);
-        if (addResponse.getStatusCode().value() != 201 && addResponse.getStatusCode().value() != 409) {
-            response = false;
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "addRoleFunctionsInExternalSystem: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
-                    addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
-        } else {
-            response = true;
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "addRoleFunctionsInExternalSystem: Finished adding permissions to roles in External Auth system {} and status code: {} ",
-                    updateRolePerms, addResponse.getStatusCode().value());
-        }
-        return response;
-    }
-
-    /**
-     * 
-     * It converts list of functions in updateExtRole parameter to the RoleFunction object
-     * 
-     * @param updateExtRole
-     * @return list of functions
-     */
-    @SuppressWarnings("unchecked")
-    private List<RoleFunction> convertSetToListOfRoleFunctions(Role updateExtRole) {
-        Set<RoleFunction> roleFunctionSetList = updateExtRole.getRoleFunctions();
-        List<RoleFunction> roleFunctionList = new ArrayList<>();
-        ObjectMapper roleFuncMapper = new ObjectMapper();
-        Iterator<RoleFunction> itetaror = roleFunctionSetList.iterator();
-        while (itetaror.hasNext()) {
-            Object nextValue = itetaror.next();
-            RoleFunction roleFunction = roleFuncMapper.convertValue(nextValue, RoleFunction.class);
-            roleFunctionList.add(roleFunction);
-        }
-        return roleFunctionList.stream().distinct().collect(Collectors.toList());
-    }
-
-    /**
-     * It delete permissions/functions in the external auth system
-     * 
-     * @param perm
-     * @param permMapper
-     * @param name
-     * @param headers
-     * @throws JsonProcessingException
-     * @throws Exception
-     */
-    private void removePermForRole(ExternalAccessPerms perm, ObjectMapper permMapper, String name, HttpHeaders headers)
-            throws ExternalAuthSystemException, JsonProcessingException {
-        ExternalAccessRolePerms extAccessRolePerms = new ExternalAccessRolePerms(perm, name);
-        String permDetails = permMapper.writeValueAsString(extAccessRolePerms);
-        try {
-            HttpEntity<String> deleteEntity = new HttpEntity<>(permDetails, headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "removePermForRole: {} for DELETE: {} ",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, permDetails);
-            ResponseEntity<String> deletePermResponse =
-                    template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                            + "role/" + name + "/perm", HttpMethod.DELETE, deleteEntity, String.class);
-            if (deletePermResponse.getStatusCode().value() != 200) {
-                throw new ExternalAuthSystemException(deletePermResponse.getBody());
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "removePermForRole: Finished deleting permission to role in External Auth system: {} and status code: {}",
-                    permDetails, deletePermResponse.getStatusCode().value());
-        } catch (Exception e) {
-            if (e.getMessage().contains("404")) {
-                logger.error(EELFLoggerDelegate.errorLogger, "Failed to add role for DELETE request: {} due to {}",
-                        permDetails, e.getMessage());
-            } else {
-                throw e;
-            }
-        }
-    }
-
-    /**
-     * It will create new role in the External Auth System
-     * 
-     * @param newRole
-     * @param app
-     * @return true if successfully added in the system else false
-     * @throws Exception If fails to add role in the system
-     */
-    private void addNewRoleInExternalSystem(List<EPRole> newRole, EPApp app)
-            throws Exception, HttpClientErrorException {
-        try {
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            ObjectMapper mapper = new ObjectMapper();
-            String addNewRole = "";
-            ExternalAccessRole extRole = new ExternalAccessRole();
-            extRole.setName(app.getNameSpace() + "." + newRole.get(0).getName()
-                    .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-            extRole.setDescription(String.valueOf(newRole.get(0).getName()));
-            addNewRole = mapper.writeValueAsString(extRole);
-            HttpEntity<String> postEntity = new HttpEntity<>(addNewRole, headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "addNewRoleInExternalSystem: {} for POST: {} ",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addNewRole);
-            ResponseEntity<String> addNewRoleInExternalSystem = template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
-                    HttpMethod.POST, postEntity, String.class);
-            if (addNewRoleInExternalSystem.getStatusCode().value() == 201) {
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "addNewRoleInExternalSystem: Finished adding into External Auth system for POST: {} and status code: {}",
-                        addNewRole, addNewRoleInExternalSystem.getStatusCode().value());
-            }
-        } catch (HttpClientErrorException ht) {
-            dataAccessService.deleteDomainObjects(EPRole.class, " role_id = " + newRole.get(0).getId(), null);
-            logger.error(EELFLoggerDelegate.debugLogger,
-                    "addNewRoleInExternalSystem: Failed to add in External Auth system and status code: {}", ht);
-            throw new HttpClientErrorException(ht.getStatusCode());
-        }
-    }
-
-    /**
-     * 
-     * It updates existing role in the External Auth System
-     * 
-     * @param addRole It Contains role information
-     * @param app
-     * @return string which is formatted to match with the external auth system
-     * @throws JsonProcessingException
-     */
-    private String updateExistingRoleInExternalSystem(Role addRole, EPApp app) throws JsonProcessingException {
-        ObjectMapper mapper = new ObjectMapper();
-        String addNewRole = "";
-        ExternalAccessRole extRole = new ExternalAccessRole();
-        extRole.setName(app.getNameSpace() + "." + addRole.getName()
-                .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-        extRole.setDescription(String.valueOf(addRole.getName()));
-        addNewRole = mapper.writeValueAsString(extRole);
-        return addNewRole;
-    }
-
-    /**
-     * It create a role in the external auth system and then in our local
-     * 
-     * @param addRoleInDB
-     * @param app
-     * @return true else false
-     * @throws Exception
-     */
-    @SuppressWarnings("unchecked")
-    @Transactional(rollbackFor = Exception.class)
-    public boolean addRoleInEcompDB(Role addRoleInDB, EPApp app) throws Exception {
-        boolean result = false;
-        EPRole epRole = null;
-        Set<RoleFunction> roleFunctionList = addRoleInDB.getRoleFunctions();
-        List<RoleFunction> roleFunctionListNew = new ArrayList<>();
-        ObjectMapper mapper = new ObjectMapper();
-        Iterator<RoleFunction> itetaror = roleFunctionList.iterator();
-        while (itetaror.hasNext()) {
-            Object nextValue = itetaror.next();
-            RoleFunction roleFunction = mapper.convertValue(nextValue, RoleFunction.class);
-            roleFunctionListNew.add(roleFunction);
-        }
-        List<RoleFunction> listWithoutDuplicates = roleFunctionListNew.stream().distinct().collect(Collectors.toList());
-        try {
-            if (addRoleInDB.getId() == null) { // check if it is new role
-                if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                    checkIfRoleExitsInExternalSystem(addRoleInDB, app);
-                }
-                EPRole epRoleNew = new EPRole();
-                epRoleNew.setActive(addRoleInDB.getActive());
-                epRoleNew.setName(addRoleInDB.getName());
-                epRoleNew.setPriority(addRoleInDB.getPriority());
-                if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                    epRoleNew.setAppId(null);
-                } else {
-                    epRoleNew.setAppId(app.getId());
-                }
-                dataAccessService.saveDomainObject(epRoleNew, null);
-                List<EPRole> getRoleCreated = null;
-                final Map<String, String> epAppRoleParams = new HashMap<>();
-                final Map<String, String> epAppPortalRoleParams = new HashMap<>();
-                if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                    epAppRoleParams.put("appId", String.valueOf(app.getId()));
-                    epAppRoleParams.put(APP_ROLE_NAME_PARAM, addRoleInDB.getName());
-                    List<EPRole> roleCreated = dataAccessService
-                            .executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, epAppRoleParams, null);
-                    EPRole epUpdateRole = roleCreated.get(0);
-                    epUpdateRole.setAppRoleId(epUpdateRole.getId());
-                    dataAccessService.saveDomainObject(epUpdateRole, null);
-                    getRoleCreated = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
-                            epAppRoleParams, null);
-                } else {
-                    epAppPortalRoleParams.put(APP_ROLE_NAME_PARAM, addRoleInDB.getName());
-                    getRoleCreated = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY,
-                            epAppPortalRoleParams, null);
-                }
-                // Add role in External Auth system
-                if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                    addNewRoleInExternalSystem(getRoleCreated, app);
-                }
-                result = true;
-            } else { // if role already exists then update it
-                EPRole globalRole = null;
-                List<EPRole> applicationRoles;
-                List<EPRole> globalRoleList = getGlobalRolesOfPortal();
-                boolean isGlobalRole = false;
-                if (!globalRoleList.isEmpty()) {
-                    EPRole role = globalRoleList.stream().filter(x -> addRoleInDB.getId().equals(x.getId())).findAny()
-                            .orElse(null);
-                    if (role != null) {
-                        globalRole = role;
-                        isGlobalRole = true;
-                    }
-                }
-                if (app.getId().equals(PortalConstants.PORTAL_APP_ID)
-                        || (globalRole != null && app.getId() != globalRole.getAppId())) {
-                    applicationRoles = getPortalAppRoleInfo(addRoleInDB.getId());
-                } else {
-                    applicationRoles = getPartnerAppRoleInfo(addRoleInDB.getId(), app);
-                }
-                if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                    updateRoleInExternalSystem(addRoleInDB, app, isGlobalRole);
-                    // Add all user to the re-named role in external auth system
-                    if (!applicationRoles.isEmpty()
-                            && !addRoleInDB.getName().equals(applicationRoles.get(0).getName())) {
-                        bulkUploadUsersSingleRole(app.getUebKey(), applicationRoles.get(0).getId(),
-                                addRoleInDB.getName());
-                    }
-                }
-                deleteRoleFunction(app, applicationRoles);
-                if (!applicationRoles.isEmpty()) {
-                    epRole = applicationRoles.get(0);
-                    epRole.setName(addRoleInDB.getName());
-                    epRole.setPriority(addRoleInDB.getPriority());
-                    epRole.setActive(addRoleInDB.getActive());
-                    if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                        epRole.setAppId(null);
-                        epRole.setAppRoleId(null);
-                    } else if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)
-                            && applicationRoles.get(0).getAppRoleId() == null) {
-                        epRole.setAppRoleId(epRole.getId());
-                    }
-                    dataAccessService.saveDomainObject(epRole, null);
-                }
-                Long roleAppId = null;
-                if (globalRole != null && !app.getId().equals(globalRole.getAppId()))
-                    roleAppId = PortalConstants.PORTAL_APP_ID;
-                saveRoleFunction(listWithoutDuplicates, app, applicationRoles, roleAppId);
-                result = true;
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addRoleInEcompDB is failed", e);
-            throw e;
-        }
-        return result;
-    }
-
-    /**
-     * 
-     * It validates whether role exists in external auth system
-     * 
-     * @param checkRole
-     * @param app
-     * @throws Exception If role exits
-     */
-    private void checkIfRoleExitsInExternalSystem(Role checkRole, EPApp app) throws Exception {
-        getNameSpaceIfExists(app);
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        String roleName = app.getNameSpace() + "." + checkRole.getName()
-                .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_");
-        HttpEntity<String> checkRoleEntity = new HttpEntity<>(headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "checkIfRoleExitsInExternalSystem: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-        ResponseEntity<String> checkRoleInExternalSystem =
-                template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                        + "roles/" + roleName, HttpMethod.GET, checkRoleEntity, String.class);
-        if (!checkRoleInExternalSystem.getBody().equals(IS_EMPTY_JSON_STRING)) {
-            logger.debug(
-                    "checkIfRoleExitsInExternalSystem: Role already exists in external system {} and status code: {} ",
-                    checkRoleInExternalSystem.getBody(), checkRoleInExternalSystem.getStatusCode().value());
-            throw new ExternalAuthSystemException(" Role already exists in external system");
-        }
-    }
-
-    /**
-     * It saves list of functions to the role in portal
-     * 
-     * @param roleFunctionListNew
-     * @param app
-     * @param applicationRoles
-     * @throws Exception
-     */
-    @SuppressWarnings("unchecked")
-    private void saveRoleFunction(List<RoleFunction> roleFunctionListNew, EPApp app, List<EPRole> applicationRoles,
-            Long roleAppId) throws Exception {
-        final Map<String, String> getAppFunctionParams = new HashMap<>();
-        for (RoleFunction roleFunc : roleFunctionListNew) {
-            String code = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-            EPAppRoleFunction appRoleFunc = new EPAppRoleFunction();
-            appRoleFunc.setAppId(app.getId());
-            appRoleFunc.setRoleId(applicationRoles.get(0).getId());
-            appRoleFunc.setRoleAppId(String.valueOf(roleAppId));
-            getAppFunctionParams.put("appId", String.valueOf(app.getId()));
-            getAppFunctionParams.put(FUNCTION_CODE_PARAMS, roleFunc.getCode());
-            // query to check if function code has pipes
-            List<CentralV2RoleFunction> roleFunction =
-                    dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams, null);
-            if (roleFunction.isEmpty()) {
-                getAppFunctionParams.put(FUNCTION_CODE_PARAMS, code);
-                roleFunction = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams, null);
-            }
-            if (roleFunction.size() > 1) {
-                CentralV2RoleFunction getExactFunctionCode = appFunctionListFilter(code, roleFunction);
-                appRoleFunc.setCode(getExactFunctionCode.getCode());
-            } else {
-                appRoleFunc.setCode(roleFunction.get(0).getCode());
-            }
-            dataAccessService.saveDomainObject(appRoleFunc, null);
-        }
-    }
-
-    /**
-     * 
-     * It filters the app functions which starts with similar name in the result set
-     * 
-     * @param roleFunc
-     * @param roleFunction
-     * @return CentralRoleFunction
-     */
-    private CentralV2RoleFunction appFunctionListFilter(String roleFuncCode, List<CentralV2RoleFunction> roleFunction) {
-        final Map<String, CentralV2RoleFunction> appFunctionsFilter = new HashMap<>();
-        final Map<String, CentralV2RoleFunction> appFunctionsFilterPipes = new HashMap<>();
-        CentralV2RoleFunction getExactFunctionCode = null;
-        for (CentralV2RoleFunction cenRoleFunction : roleFunction) {
-            appFunctionsFilter.put(cenRoleFunction.getCode(), cenRoleFunction);
-            appFunctionsFilterPipes.put(EcompPortalUtils.getFunctionCode(cenRoleFunction.getCode()), cenRoleFunction);
-        }
-        getExactFunctionCode = appFunctionsFilter.get(roleFuncCode);
-        if (getExactFunctionCode == null) {
-            getExactFunctionCode = appFunctionsFilterPipes.get(roleFuncCode);
-        }
-        return getExactFunctionCode;
-    }
-
-    /**
-     * It deletes all EPAppRoleFunction records in the portal
-     * 
-     * @param app
-     * @param role
-     */
-    @SuppressWarnings("unchecked")
-    private void deleteRoleFunction(EPApp app, List<EPRole> role) {
-        final Map<String, Long> appRoleFuncsParams = new HashMap<>();
-        appRoleFuncsParams.put("appId", app.getId());
-        appRoleFuncsParams.put("roleId", role.get(0).getId());
-        List<EPAppRoleFunction> appRoleFunctionList =
-                dataAccessService.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null);
-        if (!appRoleFunctionList.isEmpty()) {
-            for (EPAppRoleFunction approleFunction : appRoleFunctionList) {
-                dataAccessService.deleteDomainObject(approleFunction, null);
-            }
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public List<EPUser> getUser(String loginId) throws InvalidUserException {
-        final Map<String, String> userParams = new HashMap<>();
-        userParams.put("org_user_id", loginId);
-        List<EPUser> userList = dataAccessService.executeNamedQuery("getEPUserByOrgUserId", userParams, null);
-        if (userList.isEmpty()) {
-            throw new InvalidUserException("User not found");
-        }
-        return userList;
-    }
-
-    @Override
-    public String getV2UserWithRoles(String loginId, String uebkey) throws Exception {
-        final Map<String, String> params = new HashMap<>();
-        List<EPUser> userList = null;
-        CentralV2User cenV2User = null;
-        String result = null;
-        try {
-            params.put("orgUserIdValue", loginId);
-            List<EPApp> appList = getApp(uebkey);
-            if (!appList.isEmpty()) {
-                userList = getUser(loginId);
-                if (!userList.isEmpty()) {
-                    ObjectMapper mapper = new ObjectMapper();
-                    cenV2User = getV2UserAppRoles(loginId, uebkey);
-                    result = mapper.writeValueAsString(cenV2User);
-                } else if (userList.isEmpty()) {
-                    throw new InvalidUserException("User not found");
-                }
-            } else {
-                throw new InactiveApplicationException("Application not found");
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getUser: failed", e);
-            throw e;
-        }
-        return result;
-    }
-
-    @Override
-    public List<CentralV2Role> getRolesForApp(String uebkey) throws Exception {
-        logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into getRolesForApp");
-        List<CentralV2Role> roleList = new ArrayList<>();
-        final Map<String, Long> params = new HashMap<>();
-        try {
-            List<EPApp> app = getApp(uebkey);
-            List<EPRole> appRolesList = getAppRoles(app.get(0).getId());
-            roleList = createCentralRoleObject(app, appRolesList, roleList, params);
-            if (app.get(0).getId() != PortalConstants.PORTAL_APP_ID) {
-                List<CentralV2Role> globalRoleList = getGlobalRolesOfApplication(app.get(0).getId());
-                List<EPRole> globalRolesList = getGlobalRolesOfPortal();
-                List<CentralV2Role> portalsGlobalRolesFinlaList = new ArrayList<>();
-                if (!globalRolesList.isEmpty()) {
-                    for (EPRole eprole : globalRolesList) {
-                        CentralV2Role cenRole = convertRoleToCentralV2Role(eprole);
-                        portalsGlobalRolesFinlaList.add(cenRole);
-                    }
-                    roleList.addAll(globalRoleList);
-                    for (CentralV2Role role : portalsGlobalRolesFinlaList) {
-                        CentralV2Role result =
-                                roleList.stream().filter(x -> role.getId().equals(x.getId())).findAny().orElse(null);
-                        if (result == null)
-                            roleList.add(role);
-                    }
-                } else {
-                    for (EPRole role : globalRolesList) {
-                        CentralV2Role cenRole = convertRoleToCentralV2Role(role);
-                        roleList.add(cenRole);
-                    }
-                }
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp: Failed!", e);
-            throw e;
-        }
-        logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished!");
-        return roleList.stream().distinct().collect(Collectors.toList());
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<CentralV2RoleFunction> getRoleFuncList(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        List<CentralV2RoleFunction> finalRoleList = new ArrayList<>();
-        final Map<String, Long> params = new HashMap<>();
-        params.put(APP_ID, app.getId());
-        List<CentralV2RoleFunction> getRoleFuncList =
-                dataAccessService.executeNamedQuery("getAllRoleFunctions", params, null);
-        for (CentralV2RoleFunction roleFuncItem : getRoleFuncList) {
-            String code = EcompPortalUtils.getFunctionCode(roleFuncItem.getCode());
-            String type = "";
-            if (roleFuncItem.getCode().contains("|"))
-                type = EcompPortalUtils.getFunctionType(roleFuncItem.getCode());
-            else
-                type = getFunctionCodeType(roleFuncItem.getCode());
-            String action = getFunctionCodeAction(roleFuncItem.getCode());
-            roleFuncItem.setCode(EPUserUtils.decodeFunctionCode(code));
-            roleFuncItem.setType(type);
-            roleFuncItem.setAction(action);
-            finalRoleList.add(roleFuncItem);
-        }
-        return finalRoleList;
-    }
-
-    @Override
-    public String getFunctionCodeAction(String roleFuncItem) {
-        return (!roleFuncItem.contains(FUNCTION_PIPE)) ? "*" : EcompPortalUtils.getFunctionAction(roleFuncItem);
-    }
-
-    @Override
-    public String getFunctionCodeType(String roleFuncItem) {
-        String type = null;
-        if ((roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("menu"))
-                || (!roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("menu"))) {
-            type = "menu";
-        } else if (checkIfCodeHasNoPipesAndHasTypeUrl(roleFuncItem) || checkIfCodeHasPipesAndHasTypeUrl(roleFuncItem)
-                || checkIfCodeHasNoPipesAndHasNoTypeUrl(roleFuncItem)) {
-            type = "url";
-        } else if (roleFuncItem.contains(FUNCTION_PIPE)
-                && (!roleFuncItem.contains("menu") || roleFuncItem.contains("url"))) {
-            type = EcompPortalUtils.getFunctionType(roleFuncItem);
-        }
-        return type;
-    }
-
-    /**
-     * 
-     * It check whether function code has no pipes and no url string in it
-     * 
-     * @param roleFuncItem
-     * @return true or false
-     */
-    private boolean checkIfCodeHasNoPipesAndHasNoTypeUrl(String roleFuncItem) {
-        return !roleFuncItem.contains(FUNCTION_PIPE) && !roleFuncItem.contains("url");
-    }
-
-    /**
-     * 
-     * It check whether function code has pipes and url string in it
-     * 
-     * @param roleFuncItem
-     * @return true or false
-     */
-    private boolean checkIfCodeHasPipesAndHasTypeUrl(String roleFuncItem) {
-        return roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("url");
-    }
-
-    /**
-     * 
-     * It check whether function code has no pipes and has url string in it
-     * 
-     * @param roleFuncItem
-     * @return true or false
-     */
-    private boolean checkIfCodeHasNoPipesAndHasTypeUrl(String roleFuncItem) {
-        return !roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("url");
-    }
-
-    /**
-     * It returns user detail information which is deep copy of EPUser.class object
-     * 
-     * @param userInfo
-     * @param userAppSet
-     * @param app
-     * @return
-     * @throws Exception
-     */
-    @SuppressWarnings("unchecked")
-    private CentralV2User createEPUser(EPUser userInfo, Set<EPUserApp> userAppSet, EPApp app) throws Exception {
-        final Map<String, Long> params = new HashMap<>();
-        CentralV2User userAppList = new CentralV2User();
-        CentralV2User user1 = null;
-        final Map<String, Long> params1 = new HashMap<>();
-        List<EPRole> globalRoleList = new ArrayList<>();
-        try {
-            if (app.getId() != PortalConstants.PORTAL_APP_ID) {
-                params1.put("userId", userInfo.getId());
-                params1.put("appId", app.getId());
-                globalRoleList = dataAccessService.executeNamedQuery("userAppGlobalRoles", params1, null);
-            }
-            userAppList.setUserApps(new TreeSet<CentralV2UserApp>());
-            for (EPUserApp userApp : userAppSet) {
-                if (userApp.getRole().getActive()) {
-                    EPApp epApp = userApp.getApp();
-                    String globalRole = userApp.getRole().getName().toLowerCase();
-                    if (((epApp.getId().equals(app.getId()))
-                            && (!userApp.getRole().getId().equals(PortalConstants.ACCOUNT_ADMIN_ROLE_ID)))
-                            || ((epApp.getId().equals(PortalConstants.PORTAL_APP_ID))
-                                    && (globalRole.toLowerCase().startsWith("global_")))) {
-                        CentralV2UserApp cua = new CentralV2UserApp();
-                        cua.setUserId(null);
-                        CentralApp cenApp = new CentralApp(1L, epApp.getCreated(), epApp.getModified(),
-                                epApp.getCreatedId(), epApp.getModifiedId(), epApp.getRowNum(), epApp.getName(),
-                                epApp.getImageUrl(), epApp.getDescription(), epApp.getNotes(), epApp.getUrl(),
-                                epApp.getAlternateUrl(), epApp.getAppRestEndpoint(), epApp.getMlAppName(),
-                                epApp.getMlAppAdminId(), String.valueOf(epApp.getMotsId()), epApp.getAppPassword(),
-                                String.valueOf(epApp.getOpen()), String.valueOf(epApp.getEnabled()),
-                                epApp.getThumbnail(), epApp.getUsername(), epApp.getUebKey(), epApp.getUebSecret(),
-                                epApp.getUebTopicName());
-                        cenApp.setAppPassword(EPCommonSystemProperties.APP_DISPLAY_PASSWORD);
-                        cua.setApp(cenApp);
-                        Long appId = null;
-                        if (globalRole.toLowerCase().startsWith("global_")
-                                && epApp.getId().equals(PortalConstants.PORTAL_APP_ID)
-                                && !epApp.getId().equals(app.getId())) {
-                            appId = app.getId();
-                            EPRole result = null;
-                            if (globalRoleList.size() > 0)
-                                result = globalRoleList.stream()
-                                        .filter(x -> userApp.getRole().getId().equals(x.getId())).findAny()
-                                        .orElse(null);
-                            if (result == null)
-                                continue;
-                        } else {
-                            appId = userApp.getApp().getId();
-                        }
-                        params.put("roleId", userApp.getRole().getId());
-                        params.put(APP_ID, appId);
-                        List<CentralV2RoleFunction> appRoleFunctionList =
-                                dataAccessService.executeNamedQuery("getAppRoleFunctionList", params, null);
-                        SortedSet<CentralV2RoleFunction> roleFunctionSet = new TreeSet<>();
-                        for (CentralV2RoleFunction roleFunc : appRoleFunctionList) {
-                            String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-                            String type = getFunctionCodeType(roleFunc.getCode());
-                            String action = getFunctionCodeAction(roleFunc.getCode());
-                            CentralV2RoleFunction cenRoleFunc = new CentralV2RoleFunction(roleFunc.getId(),
-                                    functionCode, roleFunc.getName(), null, type, action, null);
-                            roleFunctionSet.add(cenRoleFunc);
-                        }
-                        Long userRoleId = null;
-                        if (globalRole.toLowerCase().startsWith("global_")
-                                || epApp.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                            userRoleId = userApp.getRole().getId();
-                        } else {
-                            userRoleId = userApp.getRole().getAppRoleId();
-                        }
-                        CentralV2Role cenRole = new CentralV2Role(userRoleId, userApp.getRole().getCreated(),
-                                userApp.getRole().getModified(), userApp.getRole().getCreatedId(),
-                                userApp.getRole().getModifiedId(), userApp.getRole().getRowNum(),
-                                userApp.getRole().getName(), userApp.getRole().getActive(),
-                                userApp.getRole().getPriority(), roleFunctionSet, null, null);
-                        cua.setRole(cenRole);
-                        userAppList.getUserApps().add(cua);
-                    }
-                }
-            }
-            user1 = new CentralV2User(null, userInfo.getCreated(), userInfo.getModified(), userInfo.getCreatedId(),
-                    userInfo.getModifiedId(), userInfo.getRowNum(), userInfo.getOrgId(), userInfo.getManagerId(),
-                    userInfo.getFirstName(), userInfo.getMiddleInitial(), userInfo.getLastName(), userInfo.getPhone(),
-                    userInfo.getFax(), userInfo.getCellular(), userInfo.getEmail(), userInfo.getAddressId(),
-                    userInfo.getAlertMethodCd(), userInfo.getHrid(), userInfo.getOrgUserId(), userInfo.getOrgCode(),
-                    userInfo.getAddress1(), userInfo.getAddress2(), userInfo.getCity(), userInfo.getState(),
-                    userInfo.getZipCode(), userInfo.getCountry(), userInfo.getOrgManagerUserId(),
-                    userInfo.getLocationClli(), userInfo.getBusinessCountryCode(), userInfo.getBusinessCountryName(),
-                    userInfo.getBusinessUnit(), userInfo.getBusinessUnitName(), userInfo.getDepartment(),
-                    userInfo.getDepartmentName(), userInfo.getCompanyCode(), userInfo.getCompany(),
-                    userInfo.getZipCodeSuffix(), userInfo.getJobTitle(), userInfo.getCommandChain(),
-                    userInfo.getSiloStatus(), userInfo.getCostCenter(), userInfo.getFinancialLocCode(),
-                    userInfo.getLoginId(), userInfo.getLoginPwd(), userInfo.getLastLoginDate(), userInfo.getActive(),
-                    userInfo.getInternal(), userInfo.getSelectedProfileId(), userInfo.getTimeZoneId(),
-                    userInfo.isOnline(), userInfo.getChatId(), userAppList.getUserApps(), null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "createEPUser: createEPUser failed", e);
-            throw e;
-        }
-        return user1;
-    }
-
-    @Override
-    public CentralV2Role getRoleInfo(Long roleId, String uebkey) throws Exception {
-        final Map<String, Long> params = new HashMap<>();
-        List<CentralV2Role> roleList = new ArrayList<>();
-        CentralV2Role cenRole = new CentralV2Role();
-        List<EPRole> roleInfo = null;
-        List<EPApp> app = null;
-        try {
-            app = getApp(uebkey);
-            if (app.isEmpty()) {
-                throw new InactiveApplicationException("Application not found");
-            }
-            if (app.get(0).getId() != PortalConstants.PORTAL_APP_ID) {
-                List<EPRole> globalRoleList = new ArrayList<>();
-                globalRoleList = getGlobalRolesOfPortal();
-                if (globalRoleList.size() > 0) {
-                    EPRole result =
-                            globalRoleList.stream().filter(x -> roleId.equals(x.getId())).findAny().orElse(null);
-                    if (result != null)
-                        return getGlobalRoleForRequestedApp(app.get(0).getId(), roleId);
-                }
-            }
-            if (app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                roleInfo = getPortalAppRoleInfo(roleId);
-            } else {
-                roleInfo = getPartnerAppRoleInfo(roleId, app.get(0));
-            }
-            roleList = createCentralRoleObject(app, roleInfo, roleList, params);
-            if (roleList.isEmpty()) {
-                return cenRole;
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo: failed", e);
-            throw e;
-        }
-        return roleList.get(0);
-    }
-
-    @SuppressWarnings("unchecked")
-    private List<EPRole> getPartnerAppRoleInfo(Long roleId, EPApp app) {
-        List<EPRole> roleInfo;
-        final Map<String, Long> getPartnerAppRoleParams = new HashMap<>();
-        getPartnerAppRoleParams.put("appRoleId", roleId);
-        getPartnerAppRoleParams.put("appId", app.getId());
-        roleInfo = dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null);
-        if (roleInfo.isEmpty()) {
-            getPartnerAppRoleParams.put("appRoleId", roleId);
-            roleInfo = dataAccessService.executeNamedQuery("getPartnerAppRoleById", getPartnerAppRoleParams, null);
-        }
-        return roleInfo;
-    }
-
-    @SuppressWarnings("unchecked")
-    private List<EPRole> getPortalAppRoleInfo(Long roleId) {
-        List<EPRole> roleInfo;
-        final Map<String, Long> getPortalAppRoleParams = new HashMap<>();
-        getPortalAppRoleParams.put("roleId", roleId);
-        roleInfo = dataAccessService.executeNamedQuery("getPortalAppRoleByRoleId", getPortalAppRoleParams, null);
-        return roleInfo;
-    }
-
-    /**
-     * 
-     * It returns list of app roles along with role functions and which went through deep copy
-     * 
-     * @param app
-     * @param roleInfo
-     * @param roleList
-     * @param params
-     * @return
-     * @throws DecoderException
-     */
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<CentralV2Role> createCentralRoleObject(List<EPApp> app, List<EPRole> roleInfo,
-            List<CentralV2Role> roleList, Map<String, Long> params) throws RoleFunctionException {
-        for (EPRole role : roleInfo) {
-            params.put("roleId", role.getId());
-            params.put(APP_ID, app.get(0).getId());
-            List<CentralV2RoleFunction> cenRoleFuncList =
-                    dataAccessService.executeNamedQuery("getAppRoleFunctionList", params, null);
-            SortedSet<CentralV2RoleFunction> roleFunctionSet = new TreeSet<>();
-            for (CentralV2RoleFunction roleFunc : cenRoleFuncList) {
-                String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-                functionCode = EPUserUtils.decodeFunctionCode(functionCode);
-                String type = getFunctionCodeType(roleFunc.getCode());
-                String action = getFunctionCodeAction(roleFunc.getCode());
-                CentralV2RoleFunction cenRoleFunc = new CentralV2RoleFunction(role.getId(), functionCode,
-                        roleFunc.getName(), null, type, action, null);
-                roleFunctionSet.add(cenRoleFunc);
-            }
-            SortedSet<CentralV2Role> childRoles = new TreeSet<>();
-            SortedSet<CentralV2Role> parentRoles = new TreeSet<>();
-            CentralV2Role cenRole = null;
-            if (role.getAppRoleId() == null) {
-                cenRole = new CentralV2Role(role.getId(), role.getCreated(), role.getModified(), role.getCreatedId(),
-                        role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(), role.getPriority(),
-                        roleFunctionSet, childRoles, parentRoles);
-            } else {
-                cenRole = new CentralV2Role(role.getAppRoleId(), role.getCreated(), role.getModified(),
-                        role.getCreatedId(), role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(),
-                        role.getPriority(), roleFunctionSet, childRoles, parentRoles);
-            }
-            roleList.add(cenRole);
-        }
-        return roleList;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public CentralV2RoleFunction getRoleFunction(String functionCode, String uebkey) throws Exception {
-        String code = EcompPortalUtils.getFunctionCode(functionCode);
-        String encodedCode = encodeFunctionCode(code);
-        CentralV2RoleFunction roleFunc = null;
-        EPApp app = getApp(uebkey).get(0);
-        List<CentralV2RoleFunction> getRoleFuncList = null;
-        final Map<String, String> params = new HashMap<>();
-        try {
-            params.put(FUNCTION_CODE_PARAMS, functionCode);
-            params.put(APP_ID, String.valueOf(app.getId()));
-            getRoleFuncList = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
-            if (getRoleFuncList.isEmpty()) {
-                params.put(FUNCTION_CODE_PARAMS, encodedCode);
-                getRoleFuncList = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
-                if (getRoleFuncList.isEmpty()) {
-                    return roleFunc;
-                }
-            }
-            if (getRoleFuncList.size() > 1) {
-                CentralV2RoleFunction cenV2RoleFunction = appFunctionListFilter(encodedCode, getRoleFuncList);
-                if (cenV2RoleFunction == null)
-                    return roleFunc;
-                roleFunc = checkIfPipesExitsInFunctionCode(cenV2RoleFunction);
-            } else {
-                // Check even if single record have pipes
-                if (!getRoleFuncList.isEmpty() && getRoleFuncList.get(0).getCode().contains(FUNCTION_PIPE)) {
-                    roleFunc = checkIfPipesExitsInFunctionCode(getRoleFuncList.get(0));
-                } else {
-                    roleFunc = getRoleFuncList.get(0);
-                }
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction: failed", e);
-            throw e;
-        }
-        return roleFunc;
-    }
-
-    private CentralV2RoleFunction checkIfPipesExitsInFunctionCode(CentralV2RoleFunction getRoleFuncList) {
-        CentralV2RoleFunction roleFunc;
-        String functionCodeFormat = getRoleFuncList.getCode();
-        if (functionCodeFormat.contains(FUNCTION_PIPE)) {
-            String newfunctionCodeFormat = EcompPortalUtils.getFunctionCode(functionCodeFormat);
-            String newfunctionTypeFormat = EcompPortalUtils.getFunctionType(functionCodeFormat);
-            String newfunctionActionFormat = EcompPortalUtils.getFunctionAction(functionCodeFormat);
-            roleFunc = new CentralV2RoleFunction(getRoleFuncList.getId(), newfunctionCodeFormat,
-                    getRoleFuncList.getName(), getRoleFuncList.getAppId(), newfunctionTypeFormat,
-                    newfunctionActionFormat, getRoleFuncList.getEditUrl());
-        } else {
-            roleFunc = new CentralV2RoleFunction(getRoleFuncList.getId(), functionCodeFormat, getRoleFuncList.getName(),
-                    getRoleFuncList.getAppId(), getRoleFuncList.getEditUrl());
-        }
-        return roleFunc;
-    }
-
-    @Override
-    public boolean saveCentralRoleFunction(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
-            throws Exception {
-        boolean saveOrUpdateFunction = false;
-        try {
-            domainCentralRoleFunction.setCode(encodeFunctionCode(domainCentralRoleFunction.getCode()));
-            final Map<String, String> functionParams = new HashMap<>();
-            functionParams.put("appId", String.valueOf(app.getId()));
-            if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                addRoleFunctionInExternalSystem(domainCentralRoleFunction, app);
-            }
-            if (domainCentralRoleFunction.getType() != null && domainCentralRoleFunction.getAction() != null) {
-                domainCentralRoleFunction.setCode(domainCentralRoleFunction.getType() + FUNCTION_PIPE
-                        + domainCentralRoleFunction.getCode() + FUNCTION_PIPE + domainCentralRoleFunction.getAction());
-            }
-            domainCentralRoleFunction.setAppId(app.getId());
-            dataAccessService.saveDomainObject(domainCentralRoleFunction, null);
-            saveOrUpdateFunction = true;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "saveCentralRoleFunction: failed", e);
-            throw e;
-        }
-        return saveOrUpdateFunction;
-    }
-
-    /**
-     * It creates application permission in external auth system
-     * 
-     * @param domainCentralRoleFunction
-     * @param app
-     * @throws Exception
-     */
-    private void addRoleFunctionInExternalSystem(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
-            throws Exception {
-        ObjectMapper mapper = new ObjectMapper();
-        ExternalAccessPerms extPerms = new ExternalAccessPerms();
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        String type = "";
-        String instance = "";
-        String action = "";
-        if ((domainCentralRoleFunction.getType() != null && domainCentralRoleFunction.getAction() != null)
-                || domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)) {
-            type = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
-                    ? EcompPortalUtils.getFunctionType(domainCentralRoleFunction.getCode())
-                    : domainCentralRoleFunction.getType();
-            instance = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
-                    ? EcompPortalUtils.getFunctionCode(domainCentralRoleFunction.getCode())
-                    : domainCentralRoleFunction.getCode();
-            action = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
-                    ? EcompPortalUtils.getFunctionAction(domainCentralRoleFunction.getCode())
-                    : domainCentralRoleFunction.getAction();
-        } else {
-            type = domainCentralRoleFunction.getCode().contains("menu") ? "menu" : "url";
-            instance = domainCentralRoleFunction.getCode();
-            action = "*";
-        }
-        // get Permissions from External Auth System
-        JSONArray extPermsList = getExtAuthPermissions(app);
-        List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPermsList);
-        String requestedPerm = type + FUNCTION_PIPE + instance + FUNCTION_PIPE + action;
-        boolean checkIfFunctionsExits =
-                permsDetailList.stream().anyMatch(permsDetail -> permsDetail.getInstance().equals(requestedPerm));
-        if (!checkIfFunctionsExits) {
-            try {
-                extPerms.setAction(action);
-                extPerms.setInstance(instance);
-                extPerms.setType(app.getNameSpace() + "." + type);
-                extPerms.setDescription(domainCentralRoleFunction.getName());
-                String addFunction = mapper.writeValueAsString(extPerms);
-                HttpEntity<String> entity = new HttpEntity<>(addFunction, headers);
-                logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionInExternalSystem: {} for POST: {}",
-                        CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addFunction);
-                ResponseEntity<String> addPermResponse = template.exchange(
-                        SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
-                        HttpMethod.POST, entity, String.class);
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "addRoleFunctionInExternalSystem: Finished adding permission for POST: {} and status code: {} ",
-                        addPermResponse.getStatusCode().value(), addFunction);
-            } catch (HttpClientErrorException e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "HttpClientErrorException - Failed to add function in external central auth system", e);
-                EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-                throw e;
-            } catch (Exception e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleFunctionInExternalSystem: Failed to add fucntion in external central auth system", e);
-                throw e;
-            }
-        } else {
-            try {
-                extPerms.setAction(action);
-                extPerms.setInstance(instance);
-                extPerms.setType(app.getNameSpace() + "." + type);
-                extPerms.setDescription(domainCentralRoleFunction.getName());
-                String updateRoleFunction = mapper.writeValueAsString(extPerms);
-                HttpEntity<String> entity = new HttpEntity<>(updateRoleFunction, headers);
-                logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionInExternalSystem: {} for PUT: {}",
-                        CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRoleFunction);
-                ResponseEntity<String> updatePermResponse = template.exchange(
-                        SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
-                        HttpMethod.PUT, entity, String.class);
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "addRoleFunctionInExternalSystem: Finished updating permission in External Auth system {} and response: {} ",
-                        updateRoleFunction, updatePermResponse.getStatusCode().value());
-            } catch (HttpClientErrorException e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "HttpClientErrorException - Failed to add function in external central auth system", e);
-                EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-                throw e;
-            } catch (Exception e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleFunctionInExternalSystem: Failed to update function in external central auth system",
-                        e);
-                throw e;
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public boolean deleteCentralRoleFunction(String code, EPApp app) {
-        boolean deleteFunctionResponse = false;
-        try {
-            final Map<String, String> params = new HashMap<>();
-            params.put(FUNCTION_CODE_PARAMS, code);
-            params.put(APP_ID, String.valueOf(app.getId()));
-            List<CentralV2RoleFunction> domainCentralRoleFunction =
-                    dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
-            CentralV2RoleFunction appFunctionCode = appFunctionListFilter(code, domainCentralRoleFunction);
-            if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                deleteRoleFunctionInExternalSystem(appFunctionCode, app);
-                // Delete role function dependency records
-                deleteAppRoleFunctions(appFunctionCode.getCode(), app);
-            }
-            dataAccessService.deleteDomainObject(appFunctionCode, null);
-            deleteFunctionResponse = true;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "deleteCentralRoleFunction: failed", e);
-        }
-        return deleteFunctionResponse;
-    }
-
-    /**
-     * It deletes app function record in portal
-     * 
-     * @param code
-     * @param app
-     */
-    private void deleteAppRoleFunctions(String code, EPApp app) {
-        dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
-                APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + code + "'", null);
-    }
-
-    /**
-     * 
-     * It deletes permission in the external auth system
-     * 
-     * @param domainCentralRoleFunction
-     * @param app
-     * @throws Exception
-     */
-    private void deleteRoleFunctionInExternalSystem(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
-            throws Exception {
-        try {
-            ObjectMapper mapper = new ObjectMapper();
-            ExternalAccessPerms extPerms = new ExternalAccessPerms();
-            String instanceValue = EcompPortalUtils.getFunctionCode(domainCentralRoleFunction.getCode());
-            String checkType = getFunctionCodeType(domainCentralRoleFunction.getCode());
-            String actionValue = getFunctionCodeAction(domainCentralRoleFunction.getCode());
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            extPerms.setAction(actionValue);
-            extPerms.setInstance(instanceValue);
-            extPerms.setType(app.getNameSpace() + "." + checkType);
-            extPerms.setDescription(domainCentralRoleFunction.getName());
-            String deleteRoleFunction = mapper.writeValueAsString(extPerms);
-            HttpEntity<String> entity = new HttpEntity<>(deleteRoleFunction, headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleFunctionInExternalSystem: {} for DELETE: {} ",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, deleteRoleFunction);
-            ResponseEntity<String> delPermResponse =
-                    template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                            + "perm?force=true", HttpMethod.DELETE, entity, String.class);
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "deleteRoleFunctionInExternalSystem: Finished deleting permission in External Auth system {} and status code: {} ",
-                    deleteRoleFunction, delPermResponse.getStatusCode().value());
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to delete functions in External System", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            if (e.getMessage().equalsIgnoreCase("404 Not Found")) {
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        " deleteRoleFunctionInExternalSystem: It seems like function is already deleted in external central auth system  but exists in local DB",
-                        e.getMessage());
-            } else {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "deleteRoleFunctionInExternalSystem: Failed to delete functions in External System", e);
-            }
-        }
-    }
-
-    @Override
-    public ExternalRequestFieldsValidator saveRoleForApplication(Role saveRole, String uebkey) throws Exception {
-        boolean response = false;
-        String message = "";
-        try {
-            EPApp app = getApp(uebkey).get(0);
-            addRoleInEcompDB(saveRole, app);
-            response = true;
-        } catch (Exception e) {
-            message = e.getMessage();
-            logger.error(EELFLoggerDelegate.errorLogger, "saveRoleForApplication failed", e);
-        }
-        return new ExternalRequestFieldsValidator(response, message);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public boolean deleteRoleForApplication(String deleteRole, String uebkey) throws Exception {
-        Session localSession = sessionFactory.openSession();
-        Transaction transaction = null;
-        boolean result = false;
-        try {
-            List<EPRole> epRoleList = null;
-            EPApp app = getApp(uebkey).get(0);
-            final Map<String, String> deleteRoleParams = new HashMap<>();
-            deleteRoleParams.put(APP_ROLE_NAME_PARAM, deleteRole);
-            if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                epRoleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, deleteRoleParams, null);
-            } else {
-                deleteRoleParams.put(APP_ID, String.valueOf(app.getId()));
-                epRoleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
-                        deleteRoleParams, null);
-            }
-            if (!epRoleList.isEmpty()) {
-                transaction = localSession.beginTransaction();
-                // Delete app role functions before deleting role
-                deleteRoleFunction(app, epRoleList);
-                if (app.getId() == 1) {
-                    // Delete fn_user_ role
-                    dataAccessService.deleteDomainObjects(EPUserApp.class,
-                            APP_ID_EQUALS + app.getId() + " and role_id = " + epRoleList.get(0).getId(), null);
-                    boolean isPortalRequest = false;
-                    deleteRoleDependencyRecords(localSession, epRoleList.get(0).getId(), app.getId(), isPortalRequest);
-                }
-                deleteRoleInExternalAuthSystem(epRoleList, app);
-                transaction.commit();
-                logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleForApplication: committed the transaction");
-                dataAccessService.deleteDomainObject(epRoleList.get(0), null);
-            }
-            result = true;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleForApplication: failed", e);
-            result = false;
-        } finally {
-            localSession.close();
-        }
-        return result;
-    }
-
-    /**
-     * 
-     * It deletes role for application in external auth system
-     * 
-     * @param epRoleList contains role information
-     * @param app contains application information
-     * @throws Exception
-     */
-    private void deleteRoleInExternalAuthSystem(List<EPRole> epRoleList, EPApp app) throws Exception {
-        ResponseEntity<String> deleteResponse;
-        ResponseEntity<String> res = getNameSpaceIfExists(app);
-        if (res.getStatusCode() == HttpStatus.OK) {
-            // Delete Role in External System
-            String deleteRoleKey = "{\"name\":\"" + app.getNameSpace() + "." + epRoleList.get(0).getName()
-                    .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_") + "\"}";
-            deleteResponse = deleteRoleInExternalSystem(deleteRoleKey);
-            if (deleteResponse.getStatusCode().value() != 200 && deleteResponse.getStatusCode().value() != 404) {
-                EPLogUtil.logExternalAuthAccessAlarm(logger, deleteResponse.getStatusCode());
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "deleteRoleForApplication: Failed to delete role in external auth system! due to {} ",
-                        deleteResponse.getBody());
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleForApplication: about to commit the transaction");
-        }
-    }
-
-    /**
-     * 
-     * It deletes application user role in external auth system
-     * 
-     * @param role
-     * @param app
-     * @param LoginId
-     * @throws Exception
-     */
-    private void deleteUserRoleInExternalSystem(EPRole role, EPApp app, String LoginId) throws Exception {
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        getNameSpaceIfExists(app);
-        logger.debug(EELFLoggerDelegate.debugLogger, "deleteUserRoleInExternalSystem: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-        ResponseEntity<String> getResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole/"
-                        + LoginId
-                        + SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)
-                        + "/" + app.getNameSpace() + "."
-                        + role.getName()
-                                .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                HttpMethod.GET, entity, String.class);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "deleteUserRoleInExternalSystem: Finished GET user roles from External Auth system and response: {} ",
-                getResponse.getBody());
-        if (getResponse.getStatusCode().value() != 200) {
-            throw new ExternalAuthSystemException(getResponse.getBody());
-        }
-        String res = getResponse.getBody();
-        if (!res.equals(IS_EMPTY_JSON_STRING)) {
-            HttpEntity<String> userRoleentity = new HttpEntity<>(headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "deleteUserRoleInExternalSystem: {} ",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-            ResponseEntity<String> deleteResponse = template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole/"
-                            + LoginId
-                            + SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)
-                            + "/" + app.getNameSpace() + "."
-                            + role.getName().replaceAll(
-                                    EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                    HttpMethod.DELETE, userRoleentity, String.class);
-            if (deleteResponse.getStatusCode().value() != 200) {
-                throw new ExternalAuthSystemException("Failed to delete user role");
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "deleteUserRoleInExternalSystem: Finished deleting user role in External Auth system and status code: {} ",
-                    deleteResponse.getStatusCode().value());
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<CentralV2Role> getActiveRoles(String uebkey) throws Exception {
-        List<CentralV2Role> roleList = new ArrayList<>();
-        try {
-            List<EPApp> app = getApp(uebkey);
-            final Map<String, Long> params = new HashMap<>();
-            // check if portal
-            Long appId = null;
-            if (!app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                appId = app.get(0).getId();
-            }
-            List<Criterion> restrictionsList = new ArrayList<Criterion>();
-            Criterion active_ynCrt = Restrictions.eq("active", Boolean.TRUE);
-            Criterion appIdCrt;
-            if (appId == null)
-                appIdCrt = Restrictions.isNull("appId");
-            else
-                appIdCrt = Restrictions.eq("appId", appId);
-            Criterion andCrit = Restrictions.and(active_ynCrt, appIdCrt);
-            restrictionsList.add(andCrit);
-            List<EPRole> epRole = (List<EPRole>) dataAccessService.getList(EPRole.class, null, restrictionsList, null);
-            roleList = createCentralRoleObject(app, epRole, roleList, params);
-            List<CentralV2Role> globalRoleList = getGlobalRolesOfApplication(app.get(0).getId());
-            if (globalRoleList.size() > 0)
-                roleList.addAll(globalRoleList);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles: failed", e);
-            throw e;
-        }
-        return roleList;
-    }
-
-    @Override
-    @Transactional(rollbackFor = Exception.class)
-    public ExternalRequestFieldsValidator deleteDependencyRoleRecord(Long roleId, String uebkey, String LoginId)
-            throws Exception {
-        Session localSession = sessionFactory.openSession();
-        String message = "";
-        Transaction transaction = null;
-        boolean response = false;
-        EPApp app = null;
-        try {
-            transaction = localSession.beginTransaction();
-            List<EPRole> epRoleList = null;
-            app = getApp(uebkey).get(0);
-            if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                epRoleList = getPortalAppRoleInfo(roleId);
-            } else {
-                epRoleList = getPartnerAppRoleInfo(roleId, app);
-            }
-            if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                // Delete User Role in External System before deleting role
-                deleteUserRoleInExternalSystem(epRoleList.get(0), app, LoginId);
-            }
-            // Delete user app roles
-            dataAccessService.deleteDomainObjects(EPUserApp.class,
-                    APP_ID_EQUALS + app.getId() + " and role_id = " + epRoleList.get(0).getId(), null);
-            boolean isPortalRequest = false;
-            deleteRoleDependencyRecords(localSession, epRoleList.get(0).getId(), app.getId(), isPortalRequest);
-            transaction.commit();
-            if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
-                // Final call to delete role once all dependencies has been
-                // deleted
-                deleteRoleInExternalAuthSystem(epRoleList, app);
-            }
-            dataAccessService.deleteDomainObjects(EPRole.class, " role_id = " + epRoleList.get(0).getId(), null);
-            logger.debug(EELFLoggerDelegate.debugLogger, "deleteDependencyRoleRecord: committed the transaction");
-            response = true;
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord: HttpClientErrorException", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-            message = e.getMessage();
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
-            EcompPortalUtils.rollbackTransaction(transaction,
-                    "deleteDependencyRoleRecord rollback, exception = " + e.toString());
-            message = e.getMessage();
-        } finally {
-            localSession.close();
-        }
-        return new ExternalRequestFieldsValidator(response, message);
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    @Transactional
-    public void syncRoleFunctionFromExternalAccessSystem(EPApp app) {
-        try {
-            // get Permissions from External Auth System
-            JSONArray extPerms = getExtAuthPermissions(app);
-            List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPerms);
-            // get functions in DB
-            final Map<String, Long> params = new HashMap<>();
-            final Map<String, CentralV2RoleFunction> roleFuncMap = new HashMap<>();
-            params.put(APP_ID, app.getId());
-            List<CentralV2RoleFunction> appFunctions =
-                    dataAccessService.executeNamedQuery("getAllRoleFunctions", params, null);
-            if (!appFunctions.isEmpty()) {
-                for (CentralV2RoleFunction roleFunc : appFunctions) {
-                    roleFuncMap.put(roleFunc.getCode(), roleFunc);
-                }
-            }
-            // get Roles for portal in DB
-            List<EPRole> portalRoleList = getGlobalRolesOfPortal();
-            final Map<String, EPRole> existingPortalRolesMap = new HashMap<>();
-            for (EPRole epRole : portalRoleList) {
-                existingPortalRolesMap.put(epRole.getName().replaceAll(
-                        EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), epRole);
-            }
-            // get Roles in DB
-            final Map<String, EPRole> currentRolesInDB = getAppRoleNamesWithUnderscoreMap(app);
-            // store External Permissions with Pipe and without Pipe (just
-            // instance)
-            final Map<String, ExternalAccessPermsDetail> extAccessPermsContainsPipeMap = new HashMap<>();
-            final Map<String, ExternalAccessPermsDetail> extAccessPermsMap = new HashMap<>();
-            for (ExternalAccessPermsDetail permsDetailInfoWithPipe : permsDetailList) {
-                extAccessPermsContainsPipeMap.put(permsDetailInfoWithPipe.getInstance(), permsDetailInfoWithPipe);
-                String finalFunctionCodeVal = EcompPortalUtils.getFunctionCode(permsDetailInfoWithPipe.getInstance());
-                extAccessPermsMap.put(finalFunctionCodeVal, permsDetailInfoWithPipe);
-            }
-            // Add if new functions and app role functions were added in
-            // external auth system
-            for (ExternalAccessPermsDetail permsDetail : permsDetailList) {
-                String code = permsDetail.getInstance();
-                CentralV2RoleFunction getFunctionCodeKey = roleFuncMap.get(permsDetail.getInstance());
-                List<CentralV2RoleFunction> roleFunctionList =
-                        addGetLocalFunction(app, roleFuncMap, permsDetail, code, getFunctionCodeKey);
-                List<String> roles = permsDetail.getRoles();
-                if (roles != null) {
-                    // Check if function has any roles and which does not exist
-                    // in External Auth System. If exists delete in local
-                    addRemoveIfFunctionsRolesIsSyncWithExternalAuth(app, currentRolesInDB, roleFunctionList, roles,
-                            existingPortalRolesMap);
-                }
-            }
-            // Check if function does exits in External Auth System but exits in
-            // local then delete function and its dependencies
-            for (CentralV2RoleFunction roleFunc : appFunctions) {
-                try {
-                    ExternalAccessPermsDetail getFunctionCodeContainsPipeKey =
-                            extAccessPermsContainsPipeMap.get(roleFunc.getCode());
-                    if (null == getFunctionCodeContainsPipeKey) {
-                        ExternalAccessPermsDetail getFunctionCodeKey = extAccessPermsMap.get(roleFunc.getCode());
-                        if (null == getFunctionCodeKey) {
-                            deleteAppRoleFuncDoesNotExitsInExtSystem(app, roleFunc);
-                        }
-                    }
-                } catch (Exception e) {
-                    logger.error(EELFLoggerDelegate.errorLogger,
-                            "syncRoleFunctionFromExternalAccessSystem: Failed to delete function", e);
-                }
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "syncRoleFunctionFromExternalAccessSystem: Finished syncRoleFunctionFromExternalAccessSystem");
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "syncRoleFunctionFromExternalAccessSystem: Failed syncRoleFunctionFromExternalAccessSystem", e);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private void addRemoveIfFunctionsRolesIsSyncWithExternalAuth(EPApp app, final Map<String, EPRole> currentRolesInDB,
-            List<CentralV2RoleFunction> roleFunctionList, List<String> roles,
-            Map<String, EPRole> existingPortalRolesMap) throws Exception {
-        if (!roleFunctionList.isEmpty()) {
-            final Map<String, String> appRoleFuncParams = new HashMap<>();
-            final Map<String, LocalRole> currentAppRoleFunctionsMap = new HashMap<>();
-            final Map<String, String> currentRolesInExtSystem = new HashMap<>();
-            appRoleFuncParams.put("functionCd", roleFunctionList.get(0).getCode());
-            appRoleFuncParams.put("appId", String.valueOf(app.getId()));
-            List<LocalRole> localRoleList =
-                    dataAccessService.executeNamedQuery("getCurrentAppRoleFunctions", appRoleFuncParams, null);
-            for (LocalRole localRole : localRoleList) {
-                currentAppRoleFunctionsMap.put(localRole.getRolename().replaceAll(
-                        EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), localRole);
-            }
-            for (String addRole : roles) {
-                currentRolesInExtSystem.put(addRole.substring(addRole.indexOf(FUNCTION_PIPE) + 1), addRole);
-            }
-            for (String extAuthrole : roles) {
-                String roleNameSpace = extAuthrole.substring(0, extAuthrole.indexOf(FUNCTION_PIPE));
-                boolean isNameSpaceMatching =
-                        EcompPortalUtils.checkNameSpaceMatching(roleNameSpace, app.getNameSpace());
-                if (isNameSpaceMatching) {
-                    if (!currentAppRoleFunctionsMap
-                            .containsKey(extAuthrole.substring(app.getNameSpace().length() + 1))) {
-                        EPRole localAddFuntionRole =
-                                currentRolesInDB.get(extAuthrole.substring(app.getNameSpace().length() + 1));
-                        if (localAddFuntionRole == null) {
-                            checkAndAddRoleInDB(app, currentRolesInDB, roleFunctionList, extAuthrole);
-                        } else {
-                            EPAppRoleFunction addAppRoleFunc = new EPAppRoleFunction();
-                            addAppRoleFunc.setAppId(app.getId());
-                            addAppRoleFunc.setCode(roleFunctionList.get(0).getCode());
-                            addAppRoleFunc.setRoleId(localAddFuntionRole.getId());
-                            dataAccessService.saveDomainObject(addAppRoleFunc, null);
-                        }
-                    }
-                    // This block is to save global role function if exists
-                } else {
-                    String extAuthAppRoleName = extAuthrole.substring(extAuthrole.indexOf(FUNCTION_PIPE) + 1);
-                    boolean checkIfGlobalRoleExists = existingPortalRolesMap.containsKey(extAuthAppRoleName);
-                    if (checkIfGlobalRoleExists) {
-                        final Map<String, Long> params = new HashMap<>();
-                        EPRole role = existingPortalRolesMap.get(extAuthAppRoleName);
-                        EPAppRoleFunction addGlobalRoleFunctions = new EPAppRoleFunction();
-                        params.put("appId", app.getId());
-                        params.put("roleId", role.getId());
-                        List<EPAppRoleFunction> currentGlobalRoleFunctionsList =
-                                dataAccessService.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", params, null);
-                        boolean checkIfRoleFunctionExists = currentGlobalRoleFunctionsList.stream()
-                                .anyMatch(currentGlobalRoleFunction -> currentGlobalRoleFunction.getCode()
-                                        .equals(roleFunctionList.get(0).getCode()));
-                        if (role != null && !checkIfRoleFunctionExists) {
-                            addGlobalRoleFunctions.setAppId(app.getId());
-                            addGlobalRoleFunctions.setRoleId(role.getId());
-                            if (!app.getId().equals(role.getAppRoleId())) {
-                                addGlobalRoleFunctions.setRoleAppId((PortalConstants.PORTAL_APP_ID).toString());
-                            } else {
-                                addGlobalRoleFunctions.setRoleAppId(null);
-                            }
-                            addGlobalRoleFunctions.setCode(roleFunctionList.get(0).getCode());
-                            dataAccessService.saveDomainObject(addGlobalRoleFunctions, null);
-                        }
-                    }
-                }
-            }
-            for (LocalRole localRoleDelete : localRoleList) {
-                if (!currentRolesInExtSystem.containsKey(localRoleDelete.getRolename()
-                        .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"))) {
-                    dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
-                            APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunctionList.get(0).getCode()
-                                    + "'" + " and role_id = " + localRoleDelete.getRoleId().longValue(),
-                            null);
-                }
-            }
-        }
-    }
-
-    private void deleteAppRoleFuncDoesNotExitsInExtSystem(EPApp app, CentralV2RoleFunction roleFunc) {
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncRoleFunctionFromExternalAccessSystem: Deleting app role function {}", roleFunc.getCode());
-        dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
-                APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunc.getCode() + "'", null);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncRoleFunctionFromExternalAccessSystem: Deleted app role function {}", roleFunc.getCode());
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncRoleFunctionFromExternalAccessSystem: Deleting app function {}", roleFunc.getCode());
-        dataAccessService.deleteDomainObjects(CentralV2RoleFunction.class,
-                APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunc.getCode() + "'", null);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncRoleFunctionFromExternalAccessSystem: Deleted app function {}", roleFunc.getCode());
-    }
-
-    private void checkAndAddRoleInDB(EPApp app, final Map<String, EPRole> currentRolesInDB,
-            List<CentralV2RoleFunction> roleFunctionList, String roleList) throws Exception {
-        if (!currentRolesInDB.containsKey(roleList.substring(app.getNameSpace().length() + 1))) {
-            Role role = addRoleInDBIfDoesNotExists(app, roleList.substring(app.getNameSpace().length() + 1));
-            addRoleDescriptionInExtSystem(role, app);
-            if (!roleFunctionList.isEmpty()) {
-                try {
-                    if (!roleFunctionList.isEmpty()) {
-                        EPAppRoleFunction addAppRoleFunc = new EPAppRoleFunction();
-                        addAppRoleFunc.setAppId(app.getId());
-                        addAppRoleFunc.setCode(roleFunctionList.get(0).getCode());
-                        addAppRoleFunc.setRoleId(role.getId());
-                        dataAccessService.saveDomainObject(addAppRoleFunc, null);
-                    }
-                } catch (Exception e) {
-                    logger.error(EELFLoggerDelegate.errorLogger,
-                            "syncRoleFunctionFromExternalAccessSystem: Failed to save app role function ", e);
-                }
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private List<CentralV2RoleFunction> addGetLocalFunction(EPApp app,
-            final Map<String, CentralV2RoleFunction> roleFuncMap, ExternalAccessPermsDetail permsDetail, String code,
-            CentralV2RoleFunction getFunctionCodeKey) {
-        String finalFunctionCodeVal =
-                addToLocalIfFunctionNotExists(app, roleFuncMap, permsDetail, code, getFunctionCodeKey);
-        final Map<String, String> appSyncFuncsParams = new HashMap<>();
-        appSyncFuncsParams.put("appId", String.valueOf(app.getId()));
-        appSyncFuncsParams.put("functionCd", finalFunctionCodeVal);
-        List<CentralV2RoleFunction> roleFunctionList = null;
-        roleFunctionList =
-                dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, null);
-        if (roleFunctionList.isEmpty()) {
-            appSyncFuncsParams.put("functionCd", code);
-            roleFunctionList =
-                    dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams, null);
-        }
-        return roleFunctionList;
-    }
-
-    private String addToLocalIfFunctionNotExists(EPApp app, final Map<String, CentralV2RoleFunction> roleFuncMap,
-            ExternalAccessPermsDetail permsDetail, String code, CentralV2RoleFunction getFunctionCodeKey) {
-        String finalFunctionCodeVal = "";
-        if (null == getFunctionCodeKey) {
-            finalFunctionCodeVal = EcompPortalUtils.getFunctionCode(permsDetail.getInstance());
-            CentralV2RoleFunction checkIfCodeStillExits = roleFuncMap.get(finalFunctionCodeVal);
-            // If function does not exist in local then add!
-            if (null == checkIfCodeStillExits) {
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "syncRoleFunctionFromExternalAccessSystem: Adding function: {} ", code);
-                addFunctionInEcompDB(app, permsDetail, code);
-                logger.debug(EELFLoggerDelegate.debugLogger,
-                        "syncRoleFunctionFromExternalAccessSystem: Finished adding function: {} ", code);
-            }
-        }
-        return finalFunctionCodeVal;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public Map<String, EPRole> getAppRoleNamesWithUnderscoreMap(EPApp app) {
-        final Map<String, EPRole> currentRolesInDB = new HashMap<>();
-        List<EPRole> getCurrentRoleList = null;
-        final Map<String, Long> appParams = new HashMap<>();
-        if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-            getCurrentRoleList = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
-        } else {
-            appParams.put("appId", app.getId());
-            getCurrentRoleList = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
-        }
-        for (EPRole role : getCurrentRoleList) {
-            currentRolesInDB.put(role.getName()
-                    .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), role);
-        }
-        return currentRolesInDB;
-    }
-
-    @SuppressWarnings("unchecked")
-    private Map<String, EPRole> getAppRoleNamesMap(EPApp app) {
-        final Map<String, EPRole> currentRolesInDB = new HashMap<>();
-        List<EPRole> getCurrentRoleList = null;
-        final Map<String, Long> appParams = new HashMap<>();
-        if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-            getCurrentRoleList = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
-        } else {
-            appParams.put("appId", app.getId());
-            getCurrentRoleList = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
-        }
-        for (EPRole role : getCurrentRoleList) {
-            currentRolesInDB.put(role.getName(), role);
-        }
-        return currentRolesInDB;
-    }
-
-    private List<ExternalAccessPermsDetail> getExtAuthPerrmissonList(EPApp app, JSONArray extPerms) throws IOException {
-        ExternalAccessPermsDetail permDetails = null;
-        List<ExternalAccessPermsDetail> permsDetailList = new ArrayList<>();
-        for (int i = 0; i < extPerms.length(); i++) {
-            String description = null;
-            if (extPerms.getJSONObject(i).has("description")) {
-                description = extPerms.getJSONObject(i).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
-            } else {
-                description = extPerms.getJSONObject(i).getString("type") + "|"
-                        + extPerms.getJSONObject(i).getString("instance") + "|"
-                        + extPerms.getJSONObject(i).getString("action");
-            }
-            if (extPerms.getJSONObject(i).has("roles")) {
-                ObjectMapper rolesListMapper = new ObjectMapper();
-                JSONArray resRoles = extPerms.getJSONObject(i).getJSONArray("roles");
-                List<String> list = rolesListMapper.readValue(resRoles.toString(),
-                        TypeFactory.defaultInstance().constructCollectionType(List.class, String.class));
-                permDetails = new ExternalAccessPermsDetail(extPerms.getJSONObject(i).getString("type"),
-                        extPerms.getJSONObject(i).getString("type").substring(app.getNameSpace().length() + 1)
-                                + FUNCTION_PIPE + extPerms.getJSONObject(i).getString("instance") + FUNCTION_PIPE
-                                + extPerms.getJSONObject(i).getString("action"),
-                        extPerms.getJSONObject(i).getString("action"), list, description);
-                permsDetailList.add(permDetails);
-            } else {
-                permDetails = new ExternalAccessPermsDetail(extPerms.getJSONObject(i).getString("type"),
-                        extPerms.getJSONObject(i).getString("type").substring(app.getNameSpace().length() + 1)
-                                + FUNCTION_PIPE + extPerms.getJSONObject(i).getString("instance") + FUNCTION_PIPE
-                                + extPerms.getJSONObject(i).getString("action"),
-                        extPerms.getJSONObject(i).getString("action"), description);
-                permsDetailList.add(permDetails);
-            }
-        }
-        return permsDetailList;
-    }
-
-    private JSONArray getExtAuthPermissions(EPApp app) throws Exception {
-        ResponseEntity<String> response = null;
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-        response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                + "perms/ns/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
-        String res = response.getBody();
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncRoleFunctionFromExternalAccessSystem: Finished GET permissions from External Auth system and response: {} ",
-                response.getBody());
-        JSONObject jsonObj = new JSONObject(res);
-        JSONArray extPerms = jsonObj.getJSONArray("perm");
-        for (int i = 0; i < extPerms.length(); i++) {
-            if (extPerms.getJSONObject(i).getString("type").equals(app.getNameSpace() + ".access")) {
-                extPerms.remove(i);
-                i--;
-            }
-        }
-        return extPerms;
-    }
-
-    /**
-     * 
-     * Add function into local DB
-     * 
-     * @param app
-     * @param permsDetail
-     * @param code
-     */
-    private void addFunctionInEcompDB(EPApp app, ExternalAccessPermsDetail permsDetail, String code) {
-        try {
-            CentralV2RoleFunction addFunction = new CentralV2RoleFunction();
-            addFunction.setAppId(app.getId());
-            addFunction.setCode(code);
-            addFunction.setName(permsDetail.getDescription());
-            dataAccessService.saveDomainObject(addFunction, null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addFunctionInEcompDB: Failed to add function", e);
-        }
-    }
-
-    /**
-     * 
-     * It updates description of a role in external auth system
-     * 
-     * @param role
-     * @param app
-     * @throws Exception
-     */
-    private boolean addRoleDescriptionInExtSystem(Role role, EPApp app) throws Exception {
-        boolean status = false;
-        try {
-            String addRoleNew = updateExistingRoleInExternalSystem(role, app);
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            HttpEntity<String> entity = new HttpEntity<>(addRoleNew, headers);
-            template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
-                    HttpMethod.PUT, entity, String.class);
-            status = true;
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to addRoleDescriptionInExtSystem", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addRoleDescriptionInExtSystem: Failed", e);
-        }
-        return status;
-    }
-
-    /**
-     * 
-     * While sync functions form external auth system if new role found we should add in local and
-     * return Role.class object
-     * 
-     * @param app
-     * @param role
-     * @return
-     */
-    @SuppressWarnings("unchecked")
-    private Role addRoleInDBIfDoesNotExists(EPApp app, String role) {
-        Role setNewRole = new Role();
-        try {
-            // functions can have new role created in External Auth System
-            // prevent
-            // duplication here
-            boolean isCreated = checkIfRoleExitsElseCreateInSyncFunctions(role, app);
-            final Map<String, String> getRoleByNameParams = new HashMap<>();
-            List<EPRole> getRoleCreated = null;
-            getRoleByNameParams.put(APP_ROLE_NAME_PARAM, role);
-            if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                getRoleByNameParams.put("appId", String.valueOf(app.getId()));
-                List<EPRole> roleCreated = dataAccessService
-                        .executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, getRoleByNameParams, null);
-                if (!isCreated) {
-                    EPRole epUpdateRole = roleCreated.get(0);
-                    epUpdateRole.setAppRoleId(epUpdateRole.getId());
-                    dataAccessService.saveDomainObject(epUpdateRole, null);
-                    getRoleCreated = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
-                            getRoleByNameParams, null);
-                } else {
-                    getRoleCreated = roleCreated;
-                }
-            } else {
-                getRoleCreated =
-                        dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, getRoleByNameParams, null);
-            }
-            if (getRoleCreated != null && !getRoleCreated.isEmpty()) {
-                EPRole roleObject = getRoleCreated.get(0);
-                setNewRole.setId(roleObject.getId());
-                setNewRole.setName(roleObject.getName());
-                setNewRole.setActive(roleObject.getActive());
-                setNewRole.setPriority(roleObject.getPriority());
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "addRoleInDBIfDoesNotExists: Failed", e);
-        }
-        return setNewRole;
-    }
-
-    @SuppressWarnings("unchecked")
-    private boolean checkIfRoleExitsElseCreateInSyncFunctions(String role, EPApp app) {
-        boolean isCreated = false;
-        final Map<String, String> roleParams = new HashMap<>();
-        roleParams.put(APP_ROLE_NAME_PARAM, role);
-        List<EPRole> roleCreated = null;
-        if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-            roleCreated = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, roleParams, null);
-        } else {
-            roleParams.put("appId", String.valueOf(app.getId()));
-            roleCreated =
-                    dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, roleParams, null);
-        }
-        if (roleCreated == null || roleCreated.isEmpty()) {
-            roleParams.put("appId", String.valueOf(app.getId()));
-            EPRole epRoleNew = new EPRole();
-            epRoleNew.setActive(true);
-            epRoleNew.setName(role);
-            if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                epRoleNew.setAppId(null);
-            } else {
-                epRoleNew.setAppId(app.getId());
-            }
-            dataAccessService.saveDomainObject(epRoleNew, null);
-            isCreated = false;
-        } else {
-            isCreated = true;
-        }
-        return isCreated;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public Integer bulkUploadFunctions(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        List<RoleFunction> roleFuncList = dataAccessService.executeNamedQuery("getAllFunctions", null, null);
-        CentralV2RoleFunction cenRoleFunc = null;
-        Integer functionsAdded = 0;
-        try {
-            for (RoleFunction roleFunc : roleFuncList) {
-                cenRoleFunc = new CentralV2RoleFunction(roleFunc.getCode(), roleFunc.getName());
-                addRoleFunctionInExternalSystem(cenRoleFunc, app);
-                functionsAdded++;
-            }
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - bulkUploadFunctions failed", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions: failed", e.getMessage(), e);
-        }
-        return functionsAdded;
-    }
-
-    @Override
-    public Integer bulkUploadRoles(String uebkey) throws Exception {
-        List<EPApp> app = getApp(uebkey);
-        List<EPRole> roles = getAppRoles(app.get(0).getId());
-        List<CentralV2Role> cenRoleList = new ArrayList<>();
-        final Map<String, Long> params = new HashMap<>();
-        Integer rolesListAdded = 0;
-        try {
-            cenRoleList = createCentralRoleObject(app, roles, cenRoleList, params);
-            ObjectMapper mapper = new ObjectMapper();
-            mapper.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false);
-            String roleList = mapper.writeValueAsString(cenRoleList);
-            List<Role> roleObjectList = mapper.readValue(roleList,
-                    TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
-            for (Role role : roleObjectList) {
-                addRoleInExternalSystem(role, app.get(0));
-                rolesListAdded++;
-            }
-            if (!app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                // Add Account Admin role in External AUTH System
-                try {
-                    String addAccountAdminRole = "";
-                    ExternalAccessRole extRole = new ExternalAccessRole();
-                    extRole.setName(app.get(0).getNameSpace() + "." + PortalConstants.ADMIN_ROLE
-                            .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-                    addAccountAdminRole = mapper.writeValueAsString(extRole);
-                    HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-                    HttpEntity<String> entity = new HttpEntity<>(addAccountAdminRole, headers);
-                    template.exchange(
-                            SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
-                            HttpMethod.POST, entity, String.class);
-                    rolesListAdded++;
-                } catch (HttpClientErrorException e) {
-                    logger.error(EELFLoggerDelegate.errorLogger,
-                            "HttpClientErrorException - Failed to create Account Admin role", e);
-                    EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-                } catch (Exception e) {
-                    if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
-                        logger.error(EELFLoggerDelegate.errorLogger,
-                                "bulkUploadRoles: Account Admin Role already exits but does not break functionality",
-                                e);
-                    } else {
-                        logger.error(EELFLoggerDelegate.errorLogger,
-                                "bulkUploadRoles: Failed to create Account Admin role", e.getMessage());
-                    }
-                }
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles: failed", e);
-            throw e;
-        }
-        return rolesListAdded;
-    }
-
-    /**
-     * It creating new role in external auth system while doing bulk upload
-     * 
-     * @param role
-     * @param app
-     * @throws Exception
-     */
-    private void addRoleInExternalSystem(Role role, EPApp app) throws Exception {
-        String addRoleNew = updateExistingRoleInExternalSystem(role, app);
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        try {
-            HttpEntity<String> entity = new HttpEntity<>(addRoleNew, headers);
-            template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
-                    HttpMethod.POST, entity, String.class);
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - Failed to addRoleInExternalSystem",
-                    e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleInExternalSystem: Role already exits but does not break functionality", e);
-            } else {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleInExternalSystem: Failed to addRoleInExternalSystem", e.getMessage());
-            }
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public Integer bulkUploadRolesFunctions(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        List<EPRole> roles = getAppRoles(app.getId());
-        final Map<String, Long> params = new HashMap<>();
-        Integer roleFunctions = 0;
-        try {
-            for (EPRole role : roles) {
-                params.put("roleId", role.getId());
-                List<BulkUploadRoleFunction> appRoleFunc =
-                        dataAccessService.executeNamedQuery("uploadAllRoleFunctions", params, null);
-                if (!appRoleFunc.isEmpty()) {
-                    for (BulkUploadRoleFunction addRoleFunc : appRoleFunc) {
-                        addRoleFunctionsInExternalSystem(addRoleFunc, role, app);
-                        roleFunctions++;
-                    }
-                }
-            }
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to bulkUploadRolesFunctions", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRolesFunctions: failed", e);
-        }
-        return roleFunctions;
-    }
-
-    /**
-     * Its adding a role function while doing bulk upload
-     * 
-     * @param addRoleFunc
-     * @param role
-     * @param app
-     */
-    private void addRoleFunctionsInExternalSystem(BulkUploadRoleFunction addRoleFunc, EPRole role, EPApp app) {
-        String type = "";
-        String instance = "";
-        String action = "";
-        if (addRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
-            type = EcompPortalUtils.getFunctionType(addRoleFunc.getFunctionCd());
-            instance = EcompPortalUtils.getFunctionCode(addRoleFunc.getFunctionCd());
-            action = EcompPortalUtils.getFunctionAction(addRoleFunc.getFunctionCd());
-        } else {
-            type = addRoleFunc.getFunctionCd().contains("menu") ? "menu" : "url";
-            instance = addRoleFunc.getFunctionCd();
-            action = "*";
-        }
-        ExternalAccessRolePerms extRolePerms = null;
-        ExternalAccessPerms extPerms = null;
-        ObjectMapper mapper = new ObjectMapper();
-        try {
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, instance, action,
-                    addRoleFunc.getFunctionName());
-            extRolePerms = new ExternalAccessRolePerms(extPerms, app.getNameSpace() + "." + role.getName()
-                    .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-            String updateRolePerms = mapper.writeValueAsString(extRolePerms);
-            HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-            template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
-                    HttpMethod.POST, entity, String.class);
-        } catch (Exception e) {
-            if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleFunctionsInExternalSystem: RoleFunction already exits but does not break functionality",
-                        e);
-            } else {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addRoleFunctionsInExternalSystem: Failed to addRoleFunctionsInExternalSystem", e.getMessage());
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public Integer bulkUploadPartnerFunctions(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        final Map<String, Long> params = new HashMap<>();
-        params.put("appId", app.getId());
-        List<CentralV2RoleFunction> roleFuncList =
-                dataAccessService.executeNamedQuery("getPartnerAppFunctions", params, null);
-        Integer functionsAdded = 0;
-        try {
-            for (CentralV2RoleFunction roleFunc : roleFuncList) {
-                addFunctionInExternalSystem(roleFunc, app);
-                functionsAdded++;
-            }
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - bulkUploadPartnerFunctions failed",
-                    e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerFunctions: failed", e.getMessage(), e);
-        }
-        return functionsAdded;
-    }
-
-    private void addFunctionInExternalSystem(CentralV2RoleFunction roleFunc, EPApp app) throws Exception {
-        ObjectMapper mapper = new ObjectMapper();
-        ExternalAccessPerms extPerms = new ExternalAccessPerms();
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        String type = "";
-        String instance = "";
-        String action = "";
-        if ((roleFunc.getCode().contains(FUNCTION_PIPE))
-                || (roleFunc.getType() != null && roleFunc.getAction() != null)) {
-            type = EcompPortalUtils.getFunctionType(roleFunc.getCode());
-            instance = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-            action = EcompPortalUtils.getFunctionAction(roleFunc.getCode());
-        } else {
-            type = roleFunc.getCode().contains("menu") ? "menu" : "url";
-            instance = roleFunc.getCode();
-            action = "*";
-        }
-        try {
-            extPerms.setAction(action);
-            extPerms.setInstance(instance);
-            extPerms.setType(app.getNameSpace() + "." + type);
-            extPerms.setDescription(roleFunc.getName());
-            String addFunction = mapper.writeValueAsString(extPerms);
-            HttpEntity<String> entity = new HttpEntity<>(addFunction, headers);
-            logger.debug(EELFLoggerDelegate.debugLogger, "addFunctionInExternalSystem: {} for POST: {}",
-                    CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addFunction);
-            ResponseEntity<String> addPermResponse = template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
-                    HttpMethod.POST, entity, String.class);
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "addFunctionInExternalSystem: Finished adding permission for POST: {} and status code: {} ",
-                    addPermResponse.getStatusCode().value(), addFunction);
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to add function in external central auth system", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-            throw e;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "addFunctionInExternalSystem: Failed to add fucntion in external central auth system", e);
-            throw e;
-        }
-    }
-
-    @Override
-    public void bulkUploadPartnerRoles(String uebkey, List<Role> roleList) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        for (Role role : roleList) {
-            addRoleInExternalSystem(role, app);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public Integer bulkUploadPartnerRoleFunctions(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        List<EPRole> roles = getAppRoles(app.getId());
-        final Map<String, Long> params = new HashMap<>();
-        Integer roleFunctions = 0;
-        try {
-            for (EPRole role : roles) {
-                params.put("roleId", role.getId());
-                List<BulkUploadRoleFunction> appRoleFunc =
-                        dataAccessService.executeNamedQuery("uploadPartnerRoleFunctions", params, null);
-                if (!appRoleFunc.isEmpty()) {
-                    for (BulkUploadRoleFunction addRoleFunc : appRoleFunc) {
-                        addRoleFunctionsInExternalSystem(addRoleFunc, role, app);
-                        roleFunctions++;
-                    }
-                }
-            }
-            // upload global role functions to ext auth system
-            if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                roleFunctions = bulkUploadGlobalRoleFunctions(app, roleFunctions);
-            }
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to bulkUploadRolesFunctions", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRolesFunctions: failed", e);
-        }
-        return roleFunctions;
-    }
-
-    @SuppressWarnings("unchecked")
-    private Integer bulkUploadGlobalRoleFunctions(EPApp app, Integer roleFunctions) throws Exception {
-        try {
-            EPApp portalApp = epAppService.getApp(1l);
-            final Map<String, Long> params = new HashMap<>();
-            params.put("appId", app.getId());
-            List<GlobalRoleWithApplicationRoleFunction> globalRoleFuncs =
-                    dataAccessService.executeNamedQuery("getBulkUploadPartnerGlobalRoleFunctions", params, null);
-            ObjectMapper mapper = new ObjectMapper();
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            for (GlobalRoleWithApplicationRoleFunction globalRoleFunc : globalRoleFuncs) {
-                ExternalAccessRolePerms extRolePerms;
-                ExternalAccessPerms extPerms;
-                String type = "";
-                String instance = "";
-                String action = "";
-                if (globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
-                    type = EcompPortalUtils.getFunctionType(globalRoleFunc.getFunctionCd());
-                    instance = EcompPortalUtils.getFunctionCode(globalRoleFunc.getFunctionCd());
-                    action = EcompPortalUtils.getFunctionAction(globalRoleFunc.getFunctionCd());
-                } else {
-                    type = globalRoleFunc.getFunctionCd().contains("menu") ? "menu" : "url";
-                    instance = globalRoleFunc.getFunctionCd();
-                    action = "*";
-                }
-                extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, instance, action);
-                extRolePerms = new ExternalAccessRolePerms(extPerms,
-                        portalApp.getNameSpace() + "." + globalRoleFunc.getRoleName().replaceAll(
-                                EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-                String updateRolePerms = mapper.writeValueAsString(extRolePerms);
-                HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-                updateRoleFunctionInExternalSystem(updateRolePerms, entity);
-                roleFunctions++;
-            }
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to add role function in external central auth system", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-            throw e;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "bulkUploadGlobalRoleFunctions: Failed to add role fucntion in external central auth system", e);
-            throw e;
-        }
-        return roleFunctions;
-    }
-
-    @Override
-    @Transactional
-    public void syncApplicationRolesWithEcompDB(EPApp app) {
-        try {
-            logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: Started");
-            // Sync functions and roles assigned to it which also creates new roles if does
-            // not exits in portal
-            syncRoleFunctionFromExternalAccessSystem(app);
-            logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: Finished");
-            ObjectMapper mapper = new ObjectMapper();
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering to getAppRolesJSONFromExtAuthSystem");
-            // Get Permissions from External Auth System
-            JSONArray extRole = getAppRolesJSONFromExtAuthSystem(app);
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering into getExternalRoleDetailsList");
-            // refactoring done
-            List<ExternalRoleDetails> externalRoleDetailsList = getExternalRoleDetailsList(app, mapper, extRole);
-            List<EPRole> finalRoleList = new ArrayList<>();
-            for (ExternalRoleDetails externalRole : externalRoleDetailsList) {
-                EPRole ecompRole = convertExternalRoleDetailstoEpRole(externalRole);
-                finalRoleList.add(ecompRole);
-            }
-            List<EPRole> applicationRolesList;
-            applicationRolesList = getAppRoles(app.getId());
-            List<String> applicationRoleIdList = new ArrayList<>();
-            for (EPRole applicationRole : applicationRolesList) {
-                applicationRoleIdList.add(applicationRole.getName());
-            }
-            List<EPRole> roleListToBeAddInEcompDB = new ArrayList<>();
-            for (EPRole aafRole : finalRoleList) {
-                if (!applicationRoleIdList.contains(aafRole.getName())) {
-                    roleListToBeAddInEcompDB.add(aafRole);
-                }
-            }
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering into inactiveRolesNotInExternalAuthSystem");
-            // Check if roles exits in external Access system and if not make inactive in DB
-            inactiveRolesNotInExternalAuthSystem(app, finalRoleList, applicationRolesList);
-            logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addNewRoleInEcompDBUpdateDescInExtAuthSystem");
-            // Add new roles in DB and updates role description in External Auth System
-            addNewRoleInEcompDBUpdateDescInExtAuthSystem(app, roleListToBeAddInEcompDB);
-            logger.debug(EELFLoggerDelegate.debugLogger, "syncApplicationRolesWithEcompDB: Finished");
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "syncApplicationRolesWithEcompDB: Failed due to the External Auth System", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "syncApplicationRolesWithEcompDB: Failed ", e);
-        }
-    }
-
-    /**
-     * 
-     * It adds new roles in DB and updates description in External Auth System
-     * 
-     * @param app
-     * @param roleListToBeAddInEcompDB
-     */
-    @SuppressWarnings("unchecked")
-    private void addNewRoleInEcompDBUpdateDescInExtAuthSystem(EPApp app, List<EPRole> roleListToBeAddInEcompDB) {
-        EPRole roleToBeAddedInEcompDB;
-        for (int i = 0; i < roleListToBeAddInEcompDB.size(); i++) {
-            try {
-                roleToBeAddedInEcompDB = roleListToBeAddInEcompDB.get(i);
-                if (app.getId() == 1) {
-                    roleToBeAddedInEcompDB.setAppRoleId(null);
-                }
-                dataAccessService.saveDomainObject(roleToBeAddedInEcompDB, null);
-                List<EPRole> getRoleCreatedInSync = null;
-                if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
-                    final Map<String, String> globalRoleParams = new HashMap<>();
-                    globalRoleParams.put("appId", String.valueOf(app.getId()));
-                    globalRoleParams.put("appRoleName", roleToBeAddedInEcompDB.getName());
-                    getRoleCreatedInSync = dataAccessService
-                            .executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, globalRoleParams, null);
-                    EPRole epUpdateRole = getRoleCreatedInSync.get(0);
-                    epUpdateRole.setAppRoleId(epUpdateRole.getId());
-                    dataAccessService.saveDomainObject(epUpdateRole, null);
-                }
-                List<EPRole> roleList = new ArrayList<>();
-                final Map<String, String> params = new HashMap<>();
-                params.put(APP_ROLE_NAME_PARAM, roleToBeAddedInEcompDB.getName());
-                boolean isPortalRole = false;
-                if (app.getId() == 1) {
-                    isPortalRole = true;
-                    roleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, params, null);
-                } else {
-                    isPortalRole = false;
-                    params.put(APP_ID, app.getId().toString());
-                    roleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, params,
-                            null);
-                }
-                EPRole role = roleList.get(0);
-                Role aaFrole = new Role();
-                aaFrole.setId(role.getId());
-                aaFrole.setActive(role.getActive());
-                aaFrole.setPriority(role.getPriority());
-                aaFrole.setName(role.getName());
-                updateRoleInExternalSystem(aaFrole, app, isPortalRole);
-            } catch (Exception e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "SyncApplicationRolesWithEcompDB: Failed to add or update role in external auth system", e);
-            }
-        }
-    }
-
-    /**
-     * 
-     * It checks description in External Auth System if found any changes updates in DB
-     * 
-     * @param app
-     * @param finalRoleList contains list of External Auth System roles list which is converted to
-     *        EPRole
-     */
-    @SuppressWarnings("unchecked")
-    private void checkAndUpdateRoleInDB(EPApp app, List<EPRole> finalRoleList) {
-        for (EPRole roleItem : finalRoleList) {
-            final Map<String, String> roleParams = new HashMap<>();
-            List<EPRole> currentList = null;
-            roleParams.put(APP_ROLE_NAME_PARAM, roleItem.getName());
-            if (app.getId() == 1) {
-                currentList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, roleParams, null);
-            } else {
-                roleParams.put(APP_ID, app.getId().toString());
-                currentList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
-                        roleParams, null);
-            }
-            if (!currentList.isEmpty()) {
-                try {
-                    Boolean aafRoleActive;
-                    Boolean localRoleActive;
-                    boolean result;
-                    aafRoleActive = Boolean.valueOf(roleItem.getActive());
-                    localRoleActive = Boolean.valueOf(currentList.get(0).getActive());
-                    result = aafRoleActive.equals(localRoleActive);
-                    EPRole updateRole = currentList.get(0);
-                    if (!result) {
-                        updateRole.setActive(roleItem.getActive());
-                        dataAccessService.saveDomainObject(updateRole, null);
-                    }
-                    if (roleItem.getPriority() != null
-                            && !currentList.get(0).getPriority().equals(roleItem.getPriority())) {
-                        updateRole.setPriority(roleItem.getPriority());
-                        dataAccessService.saveDomainObject(updateRole, null);
-                    }
-                } catch (Exception e) {
-                    logger.error(EELFLoggerDelegate.errorLogger,
-                            "syncApplicationRolesWithEcompDB: Failed to update role ", e);
-                }
-            }
-        }
-    }
-
-    /**
-     * 
-     * It de-activates application roles in DB if not present in External Auth system
-     * 
-     * @param app
-     * @param finalRoleList contains list of current roles present in External Auth System
-     * @param applicationRolesList contains list of current roles present in DB
-     */
-    @SuppressWarnings("unchecked")
-    private void inactiveRolesNotInExternalAuthSystem(EPApp app, List<EPRole> finalRoleList,
-            List<EPRole> applicationRolesList) {
-        final Map<String, EPRole> checkRolesInactive = new HashMap<>();
-        for (EPRole extrole : finalRoleList) {
-            checkRolesInactive.put(extrole.getName(), extrole);
-        }
-        for (EPRole role : applicationRolesList) {
-            try {
-                final Map<String, String> extRoleParams = new HashMap<>();
-                List<EPRole> roleList = null;
-                extRoleParams.put(APP_ROLE_NAME_PARAM, role.getName());
-                if (!checkRolesInactive.containsKey(role.getName()
-                        .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"))) {
-                    if (app.getId() == 1) {
-                        roleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, extRoleParams, null);
-                    } else {
-                        extRoleParams.put(APP_ID, app.getId().toString());
-                        roleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
-                                extRoleParams, null);
-                    }
-                    if (!roleList.isEmpty()) {
-                        EPRole updateRoleInactive = roleList.get(0);
-                        updateRoleInactive.setActive(false);
-                        dataAccessService.saveDomainObject(updateRoleInactive, null);
-                    }
-                }
-            } catch (Exception e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "syncApplicationRolesWithEcompDB: Failed to de-activate role ", e);
-            }
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public List<ExternalRoleDetails> getExternalRoleDetailsList(EPApp app, ObjectMapper mapper, JSONArray extRole)
-            throws IOException {
-        List<ExternalRoleDetails> externalRoleDetailsList = new ArrayList<>();
-        ExternalAccessPerms externalAccessPerms = new ExternalAccessPerms();
-        List<String> functionCodelist = new ArrayList<>();
-        Map<String, EPRole> curRolesMap = getAppRoleNamesMap(app);
-        Map<String, EPRole> curRolesUnderscoreMap = getAppRoleNamesWithUnderscoreMap(app);
-        for (int i = 0; i < extRole.length(); i++) {
-            ExternalRoleDetails externalRoleDetail = new ExternalRoleDetails();
-            EPAppRoleFunction ePAppRoleFunction = new EPAppRoleFunction();
-            JSONObject Role = (JSONObject) extRole.get(i);
-            String name = extRole.getJSONObject(i).getString(ROLE_NAME);
-            String actualRoleName = name.substring(app.getNameSpace().length() + 1);
-            if (extRole.getJSONObject(i).has(EXTERNAL_AUTH_ROLE_DESCRIPTION)) {
-                actualRoleName = extRole.getJSONObject(i).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
-            }
-            SortedSet<ExternalAccessPerms> externalAccessPermsOfRole = new TreeSet<>();
-            if (extRole.getJSONObject(i).has(EXTERNAL_AUTH_PERMS)) {
-                JSONArray extPerm = (JSONArray) Role.get(EXTERNAL_AUTH_PERMS);
-                for (int j = 0; j < extPerm.length(); j++) {
-                    JSONObject perms = extPerm.getJSONObject(j);
-                    boolean isNamespaceMatching =
-                            EcompPortalUtils.checkNameSpaceMatching(perms.getString("type"), app.getNameSpace());
-                    if (isNamespaceMatching) {
-                        externalAccessPerms = new ExternalAccessPerms(perms.getString("type"),
-                                perms.getString("instance"), perms.getString("action"));
-                        ePAppRoleFunction.setCode(externalAccessPerms.getInstance());
-                        functionCodelist.add(ePAppRoleFunction.getCode());
-                        externalAccessPermsOfRole.add(externalAccessPerms);
-                    }
-                }
-            }
-            externalRoleDetail.setActive(true);
-            externalRoleDetail.setName(actualRoleName);
-            if (app.getId() == 1) {
-                externalRoleDetail.setAppId(null);
-            } else {
-                externalRoleDetail.setAppId(app.getId());
-            }
-            EPRole currRole = null;
-            currRole = (!extRole.getJSONObject(i).has(EXTERNAL_AUTH_ROLE_DESCRIPTION))
-                    ? curRolesUnderscoreMap.get(actualRoleName)
-                    : curRolesMap.get(actualRoleName);
-            Long roleId = null;
-            if (currRole != null)
-                roleId = currRole.getId();
-            final Map<String, EPAppRoleFunction> roleFunctionsMap = new HashMap<>();
-            final Map<String, Long> appRoleFuncsParams = new HashMap<>();
-            if (roleId != null) {
-                appRoleFuncsParams.put("appId", app.getId());
-                appRoleFuncsParams.put("roleId", roleId);
-                // get role functions from DB
-                List<EPAppRoleFunction> appRoleFunctions = dataAccessService
-                        .executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null);
-                if (!appRoleFunctions.isEmpty()) {
-                    for (EPAppRoleFunction roleFunc : appRoleFunctions) {
-                        roleFunctionsMap.put(roleFunc.getCode(), roleFunc);
-                    }
-                }
-            }
-            if (!externalAccessPermsOfRole.isEmpty()) {
-                // Adding functions to role
-                for (ExternalAccessPerms externalpermission : externalAccessPermsOfRole) {
-                    EPAppRoleFunction checkRoleFunctionExits = roleFunctionsMap.get(externalpermission.getInstance());
-                    if (checkRoleFunctionExits == null) {
-                        String funcCode = externalpermission.getType().substring(app.getNameSpace().length() + 1)
-                                + FUNCTION_PIPE + externalpermission.getInstance() + FUNCTION_PIPE
-                                + externalpermission.getAction();
-                        EPAppRoleFunction checkRoleFunctionPipeExits = roleFunctionsMap.get(funcCode);
-                        if (checkRoleFunctionPipeExits == null) {
-                            try {
-                                final Map<String, String> appFuncsParams = new HashMap<>();
-                                appFuncsParams.put("appId", String.valueOf(app.getId()));
-                                appFuncsParams.put("functionCd", externalpermission.getInstance());
-                                logger.debug(EELFLoggerDelegate.debugLogger,
-                                        "SyncApplicationRolesWithEcompDB: Adding function to the role: {}",
-                                        externalpermission.getInstance());
-                                List<CentralV2RoleFunction> roleFunction = null;
-                                roleFunction = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId",
-                                        appFuncsParams, null);
-                                if (roleFunction.isEmpty()) {
-                                    appFuncsParams.put("functionCd", funcCode);
-                                    roleFunction = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId",
-                                            appFuncsParams, null);
-                                }
-                                if (!roleFunction.isEmpty()) {
-                                    EPAppRoleFunction apRoleFunction = new EPAppRoleFunction();
-                                    apRoleFunction.setAppId(app.getId());
-                                    apRoleFunction.setRoleId(roleId);
-                                    apRoleFunction.setCode(roleFunction.get(0).getCode());
-                                    dataAccessService.saveDomainObject(apRoleFunction, null);
-                                }
-                            } catch (Exception e) {
-                                logger.error(EELFLoggerDelegate.errorLogger,
-                                        "SyncApplicationRolesWithEcompDB: Failed to add role function", e);
-                            }
-                        }
-                    }
-                }
-            }
-            externalRoleDetailsList.add(externalRoleDetail);
-        }
-        return externalRoleDetailsList;
-    }
-
-    @Override
-    public JSONArray getAppRolesJSONFromExtAuthSystem(EPApp app) throws Exception {
-        ResponseEntity<String> response = null;
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "syncApplicationRolesWithEcompDB: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-        response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                + "roles/ns/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
-        String res = response.getBody();
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncApplicationRolesWithEcompDB: Finished GET roles from External Auth system and the result is :",
-                res);
-        JSONObject jsonObj = new JSONObject(res);
-        JSONArray extRole = jsonObj.getJSONArray("role");
-        for (int i = 0; i < extRole.length(); i++) {
-            if (extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + ADMIN)
-                    || extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + OWNER)
-                    || (extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + ACCOUNT_ADMINISTRATOR)
-                            && !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
-                extRole.remove(i);
-                i--;
-            }
-        }
-        return extRole;
-    }
-
-    @Override
-    public JSONArray getAllUsersByRole(String roleName) throws Exception {
-        ResponseEntity<String> response = null;
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "getAllUsersByRole: {} ",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
-        response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                + "userRoles/role/" + roleName, HttpMethod.GET, entity, String.class);
-        String res = response.getBody();
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "syncApplicationRolesWithEcompDB: Finished GET roles from External Auth system and the result is :",
-                res);
-        if (res == null || res.trim().isEmpty())
-            return null;
-        JSONObject jsonObj = new JSONObject(res);
-        JSONArray extRole = jsonObj.getJSONArray("userRole");
-        return extRole;
-    }
-
-    /**
-     * 
-     * It converts from ExternalRoleDetails.class object to EPRole.class object
-     * 
-     * @param externalRoleDetails
-     * @return EPRole object
-     */
-    private EPRole convertExternalRoleDetailstoEpRole(ExternalRoleDetails externalRoleDetails) {
-        EPRole role = new EPRole();
-        role.setActive(true);
-        role.setAppId(externalRoleDetails.getAppId());
-        role.setAppRoleId(externalRoleDetails.getAppRoleId());
-        role.setName(externalRoleDetails.getName());
-        role.setPriority(externalRoleDetails.getPriority());
-        return role;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public Integer bulkUploadUserRoles(String uebkey) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        final Map<String, String> params = new HashMap<>();
-        params.put("uebKey", app.getUebKey());
-        List<BulkUploadUserRoles> userRolesList = null;
-        Integer userRolesAdded = 0;
-        if (app.getCentralAuth()) {
-            userRolesList = dataAccessService.executeNamedQuery("getBulkUserRoles", params, null);
-            for (BulkUploadUserRoles userRolesUpload : userRolesList) {
-                if (!userRolesUpload.getOrgUserId().equals("su1234")) {
-                    addUserRoleInExternalSystem(userRolesUpload);
-                    userRolesAdded++;
-                }
-            }
-        }
-        return userRolesAdded;
-    }
-
-    /**
-     * Its adding a user role in external auth system while doing bulk upload
-     * 
-     * @param userRolesUpload
-     */
-    private void addUserRoleInExternalSystem(BulkUploadUserRoles userRolesUpload) {
-        try {
-            String name = "";
-            ObjectMapper mapper = new ObjectMapper();
-            if (EPCommonSystemProperties
-                    .containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) {
-                name = userRolesUpload.getOrgUserId()
-                        + SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN);
-            }
-            ExternalAccessUser extUser =
-                    new ExternalAccessUser(name, userRolesUpload.getAppNameSpace() + "." + userRolesUpload.getRoleName()
-                            .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-            String userRole = mapper.writeValueAsString(extUser);
-            HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-            HttpEntity<String> entity = new HttpEntity<>(userRole, headers);
-            template.exchange(
-                    SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole",
-                    HttpMethod.POST, entity, String.class);
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to addUserRoleInExternalSystem", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-        } catch (Exception e) {
-            if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addUserRoleInExternalSystem: UserRole already exits but does not break functionality");
-            } else {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addUserRoleInExternalSystem: Failed to addUserRoleInExternalSystem", e);
-            }
-        }
-    }
-
-    @Override
-    public void deleteRoleDependencyRecords(Session localSession, Long roleId, Long appId, boolean isPortalRequest)
-            throws Exception {
-        try {
-            String sql = "";
-            Query query = null;
-            // It should delete only when it portal's roleId
-            if (appId.equals(PortalConstants.PORTAL_APP_ID)) {
-                // Delete from fn_role_function
-                sql = "DELETE FROM fn_role_function WHERE role_id=" + roleId;
-                logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-                query = localSession.createSQLQuery(sql);
-                query.executeUpdate();
-                // Delete from fn_role_composite
-                sql = "DELETE FROM fn_role_composite WHERE parent_role_id=" + roleId + " OR child_role_id=" + roleId;
-                logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-                query = localSession.createSQLQuery(sql);
-                query.executeUpdate();
-            }
-            // Delete from ep_app_role_function
-            sql = "DELETE FROM ep_app_role_function WHERE role_id=" + roleId;
-            logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-            query = localSession.createSQLQuery(sql);
-            query.executeUpdate();
-            // Delete from ep_role_notification
-            sql = "DELETE FROM ep_role_notification WHERE role_id=" + roleId;
-            logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-            query = localSession.createSQLQuery(sql);
-            query.executeUpdate();
-            // Delete from fn_user_pseudo_role
-            sql = "DELETE FROM fn_user_pseudo_role WHERE pseudo_role_id=" + roleId;
-            logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-            query = localSession.createSQLQuery(sql);
-            query.executeUpdate();
-            // Delete form EP_WIDGET_CATALOG_ROLE
-            sql = "DELETE FROM EP_WIDGET_CATALOG_ROLE WHERE role_id=" + roleId;
-            logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-            query = localSession.createSQLQuery(sql);
-            query.executeUpdate();
-            // Delete form EP_WIDGET_CATALOG_ROLE
-            sql = "DELETE FROM ep_user_roles_request_det WHERE requested_role_id=" + roleId;
-            logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-            query = localSession.createSQLQuery(sql);
-            query.executeUpdate();
-            if (!isPortalRequest) {
-                // Delete form fn_menu_functional_roles
-                sql = "DELETE FROM fn_menu_functional_roles WHERE role_id=" + roleId;
-                logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
-                query = localSession.createSQLQuery(sql);
-                query.executeUpdate();
-            }
-        } catch (Exception e) {
-            logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleDependeciesRecord: failed ", e);
-            throw new DeleteDomainObjectFailedException("delete Failed" + e.getMessage());
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<String> getMenuFunctionsList(String uebkey) throws Exception {
-        List<String> appMenuFunctionsList = null;
-        List<String> appMenuFunctionsFinalList = new ArrayList<>();
-        try {
-            EPApp app = getApp(uebkey).get(0);
-            final Map<String, Long> appParams = new HashMap<>();
-            appParams.put(APP_ID, app.getId());
-            appMenuFunctionsList = dataAccessService.executeNamedQuery("getMenuFunctions", appParams, null);
-            for (String appMenuFunction : appMenuFunctionsList) {
-                if (appMenuFunction.contains(FUNCTION_PIPE)) {
-                    appMenuFunctionsFinalList.add(EcompPortalUtils.getFunctionCode(appMenuFunction));
-                } else {
-                    appMenuFunctionsFinalList.add(appMenuFunction);
-                }
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctionsList: Failed", e);
-            return appMenuFunctionsFinalList;
-        }
-        return appMenuFunctionsFinalList;
-    }
-
-    @SuppressWarnings({"unchecked"})
-    @Override
-    public List<EcompUser> getAllAppUsers(String uebkey) throws Exception {
-        List<String> usersList = new ArrayList<>();
-        List<EcompUser> usersfinalList = new ArrayList<>();
-        try {
-            EPApp app = getApp(uebkey).get(0);
-            final Map<String, Long> appParams = new HashMap<>();
-            appParams.put("appId", app.getId());
-            List<EcompUserRoles> userList =
-                    (List<EcompUserRoles>) dataAccessService.executeNamedQuery("ApplicationUserRoles", appParams, null);
-            for (EcompUserRoles ecompUserRole : userList) {
-                boolean found = false;
-                Set<EcompRole> roles = null;
-                for (EcompUser user : usersfinalList) {
-                    if (user.getOrgUserId().equals(ecompUserRole.getOrgUserId())) {
-                        EcompRole ecompRole = new EcompRole();
-                        ecompRole.setId(ecompUserRole.getRoleId());
-                        ecompRole.setName(ecompUserRole.getRoleName());
-                        roles = user.getRoles();
-                        EcompRole role = roles.stream().filter(x -> x.getName().equals(ecompUserRole.getRoleName()))
-                                .findAny().orElse(null);
-                        SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
-                        if (role != null) {
-                            roleFunctionSet = (SortedSet<EcompRoleFunction>) role.getRoleFunctions();
-                        }
-                        String functionCode = EcompPortalUtils.getFunctionCode(ecompUserRole.getFunctionCode());
-                        functionCode = EPUserUtils.decodeFunctionCode(functionCode);
-                        EcompRoleFunction epRoleFunction = new EcompRoleFunction();
-                        epRoleFunction.setName(ecompUserRole.getFunctionName());
-                        epRoleFunction.setCode(EPUserUtils.decodeFunctionCode(functionCode));
-                        epRoleFunction.setType(getFunctionCodeType(ecompUserRole.getFunctionCode()));
-                        epRoleFunction.setAction(getFunctionCodeAction(ecompUserRole.getFunctionCode()));
-                        roleFunctionSet.add(epRoleFunction);
-                        ecompRole.setRoleFunctions(roleFunctionSet);
-                        roles.add(ecompRole);
-                        user.setRoles(roles);
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    EcompUser epUser = new EcompUser();
-                    epUser.setOrgId(ecompUserRole.getOrgId());
-                    epUser.setManagerId(ecompUserRole.getManagerId());
-                    epUser.setFirstName(ecompUserRole.getFirstName());
-                    epUser.setLastName(ecompUserRole.getLastName());
-                    epUser.setPhone(ecompUserRole.getPhone());
-                    epUser.setEmail(ecompUserRole.getEmail());
-                    epUser.setOrgUserId(ecompUserRole.getOrgUserId());
-                    epUser.setOrgCode(ecompUserRole.getOrgCode());
-                    epUser.setOrgManagerUserId(ecompUserRole.getOrgManagerUserId());
-                    epUser.setJobTitle(ecompUserRole.getJobTitle());
-                    epUser.setLoginId(ecompUserRole.getLoginId());
-                    epUser.setActive(true);
-                    roles = new HashSet<>();
-                    EcompRole ecompRole = new EcompRole();
-                    ecompRole.setId(ecompUserRole.getRoleId());
-                    ecompRole.setName(ecompUserRole.getRoleName());
-                    SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
-                    String functionCode = EcompPortalUtils.getFunctionCode(ecompUserRole.getFunctionCode());
-                    functionCode = EPUserUtils.decodeFunctionCode(functionCode);
-                    EcompRoleFunction epRoleFunction = new EcompRoleFunction();
-                    epRoleFunction.setName(ecompUserRole.getFunctionName());
-                    epRoleFunction.setCode(EPUserUtils.decodeFunctionCode(functionCode));
-                    epRoleFunction.setType(getFunctionCodeType(ecompUserRole.getFunctionCode()));
-                    epRoleFunction.setAction(getFunctionCodeAction(ecompUserRole.getFunctionCode()));
-                    roleFunctionSet.add(epRoleFunction);
-                    ecompRole.setRoleFunctions(roleFunctionSet);
-                    roles.add(ecompRole);
-                    epUser.setRoles(roles);
-                    usersfinalList.add(epUser);
-                }
-            }
-            ObjectMapper mapper = new ObjectMapper();
-            for (EcompUser u1 : usersfinalList) {
-                String str = mapper.writeValueAsString(u1);
-                usersList.add(str);
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getAllUsers failed", e);
-            throw e;
-        }
-        return usersfinalList;
-    }
-
-    @Override
-    public Role ConvertCentralRoleToRole(String result) {
-        ObjectMapper mapper = new ObjectMapper();
-        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-        Role newRole = new Role();
-        try {
-            newRole = mapper.readValue(result, Role.class);
-        } catch (IOException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "Failed to convert the result to Role Object", e);
-        }
-        if (newRole.getRoleFunctions() != null) {
-            @SuppressWarnings("unchecked")
-            Set<RoleFunction> roleFunctionList = newRole.getRoleFunctions();
-            Set<RoleFunction> roleFunctionListNew = new HashSet<>();
-            Iterator<RoleFunction> itetaror = roleFunctionList.iterator();
-            while (itetaror.hasNext()) {
-                Object nextValue = itetaror.next();
-                RoleFunction roleFun = mapper.convertValue(nextValue, RoleFunction.class);
-                roleFunctionListNew.add(roleFun);
-            }
-            newRole.setRoleFunctions(roleFunctionListNew);
-        }
-        return newRole;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public List<CentralizedApp> getCentralizedAppsOfUser(String userId) {
-        Map<String, String> params = new HashMap<>();
-        params.put("userId", userId);
-        List<CentralizedApp> centralizedAppsList = new ArrayList<>();
-        try {
-            centralizedAppsList = dataAccessService.executeNamedQuery("getCentralizedAppsOfUser", params, null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getCentralizedAppsOfUser failed", e);
-        }
-        return centralizedAppsList;
-    }
-
-    @SuppressWarnings("unchecked")
-    public List<CentralV2Role> getGlobalRolesOfApplication(Long appId) {
-        Map<String, Long> params = new HashMap<>();
-        params.put("appId", appId);
-        List<GlobalRoleWithApplicationRoleFunction> globalRoles = new ArrayList<>();
-        try {
-            globalRoles =
-                    dataAccessService.executeNamedQuery("getGlobalRoleWithApplicationRoleFunctions", params, null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getCentralizedAppsOfUser failed", e);
-        }
-        List<CentralV2Role> rolesfinalList = new ArrayList<>();
-        if (globalRoles.size() > 0)
-            rolesfinalList = finalListOfCentralRoles(globalRoles);
-        return rolesfinalList;
-    }
-
-    @SuppressWarnings("unchecked")
-    private CentralV2Role getGlobalRoleForRequestedApp(long requestedAppId, long roleId) {
-        CentralV2Role finalGlobalrole = null;
-        List<GlobalRoleWithApplicationRoleFunction> roleWithApplicationRoleFucntions = new ArrayList<>();
-        Map<String, Long> params = new HashMap<>();
-        params.put("roleId", roleId);
-        params.put("requestedAppId", requestedAppId);
-        try {
-            roleWithApplicationRoleFucntions =
-                    dataAccessService.executeNamedQuery("getGlobalRoleForRequestedApp", params, null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getGlobalRoleForRequestedApp failed", e);
-        }
-        if (roleWithApplicationRoleFucntions.size() > 0) {
-            List<CentralV2Role> rolesfinalList = finalListOfCentralRoles(roleWithApplicationRoleFucntions);
-            finalGlobalrole = rolesfinalList.get(0);
-        } else {
-            List<EPRole> roleList = getPortalAppRoleInfo(roleId);
-            finalGlobalrole = convertRoleToCentralV2Role(roleList.get(0));
-        }
-        return finalGlobalrole;
-    }
-
-    private List<CentralV2Role> finalListOfCentralRoles(List<GlobalRoleWithApplicationRoleFunction> globalRoles) {
-        List<CentralV2Role> rolesfinalList = new ArrayList<>();
-        for (GlobalRoleWithApplicationRoleFunction role : globalRoles) {
-            boolean found = false;
-            for (CentralV2Role cenRole : rolesfinalList) {
-                if (role.getRoleId().equals(cenRole.getId())) {
-                    SortedSet<CentralV2RoleFunction> roleFunctions = cenRole.getRoleFunctions();
-                    CentralV2RoleFunction cenRoleFun = createCentralRoleFunctionForGlobalRole(role);
-                    roleFunctions.add(cenRoleFun);
-                    cenRole.setRoleFunctions(roleFunctions);
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                CentralV2Role cenrole = new CentralV2Role();
-                cenrole.setName(role.getRoleName());
-                cenrole.setId(role.getRoleId());
-                cenrole.setActive(role.isActive());
-                cenrole.setPriority(role.getPriority());
-                SortedSet<CentralV2RoleFunction> roleFunctions = new TreeSet<>();
-                CentralV2RoleFunction cenRoleFun = createCentralRoleFunctionForGlobalRole(role);
-                roleFunctions.add(cenRoleFun);
-                cenrole.setRoleFunctions(roleFunctions);
-                rolesfinalList.add(cenrole);
-            }
-        }
-        return rolesfinalList;
-    }
-
-    private CentralV2RoleFunction createCentralRoleFunctionForGlobalRole(GlobalRoleWithApplicationRoleFunction role) {
-        String instance;
-        String type;
-        String action;
-        CentralV2RoleFunction cenRoleFun;
-        if (role.getFunctionCd().contains(FUNCTION_PIPE)) {
-            instance = EcompPortalUtils.getFunctionCode(role.getFunctionCd());
-            type = EcompPortalUtils.getFunctionType(role.getFunctionCd());
-            action = EcompPortalUtils.getFunctionAction(role.getFunctionCd());
-            cenRoleFun = new CentralV2RoleFunction(null, instance, role.getFunctionName(), null, type, action, null);
-        } else {
-            type = getFunctionCodeType(role.getFunctionCd());
-            action = getFunctionCodeAction(role.getFunctionCd());
-            cenRoleFun = new CentralV2RoleFunction(null, role.getFunctionCd(), role.getFunctionName(), null, type,
-                    action, null);
-        }
-        return cenRoleFun;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public List<EPRole> getGlobalRolesOfPortal() {
-        List<EPRole> globalRoles = new ArrayList<>();
-        try {
-            globalRoles = dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getGlobalRolesOfPortal failed", e);
-        }
-        return globalRoles;
-    }
-
-    private CentralV2Role convertRoleToCentralV2Role(EPRole role) {
-        return new CentralV2Role(role.getId(), role.getCreated(), role.getModified(), role.getCreatedId(),
-                role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(), role.getPriority(),
-                new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
-    }
-
-    @Override
-    public List<CentralRoleFunction> convertCentralRoleFunctionToRoleFunctionObject(
-            List<CentralV2RoleFunction> answer) {
-        List<CentralRoleFunction> addRoleFuncList = new ArrayList<>();
-        for (CentralV2RoleFunction cenRoleFunc : answer) {
-            CentralRoleFunction setRoleFunc = new CentralRoleFunction();
-            setRoleFunc.setCode(cenRoleFunc.getCode());
-            setRoleFunc.setName(cenRoleFunc.getName());
-            addRoleFuncList.add(setRoleFunc);
-        }
-        return addRoleFuncList;
-    }
-
-    @Override
-    public CentralUser getUserRoles(String loginId, String uebkey) throws Exception {
-        CentralUser sendUserRoles = null;
-        try {
-            CentralV2User cenV2User = getV2UserAppRoles(loginId, uebkey);
-            sendUserRoles = convertV2UserRolesToOlderVersion(cenV2User);
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "getUserRoles: failed", e);
-            throw e;
-        }
-        return sendUserRoles;
-    }
-
-    /**
-     * 
-     * It returns V2 CentralUser object if user has any roles and permissions
-     * 
-     * @param loginId
-     * @param uebkey
-     * @return CentralUser object
-     * @throws Exception
-     */
-    private CentralV2User getV2UserAppRoles(String loginId, String uebkey) throws Exception {
-        EPApp app;
-        List<EPUser> epUserList;
-        List<EPApp> appList = getApp(uebkey);
-        app = appList.get(0);
-        epUserList = getUser(loginId);
-        EPUser user = epUserList.get(0);
-        Set<EPUserApp> userAppSet = user.getEPUserApps();
-        return createEPUser(user, userAppSet, app);
-    }
-
-    private List<EcompRole> getUserAppRoles(EPApp app, EPUser user) {
-        final Map<String, Long> userParams = new HashMap<>();
-        userParams.put("appId", app.getId());
-        userParams.put("userId", user.getId());
-        @SuppressWarnings("unchecked")
-        List<EPUserAppCurrentRoles> userAppsRolesList =
-                dataAccessService.executeNamedQuery("getUserAppCurrentRoles", userParams, null);
-        List<EcompRole> setUserRoles = new ArrayList<>();
-        for (EPUserAppCurrentRoles role : userAppsRolesList) {
-            logger.debug(EELFLoggerDelegate.debugLogger, "In getUserAppRoles()- get userRolename = {}",
-                    role.getRoleName());
-            EcompRole ecompRole = new EcompRole();
-            ecompRole.setId(role.getRoleId());
-            ecompRole.setName(role.getRoleName());
-            setUserRoles.add(ecompRole);
-        }
-        logger.debug(EELFLoggerDelegate.debugLogger, "In getUserAppRoles()- get userrole list size = {}",
-                setUserRoles.size());
-        return setUserRoles;
-    }
-
-    @Override
-    public List<EcompRole> missingUserApplicationRoles(String uebkey, String loginId, Set<EcompRole> CurrentUserRoles)
-            throws Exception {
-        List<EPApp> appList = getApp(uebkey);
-        EPApp app = appList.get(0);
-        List<EPUser> epUserList;
-        epUserList = getUser(loginId);
-        List<EcompRole> missingUserAppRoles = new ArrayList<>();
-        List<String> roleNamesList = CurrentUserRoles.stream().map(EcompRole::getName).collect(Collectors.toList());
-        logger.debug(EELFLoggerDelegate.debugLogger, "Roles of User from hibernate :" + roleNamesList);
-        List<EcompRole> userApplicationsRolesfromDB = getUserAppRoles(app, epUserList.get(0));
-        if (userApplicationsRolesfromDB.size() > 0) {
-            missingUserAppRoles = userApplicationsRolesfromDB.stream().filter(x -> !roleNamesList.contains(x.getName()))
-                    .collect(Collectors.toList());
-        }
-        List<String> MissingroleNamesList =
-                missingUserAppRoles.stream().map(EcompRole::getName).collect(Collectors.toList());
-        logger.debug(EELFLoggerDelegate.debugLogger, "MissingUserAppRoles():" + MissingroleNamesList);
-
-        List<EcompRole> finalMissingRoleList = new ArrayList<>();
-        if (missingUserAppRoles.size() > 0) {
-            final Map<String, Long> params = new HashMap<>();
-            for (EcompRole role : missingUserAppRoles) {
-                params.put("roleId", role.getId());
-                params.put(APP_ID, app.getId());
-
-                EcompRole epRole = new EcompRole();
-                epRole.setId(role.getId());
-                epRole.setName(role.getName());
-                @SuppressWarnings("unchecked")
-                List<CentralV2RoleFunction> appRoleFunctionList =
-                        dataAccessService.executeNamedQuery("getAppRoleFunctionList", params, null);
-                SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
-                for (CentralV2RoleFunction roleFunc : appRoleFunctionList) {
-                    String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
-                    String type = getFunctionCodeType(roleFunc.getCode());
-                    String action = getFunctionCodeAction(roleFunc.getCode());
-                    EcompRoleFunction fun = new EcompRoleFunction();
-                    fun.setAction(action);
-                    fun.setCode(functionCode);
-                    fun.setType(type);
-                    fun.setName(roleFunc.getName());
-                    roleFunctionSet.add(fun);
-
-                }
-                epRole.setRoleFunctions(roleFunctionSet);
-                finalMissingRoleList.add(epRole);
-            }
-        }
-
-        return finalMissingRoleList;
-    }
-
-    /**
-     * It converts V2 CentralUser object to old version CentralUser object
-     * 
-     * @param cenV2User
-     * @return EPUser object
-     */
-    private CentralUser convertV2UserRolesToOlderVersion(CentralV2User cenV2User) {
-        Set<CentralV2UserApp> userV2Apps = cenV2User.getUserApps();
-        Set<CentralUserApp> userApps = new TreeSet<>();
-        for (CentralV2UserApp userApp : userV2Apps) {
-            CentralApp app = userApp.getApp();
-            CentralUserApp cua = new CentralUserApp();
-            cua.setUserId(null);
-            cua.setApp(app);
-            SortedSet<CentralRoleFunction> cenRoleFunction = new TreeSet<>();
-            for (CentralV2RoleFunction cenV2RoleFunc : userApp.getRole().getRoleFunctions()) {
-                CentralRoleFunction cenRoleFunc =
-                        new CentralRoleFunction(cenV2RoleFunc.getCode(), cenV2RoleFunc.getName());
-                cenRoleFunction.add(cenRoleFunc);
-            }
-            CentralRole role = new CentralRole.CentralRoleBuilder().setId(userApp.getRole().getId())
-                    .setName(userApp.getRole().getName()).setActive(userApp.getRole().getActive())
-                    .setPriority(userApp.getRole().getPriority()).setRoleFunctions(cenRoleFunction).createCentralRole();
-            cua.setRole(role);
-            userApps.add(cua);
-        }
-        return new CentralUser(cenV2User.getId(), cenV2User.getCreated(), cenV2User.getModified(),
-                cenV2User.getCreatedId(), cenV2User.getModifiedId(), cenV2User.getRowNum(), cenV2User.getOrgId(),
-                cenV2User.getManagerId(), cenV2User.getFirstName(), cenV2User.getMiddleInitial(),
-                cenV2User.getLastName(), cenV2User.getPhone(), cenV2User.getFax(), cenV2User.getCellular(),
-                cenV2User.getEmail(), cenV2User.getAddressId(), cenV2User.getAlertMethodCd(), cenV2User.getHrid(),
-                cenV2User.getOrgUserId(), cenV2User.getOrgCode(), cenV2User.getAddress1(), cenV2User.getAddress2(),
-                cenV2User.getCity(), cenV2User.getState(), cenV2User.getZipCode(), cenV2User.getCountry(),
-                cenV2User.getOrgManagerUserId(), cenV2User.getLocationClli(), cenV2User.getBusinessCountryCode(),
-                cenV2User.getBusinessCountryName(), cenV2User.getBusinessUnit(), cenV2User.getBusinessUnitName(),
-                cenV2User.getDepartment(), cenV2User.getDepartmentName(), cenV2User.getCompanyCode(),
-                cenV2User.getCompany(), cenV2User.getZipCodeSuffix(), cenV2User.getJobTitle(),
-                cenV2User.getCommandChain(), cenV2User.getSiloStatus(), cenV2User.getCostCenter(),
-                cenV2User.getFinancialLocCode(), cenV2User.getLoginId(), cenV2User.getLoginPwd(),
-                cenV2User.getLastLoginDate(), cenV2User.isActive(), cenV2User.isInternal(),
-                cenV2User.getSelectedProfileId(), cenV2User.getTimeZoneId(), cenV2User.isOnline(),
-                cenV2User.getChatId(), userApps);
-    }
-
-    @Override
-    public List<CentralRole> convertV2CentralRoleListToOldVerisonCentralRoleList(List<CentralV2Role> v2CenRoleList) {
-        List<CentralRole> cenRoleList = new ArrayList<>();
-        for (CentralV2Role v2CenRole : v2CenRoleList) {
-            SortedSet<CentralRoleFunction> cenRoleFuncList = new TreeSet<>();
-            for (CentralV2RoleFunction v2CenRoleFunc : v2CenRole.getRoleFunctions()) {
-                CentralRoleFunction roleFunc =
-                        new CentralRoleFunction(v2CenRoleFunc.getCode(), v2CenRoleFunc.getName());
-                cenRoleFuncList.add(roleFunc);
-            }
-            CentralRole role = new CentralRole.CentralRoleBuilder().setId(v2CenRole.getId())
-                    .setName(v2CenRole.getName()).setActive(v2CenRole.getActive()).setPriority(v2CenRole.getPriority())
-                    .setRoleFunctions(cenRoleFuncList).createCentralRole();
-            cenRoleList.add(role);
-        }
-        return cenRoleList;
-    }
-
-    @Override
-    public ResponseEntity<String> getNameSpaceIfExists(EPApp app) throws Exception {
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> entity = new HttpEntity<>(headers);
-        logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists: Connecting to External Auth system");
-        ResponseEntity<String> response = null;
-        try {
-            response =
-                    template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                            + "nss/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
-            logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists: Finished ",
-                    response.getStatusCode().value());
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "checkIfNameSpaceExists failed", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-            if (e.getStatusCode() == HttpStatus.NOT_FOUND)
-                throw new InvalidApplicationException("Invalid NameSpace");
-            else
-                throw e;
-        }
-        return response;
-    }
-
-    @Override
-    public CentralRole convertV2CentralRoleToOldVerisonCentralRole(CentralV2Role v2CenRole) {
-        SortedSet<CentralRoleFunction> cenRoleFuncList = new TreeSet<>();
-        for (CentralV2RoleFunction v2CenRoleFunc : v2CenRole.getRoleFunctions()) {
-            CentralRoleFunction roleFunc = new CentralRoleFunction(v2CenRoleFunc.getCode(), v2CenRoleFunc.getName());
-            cenRoleFuncList.add(roleFunc);
-        }
-        return new CentralRole.CentralRoleBuilder().setId(v2CenRole.getId()).setName(v2CenRole.getName())
-                .setActive(v2CenRole.getActive()).setPriority(v2CenRole.getPriority()).setRoleFunctions(cenRoleFuncList)
-                .createCentralRole();
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public Integer bulkUploadUsersSingleRole(String uebkey, Long roleId, String modifiedRoleName) throws Exception {
-        EPApp app = getApp(uebkey).get(0);
-        final Map<String, String> params = new HashMap<>();
-        params.put("uebKey", app.getUebKey());
-        params.put("roleId", String.valueOf(roleId));
-        List<BulkUploadUserRoles> userRolesList = null;
-        Integer userRolesAdded = 0;
-        if (app.getCentralAuth()) {
-            userRolesList = dataAccessService.executeNamedQuery("getBulkUsersForSingleRole", params, null);
-            for (BulkUploadUserRoles userRolesUpload : userRolesList) {
-                userRolesUpload.setRoleName(modifiedRoleName);
-                if (!userRolesUpload.getOrgUserId().equals("su1234")) {
-                    addUserRoleInExternalSystem(userRolesUpload);
-                    userRolesAdded++;
-                }
-            }
-        }
-        return userRolesAdded;
-    }
-
-    @Override
-    public String encodeFunctionCode(String funCode) {
-        String encodedString = funCode;
-        List<Pattern> encodingList = new ArrayList<>();
-        encodingList.add(Pattern.compile("/"));
-        encodingList.add(Pattern.compile("-"));
-        for (Pattern xssInputPattern : encodingList) {
-            encodedString = xssInputPattern.matcher(encodedString)
-                    .replaceAll("%" + Hex.encodeHexString(xssInputPattern.toString().getBytes()));
-        }
-        encodedString = encodedString.replaceAll("\\*", "%" + Hex.encodeHexString("*".getBytes()));
-        return encodedString;
-    }
-
-    @Override
-    public void bulkUploadRoleFunc(UploadRoleFunctionExtSystem data, EPApp app) throws Exception {
-        ObjectMapper mapper = new ObjectMapper();
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        try {
-            ExternalAccessRolePerms extRolePerms;
-            ExternalAccessPerms extPerms;
-            extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + data.getType(),
-                    encodeFunctionCode(data.getInstance()), data.getAction());
-            String appNameSpace = "";
-            if (data.getIsGlobalRolePartnerFunc()) {
-                appNameSpace = epAppService.getApp(1l).getNameSpace();
-            } else {
-                appNameSpace = app.getNameSpace();
-            }
-            extRolePerms = new ExternalAccessRolePerms(extPerms, appNameSpace + "." + data.getRoleName()
-                    .replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
-            String updateRolePerms = mapper.writeValueAsString(extRolePerms);
-            HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
-            updateRoleFunctionInExternalSystem(updateRolePerms, entity);
-        } catch (HttpClientErrorException e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "HttpClientErrorException - Failed to add role function in external central auth system", e);
-            EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
-            throw e;
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "addFunctionInExternalSystem: Failed to add role fucntion in external central auth system", e);
-            throw e;
-        }
-    }
-
-    private void updateRoleFunctionInExternalSystem(String updateRolePerms, HttpEntity<String> entity) {
-        logger.debug(EELFLoggerDelegate.debugLogger, "bulkUploadRoleFunc: {} for POST: {}",
-                CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
-        ResponseEntity<String> addPermResponse = template.exchange(
-                SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
-                HttpMethod.POST, entity, String.class);
-        logger.debug(EELFLoggerDelegate.debugLogger,
-                "bulkUploadRoleFunc: Finished adding permission for POST: {} and status code: {} ",
-                addPermResponse.getStatusCode().value(), updateRolePerms);
-    }
-
-    @Override
-    public void syncApplicationUserRolesFromExtAuthSystem(String loginId) throws Exception {
-        String name = "";
-        if (EPCommonSystemProperties.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) {
-            name = loginId + SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN);
-        }
-        HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
-        HttpEntity<String> getUserRolesEntity = new HttpEntity<>(headers);
-        ResponseEntity<String> getResponse = getUserRolesFromExtAuthSystem(name, getUserRolesEntity);
-        List<ExternalAccessUserRoleDetail> userRoleDetailList = new ArrayList<>();
-        String res = getResponse.getBody();
-        JSONObject jsonObj = null;
-        JSONArray extRoles = null;
-        if (!res.equals("{}")) {
-            jsonObj = new JSONObject(res);
-            extRoles = jsonObj.getJSONArray("role");
-        }
-        updateUserRolesInLocal(userRoleDetailList, extRoles, loginId);
-    }
-
-    @SuppressWarnings("unchecked")
-    private void updateUserRolesInLocal(List<ExternalAccessUserRoleDetail> userRoleDetailList, JSONArray extRoles,
-            String loginId) throws InvalidUserException {
-        HashMap<String, String> userParams = new HashMap<>();
-        userParams.put("orgUserId", loginId);
-        // Get all centralized applications existing user roles from local
-        List<CentralizedAppRoles> currentUserAppRoles =
-                dataAccessService.executeNamedQuery("getUserCentralizedAppRoles", userParams, null);
-        EPUser user = getUser(loginId).get(0);
-        // Get all centralized applications roles from local
-        HashMap<String, CentralizedAppRoles> cenAppRolesMap = getCentralizedAppRoleList();
-        HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap =
-                getCurrentUserCentralizedAppRoles(currentUserAppRoles);
-        // Get all centralized applications + admin role from local
-        HashMap<String, EPApp> centralisedAppsMap = getCentralizedAdminAppsInfo();
-        if (extRoles != null) {
-            ExternalAccessUserRoleDetail userRoleDetail = null;
-            for (int i = 0; i < extRoles.length(); i++) {
-                if (!extRoles.getJSONObject(i).getString("name").endsWith(ADMIN)
-                        && !extRoles.getJSONObject(i).getString("name").endsWith(OWNER)) {
-                    userRoleDetail =
-                            new ExternalAccessUserRoleDetail(extRoles.getJSONObject(i).getString("name"), null);
-                    userRoleDetailList.add(userRoleDetail);
-                }
-            }
-            addUserRolesInLocal(userRoleDetailList, user, cenAppRolesMap, currentCentralizedUserAppRolesMap,
-                    centralisedAppsMap);
-        }
-    }
-
-    private void addUserRolesInLocal(List<ExternalAccessUserRoleDetail> userRoleDetailList, EPUser user,
-            HashMap<String, CentralizedAppRoles> cenAppRolesMap,
-            HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap,
-            HashMap<String, EPApp> centralisedAppsMap) {
-        for (ExternalAccessUserRoleDetail extUserRoleDetail : userRoleDetailList) {
-            try {
-                // check if user already has role in local
-                if (!currentCentralizedUserAppRolesMap.containsKey(extUserRoleDetail.getName())) {
-                    CentralizedAppRoles getCenAppRole = cenAppRolesMap.get(extUserRoleDetail.getName());
-                    if (getCenAppRole != null) {
-                        logger.debug(EELFLoggerDelegate.debugLogger,
-                                "addUserRolesInLocal: Adding user role from external auth system  {}",
-                                extUserRoleDetail.toString());
-                        EPUserApp userApp = new EPUserApp();
-                        EPApp app = new EPApp();
-                        app.setId(getCenAppRole.getAppId());
-                        EPRole epRole = new EPRole();
-                        epRole.setId(getCenAppRole.getRoleId());
-                        userApp.setApp(app);
-                        userApp.setUserId(user.getId());
-                        userApp.setRole(epRole);
-                        dataAccessService.saveDomainObject(userApp, null);
-                        logger.debug(EELFLoggerDelegate.debugLogger,
-                                "addUserRolesInLocal: Finished user role from external auth system  {}",
-                                extUserRoleDetail.toString());
-                    } else if (getCenAppRole == null // check if user has app
-                                                     // account admin role
-                            && extUserRoleDetail.getName().endsWith(PortalConstants.ADMIN_ROLE.replaceAll(
-                                    EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"))) {
-                        EPApp app = centralisedAppsMap.get(extUserRoleDetail.getName());
-                        if (app != null) {
-                            logger.debug(EELFLoggerDelegate.debugLogger,
-                                    "addUserRolesInLocal: Adding user role from external auth system  {}",
-                                    extUserRoleDetail.toString());
-                            EPUserApp userApp = new EPUserApp();
-                            EPRole epRole = new EPRole();
-                            epRole.setId(PortalConstants.ACCOUNT_ADMIN_ROLE_ID);
-                            userApp.setApp(app);
-                            userApp.setUserId(user.getId());
-                            userApp.setRole(epRole);
-                            dataAccessService.saveDomainObject(userApp, null);
-                            logger.debug(EELFLoggerDelegate.debugLogger,
-                                    "addUserRolesInLocal: Finished user role from external auth system  {}",
-                                    extUserRoleDetail.toString());
-                        }
-                    }
-                }
-            } catch (Exception e) {
-                logger.error(EELFLoggerDelegate.errorLogger,
-                        "addUserRolesInLocal - Failed to update user role in local from external auth system {} ",
-                        extUserRoleDetail.toString(), e);
-            }
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private HashMap<String, EPApp> getCentralizedAdminAppsInfo() {
-        List<EPApp> centralizedApps = dataAccessService.executeNamedQuery("getCentralizedApps", null, null);
-        HashMap<String, EPApp> centralisedAppsMap = new HashMap<>();
-        for (EPApp cenApp : centralizedApps) {
-            centralisedAppsMap.put(
-                    cenApp.getNameSpace() + "."
-                            + PortalConstants.ADMIN_ROLE.replaceAll(
-                                    EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                    cenApp);
-        }
-        return centralisedAppsMap;
-    }
-
-    private HashMap<String, CentralizedAppRoles> getCurrentUserCentralizedAppRoles(
-            List<CentralizedAppRoles> currentUserAppRoles) {
-        HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap = new HashMap<>();
-        for (CentralizedAppRoles cenAppUserRole : currentUserAppRoles) {
-            currentCentralizedUserAppRolesMap.put(
-                    cenAppUserRole.getAppNameSpace() + "."
-                            + cenAppUserRole.getRoleName().replaceAll(
-                                    EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                    cenAppUserRole);
-        }
-        return currentCentralizedUserAppRolesMap;
-    }
-
-    @SuppressWarnings("unchecked")
-    private HashMap<String, CentralizedAppRoles> getCentralizedAppRoleList() {
-        List<CentralizedAppRoles> centralizedAppRoles =
-                dataAccessService.executeNamedQuery("getAllCentralizedAppsRoles", null, null);
-        HashMap<String, CentralizedAppRoles> cenAppRolesMap = new HashMap<>();
-        for (CentralizedAppRoles CentralizedAppRole : centralizedAppRoles) {
-            cenAppRolesMap.put(
-                    CentralizedAppRole.getAppNameSpace() + "."
-                            + CentralizedAppRole.getRoleName().replaceAll(
-                                    EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
-                    CentralizedAppRole);
-        }
-        return cenAppRolesMap;
-    }
-
-    @Override
-    public ResponseEntity<String> getUserRolesFromExtAuthSystem(String name, HttpEntity<String> getUserRolesEntity) {
-        logger.debug(EELFLoggerDelegate.debugLogger, "Connecting to external system to get current user roles");
-        ResponseEntity<String> getResponse =
-                template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
-                        + "roles/user/" + name, HttpMethod.GET, getUserRolesEntity, String.class);
-        if (getResponse.getStatusCode().value() == 200) {
-            logger.debug(EELFLoggerDelegate.debugLogger,
-                    "getAllUserRoleFromExtAuthSystem: Finished GET user roles from external system and received user roles {}",
-                    getResponse.getBody());
-        } else {
-            logger.error(EELFLoggerDelegate.errorLogger,
-                    "getAllUserRoleFromExtAuthSystem: Failed GET user roles from external system and received user roles {}",
-                    getResponse.getBody());
-            EPLogUtil.logExternalAuthAccessAlarm(logger, getResponse.getStatusCode());
-        }
-        return getResponse;
-    }
-
-    @Override
-    public Integer updateAppRoleDescription(String uebkey) {
-        Integer roleDescUpdated = 0;
-        EPApp app;
-        try {
-            app = getApp(uebkey).get(0);
-            List<EPRole> roles = getAppRoles(app.getId());
-            for (EPRole epRole : roles) {
-                Role role = new Role();
-                role.setName(epRole.getName());
-                boolean status = addRoleDescriptionInExtSystem(role, app);
-                if (status)
-                    roleDescUpdated++;
-            }
-        } catch (Exception e) {
-            logger.error(EELFLoggerDelegate.errorLogger, "updateAppRoleDescription: Failed! ", e);
-        }
-        return roleDescUpdated;
-    }
+	private static final String APP_ROLE_NAME_PARAM = "appRoleName";
+	private static final String GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM = "getRoletoUpdateInExternalAuthSystem";
+	private static final String GET_PORTAL_APP_ROLES_QUERY = "getPortalAppRoles";
+	private static final String GET_ROLE_FUNCTION_QUERY = "getRoleFunction";
+	private static final String FUNCTION_CODE_PARAMS = "functionCode";
+	private static final String AND_FUNCTION_CD_EQUALS = " and function_cd = '";
+	private static final String OWNER = ".owner";
+	private static final String ADMIN = ".admin";
+	private static final String ACCOUNT_ADMINISTRATOR = ".Account_Administrator";
+	private static final String FUNCTION_PIPE = "|";
+	private static final String EXTERNAL_AUTH_PERMS = "perms";
+	private static final String EXTERNAL_AUTH_ROLE_DESCRIPTION = "description";
+	private static final String IS_EMPTY_JSON_STRING = "{}";
+	private static final String CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE = "Connecting to External Auth system";
+	private static final String APP_ID = "appId";
+	private static final String ROLE_NAME = "name";
+	private static final String APP_ID_EQUALS = " app_id = ";
+	private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(ExternalAccessRolesServiceImpl.class);
+	@Autowired
+	private DataAccessService dataAccessService;
+	@Autowired
+	private EPAppService epAppService;
+	@Autowired
+	private SessionFactory sessionFactory;
+	@Autowired
+	EPRoleService ePRoleService;
+	RestTemplate template = new RestTemplate();
+	// These decode values are based on HexDecoder
+	static final String decodeValueOfForwardSlash = "2f";
+	static final String decodeValueOfHiphen = "2d";
+	static final String decodeValueOfStar = "2a";
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<EPRole> getAppRoles(Long appId) throws Exception {
+		List<EPRole> applicationRoles = null;
+		final Map<String, Long> appParams = new HashMap<>();
+		try {
+			if (appId == 1) {
+				applicationRoles = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
+			} else {
+				appParams.put("appId", appId);
+				applicationRoles = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getAppRoles: failed", e);
+			throw e;
+		}
+		return applicationRoles;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<EPApp> getApp(String uebkey) throws Exception {
+		List<EPApp> app = null;
+		try {
+			final Map<String, String> appUebkeyParams = new HashMap<>();
+			appUebkeyParams.put("appKey", uebkey);
+			app = dataAccessService.executeNamedQuery("getMyAppDetailsByUebKey", appUebkeyParams, null);
+			if (!app.isEmpty() && !app.get(0).getEnabled()
+					&& !app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				throw new InactiveApplicationException("Application:" + app.get(0).getName() + " is Unavailable");
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getApp: failed", e);
+			throw e;
+		}
+		return app;
+	}
+
+	/**
+	 * It returns single application role from external auth system
+	 * 
+	 * @param addRole
+	 * @param app
+	 * @return JSON string which contains application role details
+	 * @throws Exception
+	 */
+	private String getSingleAppRole(String addRole, EPApp app) throws Exception {
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		ResponseEntity<String> response = null;
+		logger.debug(EELFLoggerDelegate.debugLogger, "getSingleAppRole: Connecting to External Auth system");
+		response = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "roles/"
+						+ app.getNameSpace() + "." + addRole
+								.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+				HttpMethod.GET, entity, String.class);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"getSingleAppRole: Finished GET app role from External Auth system and status code: {} ",
+				response.getStatusCode().value());
+		return response.getBody();
+	}
+
+	@Override
+	public boolean addRole(Role addRole, String uebkey) throws Exception {
+		boolean response = false;
+		ResponseEntity<String> addResponse = null;
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		EPApp app = getApp(uebkey).get(0);
+		String newRole = updateExistingRoleInExternalSystem(addRole, app);
+		HttpEntity<String> entity = new HttpEntity<>(newRole, headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "addRole: Connecting to External Auth system");
+		addResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
+				HttpMethod.POST, entity, String.class);
+		if (addResponse.getStatusCode().value() == 201) {
+			response = true;
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"addRole: Finished adding role in the External Auth system  and response code: {} ",
+					addResponse.getStatusCode().value());
+		}
+		if (addResponse.getStatusCode().value() == 406) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"addRole: Failed to add in the External Auth system due to {} and status code: {}",
+					addResponse.getBody(), addResponse.getStatusCode().value());
+		}
+		return response;
+	}
+
+	/**
+	 * 
+	 * It deletes record in external auth system
+	 * 
+	 * @param delRole
+	 * @return JSON String which has status code and response body
+	 * @throws Exception
+	 */
+	private ResponseEntity<String> deleteRoleInExternalSystem(String delRole) throws Exception {
+		ResponseEntity<String> delResponse = null;
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(delRole, headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleInExternalSystem: {} for DELETE: {}",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, delRole);
+		delResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role?force=true",
+				HttpMethod.DELETE, entity, String.class);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"deleteRoleInExternalSystem: Finished DELETE operation in the External Auth system {} and status code: {} ",
+				delRole, delResponse.getStatusCode().value());
+		return delResponse;
+	}
+
+	/**
+	 * It updates role in external auth system
+	 * 
+	 * @param updateExtRole
+	 * @param app
+	 * @return true if success else false
+	 * @throws Exception If updateRoleInExternalSystem fails we catch it in logger
+	 *                   for detail message
+	 */
+	private boolean updateRoleInExternalSystem(Role updateExtRole, EPApp app, boolean isGlobalRole) throws Exception {
+		boolean response = false;
+		ObjectMapper mapper = new ObjectMapper();
+		ResponseEntity<String> deleteResponse = null;
+		List<EPRole> epRoleList = null;
+		if (app.getId().equals(PortalConstants.PORTAL_APP_ID)
+				|| (isGlobalRole && !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
+			epRoleList = getPortalAppRoleInfo(updateExtRole.getId());
+		} else {
+			epRoleList = getPartnerAppRoleInfo(updateExtRole.getId(), app);
+		}
+		// Assigning functions to global role
+		if ((isGlobalRole && !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
+			List<RoleFunction> globalRoleFunctionListNew = convertSetToListOfRoleFunctions(updateExtRole);
+			EPApp portalAppInfo = epAppService.getApp(PortalConstants.PORTAL_APP_ID);
+			addFunctionsTOGlobalRole(epRoleList, updateExtRole, globalRoleFunctionListNew, mapper, app, portalAppInfo);
+			response = true;
+		} else {
+			String appRole = getSingleAppRole(epRoleList.get(0).getName(), app);
+			List<RoleFunction> roleFunctionListNew = convertSetToListOfRoleFunctions(updateExtRole);
+			if (!appRole.equals(IS_EMPTY_JSON_STRING)) {
+				JSONObject jsonObj = new JSONObject(appRole);
+				JSONArray extRole = jsonObj.getJSONArray("role");
+				if (!extRole.getJSONObject(0).has(EXTERNAL_AUTH_ROLE_DESCRIPTION)) {
+					String roleName = extRole.getJSONObject(0).getString(ROLE_NAME);
+					Map<String, String> delRoleKeyMapper = new HashMap<>();
+					delRoleKeyMapper.put(ROLE_NAME, roleName);
+					String delRoleKeyValue = mapper.writeValueAsString(delRoleKeyMapper);
+					deleteResponse = deleteRoleInExternalSystem(delRoleKeyValue);
+					if (deleteResponse.getStatusCode().value() != 200) {
+						throw new ExternalAuthSystemException(deleteResponse.getBody());
+					}
+					addRole(updateExtRole, app.getUebKey());
+				} else {
+					String desc = extRole.getJSONObject(0).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
+					String name = extRole.getJSONObject(0).getString(ROLE_NAME);
+					List<ExternalAccessPerms> list = new ArrayList<>();
+					if (extRole.getJSONObject(0).has(EXTERNAL_AUTH_PERMS)) {
+						JSONArray perms = extRole.getJSONObject(0).getJSONArray(EXTERNAL_AUTH_PERMS);
+						list = mapper.readValue(perms.toString(), TypeFactory.defaultInstance()
+								.constructCollectionType(List.class, ExternalAccessPerms.class));
+					}
+					// If role name or role functions are updated then delete
+					// record in External System and add new record to avoid
+					// conflicts
+					boolean isRoleNameChanged = false;
+					if (!desc.equals(updateExtRole.getName())) {
+						isRoleNameChanged = true;
+						deleteRoleInExtSystem(mapper, name);
+						addRole(updateExtRole, app.getUebKey());
+						// add partner functions to the global role in External
+						// Auth System
+						if (!list.isEmpty() && isGlobalRole) {
+							addPartnerHasRoleFunctionsToGlobalRole(list, mapper, app, updateExtRole);
+						}
+						list.removeIf(
+								perm -> EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace()));
+						// if role name is changes please ignore the previous
+						// functions in External Auth
+						// and update with user requested functions
+						addRemoveFunctionsToRole(updateExtRole, app, mapper, roleFunctionListNew, name, list);
+					}
+					// Delete role in External System if role is inactive
+					if (!updateExtRole.getActive()) {
+						deleteRoleInExtSystem(mapper, name);
+					}
+					if (!isRoleNameChanged) {
+						response = addRemoveFunctionsToRole(updateExtRole, app, mapper, roleFunctionListNew, name,
+								list);
+					}
+				}
+			} else {
+				// It seems like role exists in local DB but not in External
+				// Access system
+				if (updateExtRole.getActive()) {
+					addRole(updateExtRole, app.getUebKey());
+					ExternalAccessRolePerms extAddRolePerms = null;
+					ExternalAccessPerms extAddPerms = null;
+					List<RoleFunction> roleFunctionListAdd = convertSetToListOfRoleFunctions(updateExtRole);
+					HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+					for (RoleFunction roleFunc : roleFunctionListAdd) {
+						extAddPerms = new ExternalAccessPerms(app.getNameSpace() + "." + roleFunc.getType(),
+								roleFunc.getCode(), roleFunc.getAction());
+						extAddRolePerms = new ExternalAccessRolePerms(extAddPerms,
+								app.getNameSpace() + "." + updateExtRole.getName().replaceAll(
+										EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+						response = addRoleFuncExtSysRestAPI(mapper, extAddRolePerms, headers);
+					}
+				}
+			}
+		}
+		return response;
+	}
+
+	private void deleteRoleInExtSystem(ObjectMapper mapper, String name)
+			throws JsonProcessingException, Exception, ExternalAuthSystemException {
+		ResponseEntity<String> deleteResponse;
+		Map<String, String> delRoleKeyMapper = new HashMap<>();
+		delRoleKeyMapper.put(ROLE_NAME, name);
+		String delRoleKeyValue = mapper.writeValueAsString(delRoleKeyMapper);
+		deleteResponse = deleteRoleInExternalSystem(delRoleKeyValue);
+		if (deleteResponse.getStatusCode().value() != 200) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"updateRoleInExternalSystem:  Failed to delete role in external system due to {} ",
+					deleteResponse.getBody());
+			throw new ExternalAuthSystemException(deleteResponse.getBody());
+		}
+	}
+
+	private boolean addRemoveFunctionsToRole(Role updateExtRole, EPApp app, ObjectMapper mapper,
+			List<RoleFunction> roleFunctionListNew, String name, List<ExternalAccessPerms> list) throws Exception {
+		boolean response;
+		Map<String, RoleFunction> updateRoleFunc = new HashMap<>();
+		for (RoleFunction addPerm : roleFunctionListNew) {
+			updateRoleFunc.put(addPerm.getCode(), addPerm);
+		}
+		final Map<String, ExternalAccessPerms> extRolePermMap = new HashMap<>();
+		final Map<String, ExternalAccessPerms> extRolePermMapPipes = new HashMap<>();
+		list.removeIf(perm -> !EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace()));
+		// Update permissions in the ExternalAccess System
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		if (!list.isEmpty()) {
+			for (ExternalAccessPerms perm : list) {
+				RoleFunction roleFunc = updateRoleFunc.get(perm.getType().substring(app.getNameSpace().length() + 1)
+						+ FUNCTION_PIPE + perm.getInstance() + FUNCTION_PIPE + perm.getAction());
+				if (roleFunc == null) {
+					RoleFunction roleFuncPipeFilter = updateRoleFunc.get(perm.getInstance());
+					if (roleFuncPipeFilter == null)
+						removePermForRole(perm, mapper, name, headers);
+				}
+				extRolePermMap.put(perm.getInstance(), perm);
+				extRolePermMapPipes.put(perm.getType().substring(app.getNameSpace().length() + 1) + FUNCTION_PIPE
+						+ perm.getInstance() + FUNCTION_PIPE + perm.getAction(), perm);
+			}
+		}
+		response = true;
+		if (!roleFunctionListNew.isEmpty()) {
+			for (RoleFunction roleFunc : roleFunctionListNew) {
+				if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
+					ExternalAccessPerms perm = extRolePermMapPipes.get(roleFunc.getCode());
+					if (perm == null) {
+						response = addFunctionsToRoleInExternalAuthSystem(updateExtRole, app, mapper, headers,
+								roleFunc);
+					}
+				} else {
+					if (!extRolePermMap.containsKey(EcompPortalUtils.getFunctionCode(roleFunc.getCode()))) {
+						response = addFunctionsToRoleInExternalAuthSystem(updateExtRole, app, mapper, headers,
+								roleFunc);
+					}
+				}
+			}
+		}
+		return response;
+	}
+
+	/*
+	 * Adds function to the role in the external auth system while editing a role or
+	 * updating new functions to a role
+	 *
+	 */
+	private boolean addFunctionsToRoleInExternalAuthSystem(Role updateExtRole, EPApp app, ObjectMapper mapper,
+			HttpHeaders headers, RoleFunction roleFunc) throws JsonProcessingException {
+		boolean response;
+		ExternalAccessRolePerms extRolePerms;
+		ExternalAccessPerms extPerms;
+		String code = "";
+		String type = "";
+		String action = "";
+		if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
+			code = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+			type = EcompPortalUtils.getFunctionType(roleFunc.getCode());
+			action = getFunctionCodeAction(roleFunc.getCode());
+		} else {
+			code = roleFunc.getCode();
+			type = roleFunc.getCode().contains("menu") ? "menu" : "url";
+			action = "*";
+		}
+		extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, code, action);
+		extRolePerms = new ExternalAccessRolePerms(extPerms, app.getNameSpace() + "." + updateExtRole.getName()
+				.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+		String updateRolePerms = mapper.writeValueAsString(extRolePerms);
+		HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "updateRoleInExternalSystem: {} for POST: {}",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
+		ResponseEntity<String> addResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
+				HttpMethod.POST, entity, String.class);
+		if (addResponse.getStatusCode().value() != 201 && addResponse.getStatusCode().value() != 409) {
+			response = false;
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"updateRoleInExternalSystem: Connected to External Auth system but something went wrong! due to {} and statuscode: {}",
+					addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
+		} else {
+			response = true;
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"updateRoleInExternalSystem: Finished adding permissions to roles in External Auth system {} and status code: {} ",
+					updateRolePerms, addResponse.getStatusCode().value());
+		}
+		return response;
+	}
+
+	private void addPartnerHasRoleFunctionsToGlobalRole(List<ExternalAccessPerms> permslist, ObjectMapper mapper,
+			EPApp app, Role updateExtRole) throws Exception {
+		for (ExternalAccessPerms perm : permslist) {
+			if (!EcompPortalUtils.checkNameSpaceMatching(perm.getType(), app.getNameSpace())) {
+				ExternalAccessRolePerms extAddGlobalRolePerms = null;
+				ExternalAccessPerms extAddPerms = null;
+				extAddPerms = new ExternalAccessPerms(perm.getType(), perm.getInstance(), perm.getAction());
+				extAddGlobalRolePerms = new ExternalAccessRolePerms(extAddPerms,
+						app.getNameSpace() + "." + updateExtRole.getName().replaceAll(
+								EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+				String addPerms = mapper.writeValueAsString(extAddGlobalRolePerms);
+				HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+				HttpEntity<String> entity = new HttpEntity<>(addPerms, headers);
+				logger.debug(EELFLoggerDelegate.debugLogger, "addPartnerHasRoleFunctionsToGlobalRole: {} ",
+						CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+				try {
+					ResponseEntity<String> addResponse = template
+							.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+									+ "role/perm", HttpMethod.POST, entity, String.class);
+					if (addResponse.getStatusCode().value() != 201) {
+						logger.debug(EELFLoggerDelegate.debugLogger,
+								"addPartnerHasRoleFunctionsToGlobalRole: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
+								addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
+					} else {
+						logger.debug(EELFLoggerDelegate.debugLogger,
+								"addPartnerHasRoleFunctionsToGlobalRole: Finished adding permissions to roles in External Auth system and status code: {} ",
+								addResponse.getStatusCode().value());
+					}
+				} catch (Exception e) {
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"addPartnerHasRoleFunctionsToGlobalRole: Failed for POST request: {} due to ", addPerms, e);
+				}
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private void addFunctionsTOGlobalRole(List<EPRole> epRoleList, Role updateExtRole,
+			List<RoleFunction> roleFunctionListNew, ObjectMapper mapper, EPApp app, EPApp portalAppInfo)
+			throws Exception {
+		try {
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addFunctionsTOGlobalRole");
+			// GET Permissions from External Auth System
+			JSONArray extPerms = getExtAuthPermissions(app);
+			List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPerms);
+			final Map<String, ExternalAccessPermsDetail> existingPermsWithRoles = new HashMap<>();
+			final Map<String, ExternalAccessPermsDetail> existingPermsWithRolesWithPipes = new HashMap<>();
+			final Map<String, RoleFunction> userRquestedFunctionsMap = new HashMap<>();
+			final Map<String, RoleFunction> userRquestedFunctionsMapPipesFilter = new HashMap<>();
+			for (ExternalAccessPermsDetail permDetail : permsDetailList) {
+				existingPermsWithRoles.put(EcompPortalUtils.getFunctionCode(permDetail.getInstance()), permDetail);
+				existingPermsWithRolesWithPipes.put(permDetail.getInstance(), permDetail);
+			}
+			// Add If function does not exists for role in External Auth System
+			for (RoleFunction roleFunc : roleFunctionListNew) {
+				String roleFuncCode = "";
+				ExternalAccessPermsDetail permsDetail;
+				if (roleFunc.getCode().contains(FUNCTION_PIPE)) {
+					roleFuncCode = roleFunc.getCode();
+					permsDetail = existingPermsWithRolesWithPipes.get(roleFunc.getCode());
+				} else {
+					roleFuncCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+					permsDetail = existingPermsWithRoles.get(roleFuncCode);
+				}
+				if (null == permsDetail.getRoles()
+						|| !permsDetail.getRoles()
+								.contains(portalAppInfo.getNameSpace() + FUNCTION_PIPE
+										+ epRoleList.get(0).getName().replaceAll(
+												EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS,
+												"_"))) {
+					addRoleFunctionsToGlobalRoleInExternalSystem(roleFunc, updateExtRole, mapper, app, portalAppInfo);
+				}
+				userRquestedFunctionsMap.put(roleFuncCode, roleFunc);
+				userRquestedFunctionsMapPipesFilter.put(EcompPortalUtils.getFunctionCode(roleFuncCode), roleFunc);
+			}
+			// Delete functions if exists in External Auth System but not in
+			// incoming
+			// request
+			final Map<String, Long> epAppRoleFuncParams = new HashMap<>();
+			epAppRoleFuncParams.put("requestedAppId", app.getId());
+			epAppRoleFuncParams.put("roleId", updateExtRole.getId());
+			List<GlobalRoleWithApplicationRoleFunction> globalRoleFunctionList = dataAccessService
+					.executeNamedQuery("getGlobalRoleForRequestedApp", epAppRoleFuncParams, null);
+			for (GlobalRoleWithApplicationRoleFunction globalRoleFunc : globalRoleFunctionList) {
+				String globalRoleFuncWithoutPipes = "";
+				RoleFunction roleFunc = null;
+				if (globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
+					globalRoleFuncWithoutPipes = globalRoleFunc.getFunctionCd();
+					roleFunc = userRquestedFunctionsMap.get(globalRoleFuncWithoutPipes);
+				} else {
+					globalRoleFuncWithoutPipes = EcompPortalUtils.getFunctionCode(globalRoleFunc.getFunctionCd());
+					roleFunc = userRquestedFunctionsMapPipesFilter.get(globalRoleFuncWithoutPipes);
+				}
+				if (roleFunc == null) {
+					ExternalAccessPermsDetail permDetailFromMap = globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)
+							? existingPermsWithRolesWithPipes.get(globalRoleFuncWithoutPipes)
+							: existingPermsWithRoles.get(globalRoleFuncWithoutPipes);
+					ExternalAccessPerms perm = new ExternalAccessPerms(permDetailFromMap.getType(),
+							EcompPortalUtils.getFunctionCode(permDetailFromMap.getInstance()),
+							permDetailFromMap.getAction());
+					String roleName = portalAppInfo.getNameSpace() + "." + globalRoleFunc.getRoleName()
+							.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_");
+					HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+					removePermForRole(perm, mapper, roleName, headers);
+				}
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger, "Finished addFunctionsTOGlobalRole");
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addFunctionsTOGlobalRole: Failed", e);
+			throw e;
+		}
+	}
+
+	private void addRoleFunctionsToGlobalRoleInExternalSystem(RoleFunction addFunction, Role globalRole,
+			ObjectMapper mapper, EPApp app, EPApp portalAppInfo) throws Exception {
+		try {
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addRoleFunctionsToGlobalRoleInExternalSystem");
+			ExternalAccessRolePerms extAddRolePerms = null;
+			ExternalAccessPerms extAddPerms = null;
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			String code = "";
+			String type = "";
+			String action = "";
+			if (addFunction.getCode().contains(FUNCTION_PIPE)) {
+				code = EcompPortalUtils.getFunctionCode(addFunction.getCode());
+				type = getFunctionCodeType(addFunction.getCode());
+				action = getFunctionCodeAction(addFunction.getCode());
+			} else {
+				code = addFunction.getCode();
+				type = addFunction.getCode().contains("menu") ? "menu" : "url";
+				action = "*";
+			}
+			extAddPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, code, action);
+			extAddRolePerms = new ExternalAccessRolePerms(extAddPerms, portalAppInfo.getNameSpace() + "." + globalRole
+					.getName().replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+			String updateRolePerms = mapper.writeValueAsString(extAddRolePerms);
+			HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionsInExternalSystem: {} ",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+			ResponseEntity<String> addResponse = template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
+					HttpMethod.POST, entity, String.class);
+			if (addResponse.getStatusCode().value() != 201) {
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"addRoleFunctionsInExternalSystem: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
+						addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
+			} else {
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"addRoleFunctionsInExternalSystem: Finished adding permissions to roles in External Auth system and status code: {} ",
+						addResponse.getStatusCode().value());
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger, "Finished addRoleFunctionsToGlobalRoleInExternalSystem");
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addRoleFunctionsToGlobalRoleInExternalSystem: Failed", e);
+			throw e;
+		}
+	}
+
+	private boolean addRoleFuncExtSysRestAPI(ObjectMapper addPermsMapper, ExternalAccessRolePerms extAddRolePerms,
+			HttpHeaders headers) throws JsonProcessingException {
+		boolean response;
+		String updateRolePerms = addPermsMapper.writeValueAsString(extAddRolePerms);
+		HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionsInExternalSystem: {} for POST: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
+		ResponseEntity<String> addResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
+				HttpMethod.POST, entity, String.class);
+		if (addResponse.getStatusCode().value() != 201 && addResponse.getStatusCode().value() != 409) {
+			response = false;
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"addRoleFunctionsInExternalSystem: While adding permission to the role in  External Auth system something went wrong! due to {} and statuscode: {}",
+					addResponse.getStatusCode().getReasonPhrase(), addResponse.getStatusCode().value());
+		} else {
+			response = true;
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"addRoleFunctionsInExternalSystem: Finished adding permissions to roles in External Auth system {} and status code: {} ",
+					updateRolePerms, addResponse.getStatusCode().value());
+		}
+		return response;
+	}
+
+	/**
+	 * 
+	 * It converts list of functions in updateExtRole parameter to the RoleFunction
+	 * object
+	 * 
+	 * @param updateExtRole
+	 * @return list of functions
+	 */
+	@SuppressWarnings("unchecked")
+	private List<RoleFunction> convertSetToListOfRoleFunctions(Role updateExtRole) {
+		Set<RoleFunction> roleFunctionSetList = updateExtRole.getRoleFunctions();
+		List<RoleFunction> roleFunctionList = new ArrayList<>();
+		ObjectMapper roleFuncMapper = new ObjectMapper();
+		Iterator<RoleFunction> itetaror = roleFunctionSetList.iterator();
+		while (itetaror.hasNext()) {
+			Object nextValue = itetaror.next();
+			RoleFunction roleFunction = roleFuncMapper.convertValue(nextValue, RoleFunction.class);
+			roleFunctionList.add(roleFunction);
+		}
+		return roleFunctionList.stream().distinct().collect(Collectors.toList());
+	}
+
+	/**
+	 * It delete permissions/functions in the external auth system
+	 * 
+	 * @param perm
+	 * @param permMapper
+	 * @param name
+	 * @param headers
+	 * @throws JsonProcessingException
+	 * @throws Exception
+	 */
+	private void removePermForRole(ExternalAccessPerms perm, ObjectMapper permMapper, String name, HttpHeaders headers)
+			throws ExternalAuthSystemException, JsonProcessingException {
+		ExternalAccessRolePerms extAccessRolePerms = new ExternalAccessRolePerms(perm, name);
+		String permDetails = permMapper.writeValueAsString(extAccessRolePerms);
+		try {
+			HttpEntity<String> deleteEntity = new HttpEntity<>(permDetails, headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "removePermForRole: {} for DELETE: {} ",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, permDetails);
+			ResponseEntity<String> deletePermResponse = template
+					.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+							+ "role/" + name + "/perm", HttpMethod.DELETE, deleteEntity, String.class);
+			if (deletePermResponse.getStatusCode().value() != 200) {
+				throw new ExternalAuthSystemException(deletePermResponse.getBody());
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"removePermForRole: Finished deleting permission to role in External Auth system: {} and status code: {}",
+					permDetails, deletePermResponse.getStatusCode().value());
+		} catch (Exception e) {
+			if (e.getMessage().contains("404")) {
+				logger.error(EELFLoggerDelegate.errorLogger, "Failed to add role for DELETE request: {} due to {}",
+						permDetails, e.getMessage());
+			} else {
+				throw e;
+			}
+		}
+	}
+
+	/**
+	 * It will create new role in the External Auth System
+	 * 
+	 * @param newRole
+	 * @param app
+	 * @return true if successfully added in the system else false
+	 * @throws Exception If fails to add role in the system
+	 */
+	private void addNewRoleInExternalSystem(List<EPRole> newRole, EPApp app)
+			throws Exception, HttpClientErrorException {
+		try {
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			ObjectMapper mapper = new ObjectMapper();
+			String addNewRole = "";
+			ExternalAccessRole extRole = new ExternalAccessRole();
+			extRole.setName(app.getNameSpace() + "." + newRole.get(0).getName()
+					.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+			extRole.setDescription(String.valueOf(newRole.get(0).getName()));
+			addNewRole = mapper.writeValueAsString(extRole);
+			HttpEntity<String> postEntity = new HttpEntity<>(addNewRole, headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "addNewRoleInExternalSystem: {} for POST: {} ",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addNewRole);
+			ResponseEntity<String> addNewRoleInExternalSystem = template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
+					HttpMethod.POST, postEntity, String.class);
+			if (addNewRoleInExternalSystem.getStatusCode().value() == 201) {
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"addNewRoleInExternalSystem: Finished adding into External Auth system for POST: {} and status code: {}",
+						addNewRole, addNewRoleInExternalSystem.getStatusCode().value());
+			}
+		} catch (HttpClientErrorException ht) {
+			dataAccessService.deleteDomainObjects(EPRole.class, " role_id = " + newRole.get(0).getId(), null);
+			logger.error(EELFLoggerDelegate.debugLogger,
+					"addNewRoleInExternalSystem: Failed to add in External Auth system and status code: {}", ht);
+			throw new HttpClientErrorException(ht.getStatusCode());
+		}
+	}
+
+	/**
+	 * 
+	 * It updates existing role in the External Auth System
+	 * 
+	 * @param addRole It Contains role information
+	 * @param app
+	 * @return string which is formatted to match with the external auth system
+	 * @throws JsonProcessingException
+	 */
+	private String updateExistingRoleInExternalSystem(Role addRole, EPApp app) throws JsonProcessingException {
+		ObjectMapper mapper = new ObjectMapper();
+		String addNewRole = "";
+		ExternalAccessRole extRole = new ExternalAccessRole();
+		extRole.setName(app.getNameSpace() + "." + addRole.getName()
+				.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+		extRole.setDescription(String.valueOf(addRole.getName()));
+		addNewRole = mapper.writeValueAsString(extRole);
+		return addNewRole;
+	}
+
+	/**
+	 * It create a role in the external auth system and then in our local
+	 * 
+	 * @param addRoleInDB
+	 * @param app
+	 * @return true else false
+	 * @throws Exception
+	 */
+	@SuppressWarnings("unchecked")
+	@Transactional(rollbackFor = Exception.class)
+	public boolean addRoleInEcompDB(Role addRoleInDB, EPApp app) throws Exception {
+		boolean result = false;
+		EPRole epRole = null;
+		Set<RoleFunction> roleFunctionList = addRoleInDB.getRoleFunctions();
+		List<RoleFunction> roleFunctionListNew = new ArrayList<>();
+		ObjectMapper mapper = new ObjectMapper();
+		Iterator<RoleFunction> itetaror = roleFunctionList.iterator();
+		while (itetaror.hasNext()) {
+			Object nextValue = itetaror.next();
+			RoleFunction roleFunction = mapper.convertValue(nextValue, RoleFunction.class);
+			roleFunctionListNew.add(roleFunction);
+		}
+		List<RoleFunction> listWithoutDuplicates = roleFunctionListNew.stream().distinct().collect(Collectors.toList());
+		try {
+			if (addRoleInDB.getId() == null) { // check if it is new role
+				if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+					checkIfRoleExitsInExternalSystem(addRoleInDB, app);
+				}
+				EPRole epRoleNew = new EPRole();
+				epRoleNew.setActive(addRoleInDB.getActive());
+				epRoleNew.setName(addRoleInDB.getName());
+				epRoleNew.setPriority(addRoleInDB.getPriority());
+				if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+					epRoleNew.setAppId(null);
+				} else {
+					epRoleNew.setAppId(app.getId());
+				}
+				dataAccessService.saveDomainObject(epRoleNew, null);
+				List<EPRole> getRoleCreated = null;
+				final Map<String, String> epAppRoleParams = new HashMap<>();
+				final Map<String, String> epAppPortalRoleParams = new HashMap<>();
+				if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+					epAppRoleParams.put("appId", String.valueOf(app.getId()));
+					epAppRoleParams.put(APP_ROLE_NAME_PARAM, addRoleInDB.getName());
+					List<EPRole> roleCreated = dataAccessService
+							.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, epAppRoleParams, null);
+					EPRole epUpdateRole = roleCreated.get(0);
+					epUpdateRole.setAppRoleId(epUpdateRole.getId());
+					dataAccessService.saveDomainObject(epUpdateRole, null);
+					getRoleCreated = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
+							epAppRoleParams, null);
+				} else {
+					epAppPortalRoleParams.put(APP_ROLE_NAME_PARAM, addRoleInDB.getName());
+					getRoleCreated = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY,
+							epAppPortalRoleParams, null);
+				}
+				// Add role in External Auth system
+				if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+					addNewRoleInExternalSystem(getRoleCreated, app);
+				}
+				result = true;
+			} else { // if role already exists then update it
+				EPRole globalRole = null;
+				List<EPRole> applicationRoles;
+				List<EPRole> globalRoleList = getGlobalRolesOfPortal();
+				boolean isGlobalRole = false;
+				if (!globalRoleList.isEmpty()) {
+					EPRole role = globalRoleList.stream().filter(x -> addRoleInDB.getId().equals(x.getId())).findAny()
+							.orElse(null);
+					if (role != null) {
+						globalRole = role;
+						isGlobalRole = true;
+					}
+				}
+				if (app.getId().equals(PortalConstants.PORTAL_APP_ID)
+						|| (globalRole != null && app.getId() != globalRole.getAppId())) {
+					applicationRoles = getPortalAppRoleInfo(addRoleInDB.getId());
+				} else {
+					applicationRoles = getPartnerAppRoleInfo(addRoleInDB.getId(), app);
+				}
+				if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+					updateRoleInExternalSystem(addRoleInDB, app, isGlobalRole);
+					// Add all user to the re-named role in external auth system
+					if (!applicationRoles.isEmpty()
+							&& !addRoleInDB.getName().equals(applicationRoles.get(0).getName())) {
+						bulkUploadUsersSingleRole(app.getUebKey(), applicationRoles.get(0).getId(),
+								addRoleInDB.getName());
+					}
+				}
+				deleteRoleFunction(app, applicationRoles);
+				if (!applicationRoles.isEmpty()) {
+					epRole = applicationRoles.get(0);
+					epRole.setName(addRoleInDB.getName());
+					epRole.setPriority(addRoleInDB.getPriority());
+					epRole.setActive(addRoleInDB.getActive());
+					if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+						epRole.setAppId(null);
+						epRole.setAppRoleId(null);
+					} else if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)
+							&& applicationRoles.get(0).getAppRoleId() == null) {
+						epRole.setAppRoleId(epRole.getId());
+					}
+					dataAccessService.saveDomainObject(epRole, null);
+				}
+				Long roleAppId = null;
+				if (globalRole != null && !app.getId().equals(globalRole.getAppId()))
+					roleAppId = PortalConstants.PORTAL_APP_ID;
+				saveRoleFunction(listWithoutDuplicates, app, applicationRoles, roleAppId);
+				result = true;
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addRoleInEcompDB is failed", e);
+			throw e;
+		}
+		return result;
+	}
+
+	/**
+	 * 
+	 * It validates whether role exists in external auth system
+	 * 
+	 * @param checkRole
+	 * @param app
+	 * @throws Exception If role exits
+	 */
+	private void checkIfRoleExitsInExternalSystem(Role checkRole, EPApp app) throws Exception {
+		getNameSpaceIfExists(app);
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		String roleName = app.getNameSpace() + "." + checkRole.getName()
+				.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_");
+		HttpEntity<String> checkRoleEntity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "checkIfRoleExitsInExternalSystem: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+		ResponseEntity<String> checkRoleInExternalSystem = template
+				.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "roles/"
+						+ roleName, HttpMethod.GET, checkRoleEntity, String.class);
+		if (!checkRoleInExternalSystem.getBody().equals(IS_EMPTY_JSON_STRING)) {
+			logger.debug(
+					"checkIfRoleExitsInExternalSystem: Role already exists in external system {} and status code: {} ",
+					checkRoleInExternalSystem.getBody(), checkRoleInExternalSystem.getStatusCode().value());
+			throw new ExternalAuthSystemException(" Role already exists in external system");
+		}
+	}
+
+	/**
+	 * It saves list of functions to the role in portal
+	 * 
+	 * @param roleFunctionListNew
+	 * @param app
+	 * @param applicationRoles
+	 * @throws Exception
+	 */
+	@SuppressWarnings("unchecked")
+	private void saveRoleFunction(List<RoleFunction> roleFunctionListNew, EPApp app, List<EPRole> applicationRoles,
+			Long roleAppId) throws Exception {
+		final Map<String, String> getAppFunctionParams = new HashMap<>();
+		for (RoleFunction roleFunc : roleFunctionListNew) {
+			String code = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+			EPAppRoleFunction appRoleFunc = new EPAppRoleFunction();
+			appRoleFunc.setAppId(app.getId());
+			appRoleFunc.setRoleId(applicationRoles.get(0).getId());
+			appRoleFunc.setRoleAppId(String.valueOf(roleAppId));
+			getAppFunctionParams.put("appId", String.valueOf(app.getId()));
+			getAppFunctionParams.put(FUNCTION_CODE_PARAMS, roleFunc.getCode());
+			// query to check if function code has pipes
+			List<CentralV2RoleFunction> roleFunction = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY,
+					getAppFunctionParams, null);
+			if (roleFunction.isEmpty()) {
+				getAppFunctionParams.put(FUNCTION_CODE_PARAMS, code);
+				roleFunction = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, getAppFunctionParams, null);
+			}
+			if (roleFunction.size() > 1) {
+				CentralV2RoleFunction getExactFunctionCode = appFunctionListFilter(code, roleFunction);
+				appRoleFunc.setCode(getExactFunctionCode.getCode());
+			} else {
+				appRoleFunc.setCode(roleFunction.get(0).getCode());
+			}
+			dataAccessService.saveDomainObject(appRoleFunc, null);
+		}
+	}
+
+	/**
+	 * 
+	 * It filters the app functions which starts with similar name in the result set
+	 * 
+	 * @param roleFunc
+	 * @param roleFunction
+	 * @return CentralRoleFunction
+	 */
+	private CentralV2RoleFunction appFunctionListFilter(String roleFuncCode, List<CentralV2RoleFunction> roleFunction) {
+		final Map<String, CentralV2RoleFunction> appFunctionsFilter = new HashMap<>();
+		final Map<String, CentralV2RoleFunction> appFunctionsFilterPipes = new HashMap<>();
+		CentralV2RoleFunction getExactFunctionCode = null;
+		for (CentralV2RoleFunction cenRoleFunction : roleFunction) {
+			appFunctionsFilter.put(cenRoleFunction.getCode(), cenRoleFunction);
+			appFunctionsFilterPipes.put(EcompPortalUtils.getFunctionCode(cenRoleFunction.getCode()), cenRoleFunction);
+		}
+		getExactFunctionCode = appFunctionsFilter.get(roleFuncCode);
+		if (getExactFunctionCode == null) {
+			getExactFunctionCode = appFunctionsFilterPipes.get(roleFuncCode);
+		}
+		return getExactFunctionCode;
+	}
+
+	/**
+	 * It deletes all EPAppRoleFunction records in the portal
+	 * 
+	 * @param app
+	 * @param role
+	 */
+	@SuppressWarnings("unchecked")
+	private void deleteRoleFunction(EPApp app, List<EPRole> role) {
+		final Map<String, Long> appRoleFuncsParams = new HashMap<>();
+		appRoleFuncsParams.put("appId", app.getId());
+		appRoleFuncsParams.put("roleId", role.get(0).getId());
+		List<EPAppRoleFunction> appRoleFunctionList = dataAccessService
+				.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null);
+		if (!appRoleFunctionList.isEmpty()) {
+			for (EPAppRoleFunction approleFunction : appRoleFunctionList) {
+				dataAccessService.deleteDomainObject(approleFunction, null);
+			}
+		}
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public List<EPUser> getUser(String loginId) throws InvalidUserException {
+		final Map<String, String> userParams = new HashMap<>();
+		userParams.put("org_user_id", loginId);
+		List<EPUser> userList = dataAccessService.executeNamedQuery("getEPUserByOrgUserId", userParams, null);
+		if (userList.isEmpty()) {
+			throw new InvalidUserException("User not found");
+		}
+		return userList;
+	}
+
+	@Override
+	public String getV2UserWithRoles(String loginId, String uebkey) throws Exception {
+		final Map<String, String> params = new HashMap<>();
+		List<EPUser> userList = null;
+		CentralV2User cenV2User = null;
+		String result = null;
+		try {
+			params.put("orgUserIdValue", loginId);
+			List<EPApp> appList = getApp(uebkey);
+			if (!appList.isEmpty()) {
+				userList = getUser(loginId);
+				if (!userList.isEmpty()) {
+					ObjectMapper mapper = new ObjectMapper();
+					cenV2User = getV2UserAppRoles(loginId, uebkey);
+					result = mapper.writeValueAsString(cenV2User);
+				} else if (userList.isEmpty()) {
+					throw new InvalidUserException("User not found");
+				}
+			} else {
+				throw new InactiveApplicationException("Application not found");
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getUser: failed", e);
+			throw e;
+		}
+		return result;
+	}
+
+	@Override
+	public List<CentralV2Role> getRolesForApp(String uebkey) throws Exception {
+		logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Entering into getRolesForApp");
+		List<CentralV2Role> roleList = new ArrayList<>();
+		final Map<String, Long> params = new HashMap<>();
+		try {
+			List<EPApp> app = getApp(uebkey);
+			List<EPRole> appRolesList = getAppRoles(app.get(0).getId());
+			roleList = createCentralRoleObject(app, appRolesList, roleList, params);
+			if (app.get(0).getId() != PortalConstants.PORTAL_APP_ID) {
+				List<CentralV2Role> globalRoleList = getGlobalRolesOfApplication(app.get(0).getId());
+				List<EPRole> globalRolesList = getGlobalRolesOfPortal();
+				List<CentralV2Role> portalsGlobalRolesFinlaList = new ArrayList<>();
+				if (!globalRolesList.isEmpty()) {
+					for (EPRole eprole : globalRolesList) {
+						CentralV2Role cenRole = convertRoleToCentralV2Role(eprole);
+						portalsGlobalRolesFinlaList.add(cenRole);
+					}
+					roleList.addAll(globalRoleList);
+					for (CentralV2Role role : portalsGlobalRolesFinlaList) {
+						CentralV2Role result = roleList.stream().filter(x -> role.getId().equals(x.getId())).findAny()
+								.orElse(null);
+						if (result == null)
+							roleList.add(role);
+					}
+				} else {
+					for (EPRole role : globalRolesList) {
+						CentralV2Role cenRole = convertRoleToCentralV2Role(role);
+						roleList.add(cenRole);
+					}
+				}
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getRolesForApp: Failed!", e);
+			throw e;
+		}
+		logger.debug(EELFLoggerDelegate.debugLogger, "getRolesForApp: Finished!");
+		return roleList.stream().distinct().collect(Collectors.toList());
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<CentralV2RoleFunction> getRoleFuncList(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		List<CentralV2RoleFunction> finalRoleList = new ArrayList<>();
+		final Map<String, Long> params = new HashMap<>();
+		params.put(APP_ID, app.getId());
+		List<CentralV2RoleFunction> getRoleFuncList = dataAccessService.executeNamedQuery("getAllRoleFunctions", params,
+				null);
+		for (CentralV2RoleFunction roleFuncItem : getRoleFuncList) {
+			String code = EcompPortalUtils.getFunctionCode(roleFuncItem.getCode());
+			String type = "";
+			if (roleFuncItem.getCode().contains("|"))
+				type = EcompPortalUtils.getFunctionType(roleFuncItem.getCode());
+			else
+				type = getFunctionCodeType(roleFuncItem.getCode());
+			String action = getFunctionCodeAction(roleFuncItem.getCode());
+			roleFuncItem.setCode(EPUserUtils.decodeFunctionCode(code));
+			roleFuncItem.setType(type);
+			roleFuncItem.setAction(action);
+			finalRoleList.add(roleFuncItem);
+		}
+		return finalRoleList;
+	}
+
+	@Override
+	public String getFunctionCodeAction(String roleFuncItem) {
+		return (!roleFuncItem.contains(FUNCTION_PIPE)) ? "*" : EcompPortalUtils.getFunctionAction(roleFuncItem);
+	}
+
+	@Override
+	public String getFunctionCodeType(String roleFuncItem) {
+		String type = null;
+		if ((roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("menu"))
+				|| (!roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("menu"))) {
+			type = "menu";
+		} else if (checkIfCodeHasNoPipesAndHasTypeUrl(roleFuncItem) || checkIfCodeHasPipesAndHasTypeUrl(roleFuncItem)
+				|| checkIfCodeHasNoPipesAndHasNoTypeUrl(roleFuncItem)) {
+			type = "url";
+		} else if (roleFuncItem.contains(FUNCTION_PIPE)
+				&& (!roleFuncItem.contains("menu") || roleFuncItem.contains("url"))) {
+			type = EcompPortalUtils.getFunctionType(roleFuncItem);
+		}
+		return type;
+	}
+
+	/**
+	 * 
+	 * It check whether function code has no pipes and no url string in it
+	 * 
+	 * @param roleFuncItem
+	 * @return true or false
+	 */
+	private boolean checkIfCodeHasNoPipesAndHasNoTypeUrl(String roleFuncItem) {
+		return !roleFuncItem.contains(FUNCTION_PIPE) && !roleFuncItem.contains("url");
+	}
+
+	/**
+	 * 
+	 * It check whether function code has pipes and url string in it
+	 * 
+	 * @param roleFuncItem
+	 * @return true or false
+	 */
+	private boolean checkIfCodeHasPipesAndHasTypeUrl(String roleFuncItem) {
+		return roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("url");
+	}
+
+	/**
+	 * 
+	 * It check whether function code has no pipes and has url string in it
+	 * 
+	 * @param roleFuncItem
+	 * @return true or false
+	 */
+	private boolean checkIfCodeHasNoPipesAndHasTypeUrl(String roleFuncItem) {
+		return !roleFuncItem.contains(FUNCTION_PIPE) && roleFuncItem.contains("url");
+	}
+
+	/**
+	 * It returns user detail information which is deep copy of EPUser.class object
+	 * 
+	 * @param userInfo
+	 * @param userAppSet
+	 * @param app
+	 * @return
+	 * @throws Exception
+	 */
+	@SuppressWarnings("unchecked")
+	private CentralV2User createEPUser(EPUser userInfo, Set<EPUserApp> userAppSet, EPApp app) throws Exception {
+		final Map<String, Long> params = new HashMap<>();
+		CentralV2User userAppList = new CentralV2User();
+		CentralV2User user1 = null;
+		final Map<String, Long> params1 = new HashMap<>();
+		List<EPRole> globalRoleList = new ArrayList<>();
+		try {
+			if (app.getId() != PortalConstants.PORTAL_APP_ID) {
+				params1.put("userId", userInfo.getId());
+				params1.put("appId", app.getId());
+				globalRoleList = dataAccessService.executeNamedQuery("userAppGlobalRoles", params1, null);
+			}
+			userAppList.setUserApps(new TreeSet<CentralV2UserApp>());
+			for (EPUserApp userApp : userAppSet) {
+				if (userApp.getRole().getActive()) {
+					EPApp epApp = userApp.getApp();
+					String globalRole = userApp.getRole().getName().toLowerCase();
+					if (((epApp.getId().equals(app.getId()))
+							&& (!userApp.getRole().getId().equals(PortalConstants.ACCOUNT_ADMIN_ROLE_ID)))
+							|| ((epApp.getId().equals(PortalConstants.PORTAL_APP_ID))
+									&& (globalRole.toLowerCase().startsWith("global_")))) {
+						CentralV2UserApp cua = new CentralV2UserApp();
+						cua.setUserId(null);
+						CentralApp cenApp = new CentralApp(1L, epApp.getCreated(), epApp.getModified(),
+								epApp.getCreatedId(), epApp.getModifiedId(), epApp.getRowNum(), epApp.getName(),
+								epApp.getImageUrl(), epApp.getDescription(), epApp.getNotes(), epApp.getUrl(),
+								epApp.getAlternateUrl(), epApp.getAppRestEndpoint(), epApp.getMlAppName(),
+								epApp.getMlAppAdminId(), String.valueOf(epApp.getMotsId()), epApp.getAppPassword(),
+								String.valueOf(epApp.getOpen()), String.valueOf(epApp.getEnabled()),
+								epApp.getThumbnail(), epApp.getUsername(), epApp.getUebKey(), epApp.getUebSecret(),
+								epApp.getUebTopicName());
+						cenApp.setAppPassword(EPCommonSystemProperties.APP_DISPLAY_PASSWORD);
+						cua.setApp(cenApp);
+						Long appId = null;
+						if (globalRole.toLowerCase().startsWith("global_")
+								&& epApp.getId().equals(PortalConstants.PORTAL_APP_ID)
+								&& !epApp.getId().equals(app.getId())) {
+							appId = app.getId();
+							EPRole result = null;
+							if (globalRoleList.size() > 0)
+								result = globalRoleList.stream()
+										.filter(x -> userApp.getRole().getId().equals(x.getId())).findAny()
+										.orElse(null);
+							if (result == null)
+								continue;
+						} else {
+							appId = userApp.getApp().getId();
+						}
+						params.put("roleId", userApp.getRole().getId());
+						params.put(APP_ID, appId);
+						List<CentralV2RoleFunction> appRoleFunctionList = dataAccessService
+								.executeNamedQuery("getAppRoleFunctionList", params, null);
+						SortedSet<CentralV2RoleFunction> roleFunctionSet = new TreeSet<>();
+						for (CentralV2RoleFunction roleFunc : appRoleFunctionList) {
+							String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+							String type = getFunctionCodeType(roleFunc.getCode());
+							String action = getFunctionCodeAction(roleFunc.getCode());
+							CentralV2RoleFunction cenRoleFunc = new CentralV2RoleFunction(roleFunc.getId(),
+									functionCode, roleFunc.getName(), null, type, action, null);
+							roleFunctionSet.add(cenRoleFunc);
+						}
+						Long userRoleId = null;
+						if (globalRole.toLowerCase().startsWith("global_")
+								|| epApp.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+							userRoleId = userApp.getRole().getId();
+						} else {
+							userRoleId = userApp.getRole().getAppRoleId();
+						}
+						CentralV2Role cenRole = new CentralV2Role(userRoleId, userApp.getRole().getCreated(),
+								userApp.getRole().getModified(), userApp.getRole().getCreatedId(),
+								userApp.getRole().getModifiedId(), userApp.getRole().getRowNum(),
+								userApp.getRole().getName(), userApp.getRole().getActive(),
+								userApp.getRole().getPriority(), roleFunctionSet, null, null);
+						cua.setRole(cenRole);
+						userAppList.getUserApps().add(cua);
+					}
+				}
+			}
+			user1 = new CentralV2User(null, userInfo.getCreated(), userInfo.getModified(), userInfo.getCreatedId(),
+					userInfo.getModifiedId(), userInfo.getRowNum(), userInfo.getOrgId(), userInfo.getManagerId(),
+					userInfo.getFirstName(), userInfo.getMiddleInitial(), userInfo.getLastName(), userInfo.getPhone(),
+					userInfo.getFax(), userInfo.getCellular(), userInfo.getEmail(), userInfo.getAddressId(),
+					userInfo.getAlertMethodCd(), userInfo.getHrid(), userInfo.getOrgUserId(), userInfo.getOrgCode(),
+					userInfo.getAddress1(), userInfo.getAddress2(), userInfo.getCity(), userInfo.getState(),
+					userInfo.getZipCode(), userInfo.getCountry(), userInfo.getOrgManagerUserId(),
+					userInfo.getLocationClli(), userInfo.getBusinessCountryCode(), userInfo.getBusinessCountryName(),
+					userInfo.getBusinessUnit(), userInfo.getBusinessUnitName(), userInfo.getDepartment(),
+					userInfo.getDepartmentName(), userInfo.getCompanyCode(), userInfo.getCompany(),
+					userInfo.getZipCodeSuffix(), userInfo.getJobTitle(), userInfo.getCommandChain(),
+					userInfo.getSiloStatus(), userInfo.getCostCenter(), userInfo.getFinancialLocCode(),
+					userInfo.getLoginId(), userInfo.getLoginPwd(), userInfo.getLastLoginDate(), userInfo.getActive(),
+					userInfo.getInternal(), userInfo.getSelectedProfileId(), userInfo.getTimeZoneId(),
+					userInfo.isOnline(), userInfo.getChatId(), userAppList.getUserApps(), null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "createEPUser: createEPUser failed", e);
+			throw e;
+		}
+		return user1;
+	}
+
+	@Override
+	public CentralV2Role getRoleInfo(Long roleId, String uebkey) throws Exception {
+		final Map<String, Long> params = new HashMap<>();
+		List<CentralV2Role> roleList = new ArrayList<>();
+		CentralV2Role cenRole = new CentralV2Role();
+		List<EPRole> roleInfo = null;
+		List<EPApp> app = null;
+		try {
+			app = getApp(uebkey);
+			if (app.isEmpty()) {
+				throw new InactiveApplicationException("Application not found");
+			}
+			if (app.get(0).getId() != PortalConstants.PORTAL_APP_ID) {
+				List<EPRole> globalRoleList = new ArrayList<>();
+				globalRoleList = getGlobalRolesOfPortal();
+				if (globalRoleList.size() > 0) {
+					EPRole result = globalRoleList.stream().filter(x -> roleId.equals(x.getId())).findAny()
+							.orElse(null);
+					if (result != null)
+						return getGlobalRoleForRequestedApp(app.get(0).getId(), roleId);
+				}
+			}
+			if (app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				roleInfo = getPortalAppRoleInfo(roleId);
+			} else {
+				roleInfo = getPartnerAppRoleInfo(roleId, app.get(0));
+			}
+			roleList = createCentralRoleObject(app, roleInfo, roleList, params);
+			if (roleList.isEmpty()) {
+				return cenRole;
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getRoleInfo: failed", e);
+			throw e;
+		}
+		return roleList.get(0);
+	}
+
+	@SuppressWarnings("unchecked")
+	private List<EPRole> getPartnerAppRoleInfo(Long roleId, EPApp app) {
+		List<EPRole> roleInfo;
+		final Map<String, Long> getPartnerAppRoleParams = new HashMap<>();
+		getPartnerAppRoleParams.put("appRoleId", roleId);
+		getPartnerAppRoleParams.put("appId", app.getId());
+		roleInfo = dataAccessService.executeNamedQuery("getPartnerAppRoleByRoleId", getPartnerAppRoleParams, null);
+		if (roleInfo.isEmpty()) {
+			getPartnerAppRoleParams.put("appRoleId", roleId);
+			roleInfo = dataAccessService.executeNamedQuery("getPartnerAppRoleById", getPartnerAppRoleParams, null);
+		}
+		return roleInfo;
+	}
+
+	@SuppressWarnings("unchecked")
+	private List<EPRole> getPortalAppRoleInfo(Long roleId) {
+		List<EPRole> roleInfo;
+		final Map<String, Long> getPortalAppRoleParams = new HashMap<>();
+		getPortalAppRoleParams.put("roleId", roleId);
+		roleInfo = dataAccessService.executeNamedQuery("getPortalAppRoleByRoleId", getPortalAppRoleParams, null);
+		return roleInfo;
+	}
+
+	/**
+	 * 
+	 * It returns list of app roles along with role functions and which went through
+	 * deep copy
+	 * 
+	 * @param app
+	 * @param roleInfo
+	 * @param roleList
+	 * @param params
+	 * @return
+	 * @throws DecoderException
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<CentralV2Role> createCentralRoleObject(List<EPApp> app, List<EPRole> roleInfo,
+			List<CentralV2Role> roleList, Map<String, Long> params) throws RoleFunctionException {
+		for (EPRole role : roleInfo) {
+			params.put("roleId", role.getId());
+			params.put(APP_ID, app.get(0).getId());
+			List<CentralV2RoleFunction> cenRoleFuncList = dataAccessService.executeNamedQuery("getAppRoleFunctionList",
+					params, null);
+			SortedSet<CentralV2RoleFunction> roleFunctionSet = new TreeSet<>();
+			for (CentralV2RoleFunction roleFunc : cenRoleFuncList) {
+				String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+				functionCode = EPUserUtils.decodeFunctionCode(functionCode);
+				String type = getFunctionCodeType(roleFunc.getCode());
+				String action = getFunctionCodeAction(roleFunc.getCode());
+				CentralV2RoleFunction cenRoleFunc = new CentralV2RoleFunction(role.getId(), functionCode,
+						roleFunc.getName(), null, type, action, null);
+				roleFunctionSet.add(cenRoleFunc);
+			}
+			SortedSet<CentralV2Role> childRoles = new TreeSet<>();
+			SortedSet<CentralV2Role> parentRoles = new TreeSet<>();
+			CentralV2Role cenRole = null;
+			if (role.getAppRoleId() == null) {
+				cenRole = new CentralV2Role(role.getId(), role.getCreated(), role.getModified(), role.getCreatedId(),
+						role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(), role.getPriority(),
+						roleFunctionSet, childRoles, parentRoles);
+			} else {
+				cenRole = new CentralV2Role(role.getAppRoleId(), role.getCreated(), role.getModified(),
+						role.getCreatedId(), role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(),
+						role.getPriority(), roleFunctionSet, childRoles, parentRoles);
+			}
+			roleList.add(cenRole);
+		}
+		return roleList;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public CentralV2RoleFunction getRoleFunction(String functionCode, String uebkey) throws Exception {
+		String code = EcompPortalUtils.getFunctionCode(functionCode);
+		String encodedCode = EcompPortalUtils.encodeFunctionCode(code);
+		CentralV2RoleFunction roleFunc = null;
+		EPApp app = getApp(uebkey).get(0);
+		List<CentralV2RoleFunction> getRoleFuncList = null;
+		final Map<String, String> params = new HashMap<>();
+		try {
+			params.put(FUNCTION_CODE_PARAMS, functionCode);
+			params.put(APP_ID, String.valueOf(app.getId()));
+			getRoleFuncList = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
+			if (getRoleFuncList.isEmpty()) {
+				params.put(FUNCTION_CODE_PARAMS, encodedCode);
+				getRoleFuncList = dataAccessService.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
+				if (getRoleFuncList.isEmpty()) {
+					return roleFunc;
+				}
+			}
+			if (getRoleFuncList.size() > 1) {
+				CentralV2RoleFunction cenV2RoleFunction = appFunctionListFilter(encodedCode, getRoleFuncList);
+				if (cenV2RoleFunction == null)
+					return roleFunc;
+				roleFunc = checkIfPipesExitsInFunctionCode(cenV2RoleFunction);
+			} else {
+				// Check even if single record have pipes
+				if (!getRoleFuncList.isEmpty() && getRoleFuncList.get(0).getCode().contains(FUNCTION_PIPE)) {
+					roleFunc = checkIfPipesExitsInFunctionCode(getRoleFuncList.get(0));
+				} else {
+					roleFunc = getRoleFuncList.get(0);
+				}
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getRoleFunction: failed", e);
+			throw e;
+		}
+		return roleFunc;
+	}
+
+	private CentralV2RoleFunction checkIfPipesExitsInFunctionCode(CentralV2RoleFunction getRoleFuncList) {
+		CentralV2RoleFunction roleFunc;
+		String functionCodeFormat = getRoleFuncList.getCode();
+		if (functionCodeFormat.contains(FUNCTION_PIPE)) {
+			String newfunctionCodeFormat = EcompPortalUtils.getFunctionCode(functionCodeFormat);
+			String newfunctionTypeFormat = EcompPortalUtils.getFunctionType(functionCodeFormat);
+			String newfunctionActionFormat = EcompPortalUtils.getFunctionAction(functionCodeFormat);
+			roleFunc = new CentralV2RoleFunction(getRoleFuncList.getId(), newfunctionCodeFormat,
+					getRoleFuncList.getName(), getRoleFuncList.getAppId(), newfunctionTypeFormat,
+					newfunctionActionFormat, getRoleFuncList.getEditUrl());
+		} else {
+			roleFunc = new CentralV2RoleFunction(getRoleFuncList.getId(), functionCodeFormat, getRoleFuncList.getName(),
+					getRoleFuncList.getAppId(), getRoleFuncList.getEditUrl());
+		}
+		return roleFunc;
+	}
+
+	@Override
+	public boolean saveCentralRoleFunction(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
+			throws Exception {
+		boolean saveOrUpdateFunction = false;
+		try {
+			if(EcompPortalUtils.checkFunctionCodeHasEncodePattern(domainCentralRoleFunction.getCode()))
+			 domainCentralRoleFunction.setCode(EcompPortalUtils.encodeFunctionCode(domainCentralRoleFunction.getCode()));
+			final Map<String, String> functionParams = new HashMap<>();
+			functionParams.put("appId", String.valueOf(app.getId()));
+			if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+				addRoleFunctionInExternalSystem(domainCentralRoleFunction, app);
+			}
+			if (domainCentralRoleFunction.getType() != null && domainCentralRoleFunction.getAction() != null) {
+				domainCentralRoleFunction.setCode(domainCentralRoleFunction.getType() + FUNCTION_PIPE
+						+ domainCentralRoleFunction.getCode() + FUNCTION_PIPE + domainCentralRoleFunction.getAction());
+			}
+			domainCentralRoleFunction.setAppId(app.getId());
+			dataAccessService.saveDomainObject(domainCentralRoleFunction, null);
+			saveOrUpdateFunction = true;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "saveCentralRoleFunction: failed", e);
+			throw e;
+		}
+		return saveOrUpdateFunction;
+	}
+
+	/**
+	 * It creates application permission in external auth system
+	 * 
+	 * @param domainCentralRoleFunction
+	 * @param app
+	 * @throws Exception
+	 */
+	private void addRoleFunctionInExternalSystem(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
+			throws Exception {
+		ObjectMapper mapper = new ObjectMapper();
+		ExternalAccessPerms extPerms = new ExternalAccessPerms();
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		String type = "";
+		String instance = "";
+		String action = "";
+		if ((domainCentralRoleFunction.getType() != null && domainCentralRoleFunction.getAction() != null)
+				|| domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)) {
+			type = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
+					? EcompPortalUtils.getFunctionType(domainCentralRoleFunction.getCode())
+					: domainCentralRoleFunction.getType();
+			instance = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
+					? EcompPortalUtils.getFunctionCode(domainCentralRoleFunction.getCode())
+					: domainCentralRoleFunction.getCode();
+			action = domainCentralRoleFunction.getCode().contains(FUNCTION_PIPE)
+					? EcompPortalUtils.getFunctionAction(domainCentralRoleFunction.getCode())
+					: domainCentralRoleFunction.getAction();
+		} else {
+			type = domainCentralRoleFunction.getCode().contains("menu") ? "menu" : "url";
+			instance = domainCentralRoleFunction.getCode();
+			action = "*";
+		}
+		// get Permissions from External Auth System
+		JSONArray extPermsList = getExtAuthPermissions(app);
+		List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPermsList);
+		String requestedPerm = type + FUNCTION_PIPE + instance + FUNCTION_PIPE + action;
+		boolean checkIfFunctionsExits = permsDetailList.stream()
+				.anyMatch(permsDetail -> permsDetail.getInstance().equals(requestedPerm));
+		if (!checkIfFunctionsExits) {
+			try {
+				extPerms.setAction(action);
+				extPerms.setInstance(instance);
+				extPerms.setType(app.getNameSpace() + "." + type);
+				extPerms.setDescription(domainCentralRoleFunction.getName());
+				String addFunction = mapper.writeValueAsString(extPerms);
+				HttpEntity<String> entity = new HttpEntity<>(addFunction, headers);
+				logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionInExternalSystem: {} for POST: {}",
+						CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addFunction);
+				ResponseEntity<String> addPermResponse = template.exchange(
+						SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
+						HttpMethod.POST, entity, String.class);
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"addRoleFunctionInExternalSystem: Finished adding permission for POST: {} and status code: {} ",
+						addPermResponse.getStatusCode().value(), addFunction);
+			} catch (HttpClientErrorException e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"HttpClientErrorException - Failed to add function in external central auth system", e);
+				EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+				throw e;
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleFunctionInExternalSystem: Failed to add fucntion in external central auth system", e);
+				throw e;
+			}
+		} else {
+			try {
+				extPerms.setAction(action);
+				extPerms.setInstance(instance);
+				extPerms.setType(app.getNameSpace() + "." + type);
+				extPerms.setDescription(domainCentralRoleFunction.getName());
+				String updateRoleFunction = mapper.writeValueAsString(extPerms);
+				HttpEntity<String> entity = new HttpEntity<>(updateRoleFunction, headers);
+				logger.debug(EELFLoggerDelegate.debugLogger, "addRoleFunctionInExternalSystem: {} for PUT: {}",
+						CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRoleFunction);
+				ResponseEntity<String> updatePermResponse = template.exchange(
+						SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
+						HttpMethod.PUT, entity, String.class);
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"addRoleFunctionInExternalSystem: Finished updating permission in External Auth system {} and response: {} ",
+						updateRoleFunction, updatePermResponse.getStatusCode().value());
+			} catch (HttpClientErrorException e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"HttpClientErrorException - Failed to add function in external central auth system", e);
+				EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+				throw e;
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleFunctionInExternalSystem: Failed to update function in external central auth system",
+						e);
+				throw e;
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public boolean deleteCentralRoleFunction(String code, EPApp app) {
+		boolean deleteFunctionResponse = false;
+		try {
+			final Map<String, String> params = new HashMap<>();
+			params.put(FUNCTION_CODE_PARAMS, code);
+			params.put(APP_ID, String.valueOf(app.getId()));
+			List<CentralV2RoleFunction> domainCentralRoleFunction = dataAccessService
+					.executeNamedQuery(GET_ROLE_FUNCTION_QUERY, params, null);
+			CentralV2RoleFunction appFunctionCode = appFunctionListFilter(code, domainCentralRoleFunction);
+			if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+				deleteRoleFunctionInExternalSystem(appFunctionCode, app);
+				// Delete role function dependency records
+				deleteAppRoleFunctions(appFunctionCode.getCode(), app);
+			}
+			dataAccessService.deleteDomainObject(appFunctionCode, null);
+			deleteFunctionResponse = true;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "deleteCentralRoleFunction: failed", e);
+		}
+		return deleteFunctionResponse;
+	}
+
+	/**
+	 * It deletes app function record in portal
+	 * 
+	 * @param code
+	 * @param app
+	 */
+	private void deleteAppRoleFunctions(String code, EPApp app) {
+		dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
+				APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + code + "'", null);
+	}
+
+	/**
+	 * 
+	 * It deletes permission in the external auth system
+	 * 
+	 * @param domainCentralRoleFunction
+	 * @param app
+	 * @throws Exception
+	 */
+	private void deleteRoleFunctionInExternalSystem(CentralV2RoleFunction domainCentralRoleFunction, EPApp app)
+			throws Exception {
+		try {
+			ObjectMapper mapper = new ObjectMapper();
+			ExternalAccessPerms extPerms = new ExternalAccessPerms();
+			String instanceValue = EcompPortalUtils.getFunctionCode(domainCentralRoleFunction.getCode());
+			String checkType = getFunctionCodeType(domainCentralRoleFunction.getCode());
+			String actionValue = getFunctionCodeAction(domainCentralRoleFunction.getCode());
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			extPerms.setAction(actionValue);
+			extPerms.setInstance(instanceValue);
+			extPerms.setType(app.getNameSpace() + "." + checkType);
+			extPerms.setDescription(domainCentralRoleFunction.getName());
+			String deleteRoleFunction = mapper.writeValueAsString(extPerms);
+			HttpEntity<String> entity = new HttpEntity<>(deleteRoleFunction, headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleFunctionInExternalSystem: {} for DELETE: {} ",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, deleteRoleFunction);
+			ResponseEntity<String> delPermResponse = template
+					.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+							+ "perm?force=true", HttpMethod.DELETE, entity, String.class);
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"deleteRoleFunctionInExternalSystem: Finished deleting permission in External Auth system {} and status code: {} ",
+					deleteRoleFunction, delPermResponse.getStatusCode().value());
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to delete functions in External System", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			if (e.getMessage().equalsIgnoreCase("404 Not Found")) {
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						" deleteRoleFunctionInExternalSystem: It seems like function is already deleted in external central auth system  but exists in local DB",
+						e.getMessage());
+			} else {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"deleteRoleFunctionInExternalSystem: Failed to delete functions in External System", e);
+			}
+		}
+	}
+
+	@Override
+	public ExternalRequestFieldsValidator saveRoleForApplication(Role saveRole, String uebkey) throws Exception {
+		boolean response = false;
+		String message = "";
+		try {
+			EPApp app = getApp(uebkey).get(0);
+			addRoleInEcompDB(saveRole, app);
+			response = true;
+		} catch (Exception e) {
+			message = e.getMessage();
+			logger.error(EELFLoggerDelegate.errorLogger, "saveRoleForApplication failed", e);
+		}
+		return new ExternalRequestFieldsValidator(response, message);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public boolean deleteRoleForApplication(String deleteRole, String uebkey) throws Exception {
+		Session localSession = sessionFactory.openSession();
+		Transaction transaction = null;
+		boolean result = false;
+		try {
+			List<EPRole> epRoleList = null;
+			EPApp app = getApp(uebkey).get(0);
+			final Map<String, String> deleteRoleParams = new HashMap<>();
+			deleteRoleParams.put(APP_ROLE_NAME_PARAM, deleteRole);
+			if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				epRoleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, deleteRoleParams, null);
+			} else {
+				deleteRoleParams.put(APP_ID, String.valueOf(app.getId()));
+				epRoleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
+						deleteRoleParams, null);
+			}
+			if (!epRoleList.isEmpty()) {
+				transaction = localSession.beginTransaction();
+				// Delete app role functions before deleting role
+				deleteRoleFunction(app, epRoleList);
+				if (app.getId() == 1) {
+					// Delete fn_user_ role
+					dataAccessService.deleteDomainObjects(EPUserApp.class,
+							APP_ID_EQUALS + app.getId() + " and role_id = " + epRoleList.get(0).getId(), null);
+					boolean isPortalRequest = false;
+					deleteRoleDependencyRecords(localSession, epRoleList.get(0).getId(), app.getId(), isPortalRequest);
+				}
+				deleteRoleInExternalAuthSystem(epRoleList, app);
+				transaction.commit();
+				logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleForApplication: committed the transaction");
+				dataAccessService.deleteDomainObject(epRoleList.get(0), null);
+			}
+			result = true;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "deleteRoleForApplication: failed", e);
+			result = false;
+		} finally {
+			localSession.close();
+		}
+		return result;
+	}
+
+	/**
+	 * 
+	 * It deletes role for application in external auth system
+	 * 
+	 * @param epRoleList contains role information
+	 * @param app        contains application information
+	 * @throws Exception
+	 */
+	private void deleteRoleInExternalAuthSystem(List<EPRole> epRoleList, EPApp app) throws Exception {
+		ResponseEntity<String> deleteResponse;
+		ResponseEntity<String> res = getNameSpaceIfExists(app);
+		if (res.getStatusCode() == HttpStatus.OK) {
+			// Delete Role in External System
+			String deleteRoleKey = "{\"name\":\"" + app.getNameSpace() + "." + epRoleList.get(0).getName()
+					.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_") + "\"}";
+			deleteResponse = deleteRoleInExternalSystem(deleteRoleKey);
+			if (deleteResponse.getStatusCode().value() != 200 && deleteResponse.getStatusCode().value() != 404) {
+				EPLogUtil.logExternalAuthAccessAlarm(logger, deleteResponse.getStatusCode());
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"deleteRoleForApplication: Failed to delete role in external auth system! due to {} ",
+						deleteResponse.getBody());
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleForApplication: about to commit the transaction");
+		}
+	}
+
+	/**
+	 * 
+	 * It deletes application user role in external auth system
+	 * 
+	 * @param role
+	 * @param app
+	 * @param LoginId
+	 * @throws Exception
+	 */
+	private void deleteUserRoleInExternalSystem(EPRole role, EPApp app, String LoginId) throws Exception {
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		getNameSpaceIfExists(app);
+		logger.debug(EELFLoggerDelegate.debugLogger, "deleteUserRoleInExternalSystem: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+		ResponseEntity<String> getResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole/"
+						+ LoginId
+						+ SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)
+						+ "/" + app.getNameSpace() + "."
+						+ role.getName()
+								.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+				HttpMethod.GET, entity, String.class);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"deleteUserRoleInExternalSystem: Finished GET user roles from External Auth system and response: {} ",
+				getResponse.getBody());
+		if (getResponse.getStatusCode().value() != 200) {
+			throw new ExternalAuthSystemException(getResponse.getBody());
+		}
+		String res = getResponse.getBody();
+		if (!res.equals(IS_EMPTY_JSON_STRING)) {
+			HttpEntity<String> userRoleentity = new HttpEntity<>(headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "deleteUserRoleInExternalSystem: {} ",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+			ResponseEntity<String> deleteResponse = template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole/"
+							+ LoginId
+							+ SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)
+							+ "/" + app.getNameSpace() + "."
+							+ role.getName().replaceAll(
+									EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+					HttpMethod.DELETE, userRoleentity, String.class);
+			if (deleteResponse.getStatusCode().value() != 200) {
+				throw new ExternalAuthSystemException("Failed to delete user role");
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"deleteUserRoleInExternalSystem: Finished deleting user role in External Auth system and status code: {} ",
+					deleteResponse.getStatusCode().value());
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<CentralV2Role> getActiveRoles(String uebkey) throws Exception {
+		List<CentralV2Role> roleList = new ArrayList<>();
+		try {
+			List<EPApp> app = getApp(uebkey);
+			final Map<String, Long> params = new HashMap<>();
+			// check if portal
+			Long appId = null;
+			if (!app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				appId = app.get(0).getId();
+			}
+			List<Criterion> restrictionsList = new ArrayList<Criterion>();
+			Criterion active_ynCrt = Restrictions.eq("active", Boolean.TRUE);
+			Criterion appIdCrt;
+			if (appId == null)
+				appIdCrt = Restrictions.isNull("appId");
+			else
+				appIdCrt = Restrictions.eq("appId", appId);
+			Criterion andCrit = Restrictions.and(active_ynCrt, appIdCrt);
+			restrictionsList.add(andCrit);
+			List<EPRole> epRole = (List<EPRole>) dataAccessService.getList(EPRole.class, null, restrictionsList, null);
+			roleList = createCentralRoleObject(app, epRole, roleList, params);
+			List<CentralV2Role> globalRoleList = getGlobalRolesOfApplication(app.get(0).getId());
+			if (globalRoleList.size() > 0)
+				roleList.addAll(globalRoleList);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getActiveRoles: failed", e);
+			throw e;
+		}
+		return roleList;
+	}
+
+	@Override
+	@Transactional(rollbackFor = Exception.class)
+	public ExternalRequestFieldsValidator deleteDependencyRoleRecord(Long roleId, String uebkey, String LoginId)
+			throws Exception {
+		Session localSession = sessionFactory.openSession();
+		String message = "";
+		Transaction transaction = null;
+		boolean response = false;
+		EPApp app = null;
+		try {
+			transaction = localSession.beginTransaction();
+			List<EPRole> epRoleList = null;
+			app = getApp(uebkey).get(0);
+			if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				epRoleList = getPortalAppRoleInfo(roleId);
+			} else {
+				epRoleList = getPartnerAppRoleInfo(roleId, app);
+			}
+			if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+				// Delete User Role in External System before deleting role
+				deleteUserRoleInExternalSystem(epRoleList.get(0), app, LoginId);
+			}
+			// Delete user app roles
+			dataAccessService.deleteDomainObjects(EPUserApp.class,
+					APP_ID_EQUALS + app.getId() + " and role_id = " + epRoleList.get(0).getId(), null);
+			boolean isPortalRequest = false;
+			deleteRoleDependencyRecords(localSession, epRoleList.get(0).getId(), app.getId(), isPortalRequest);
+			transaction.commit();
+			if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+				// Final call to delete role once all dependencies has been
+				// deleted
+				deleteRoleInExternalAuthSystem(epRoleList, app);
+			}
+			dataAccessService.deleteDomainObjects(EPRole.class, " role_id = " + epRoleList.get(0).getId(), null);
+			logger.debug(EELFLoggerDelegate.debugLogger, "deleteDependencyRoleRecord: committed the transaction");
+			response = true;
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord: HttpClientErrorException", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+			message = e.getMessage();
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "deleteDependencyRoleRecord failed", e);
+			EcompPortalUtils.rollbackTransaction(transaction,
+					"deleteDependencyRoleRecord rollback, exception = " + e.toString());
+			message = e.getMessage();
+		} finally {
+			localSession.close();
+		}
+		return new ExternalRequestFieldsValidator(response, message);
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	@Transactional
+	public void syncRoleFunctionFromExternalAccessSystem(EPApp app) {
+		try {
+			// get Permissions from External Auth System
+			JSONArray extPerms = getExtAuthPermissions(app);
+			List<ExternalAccessPermsDetail> permsDetailList = getExtAuthPerrmissonList(app, extPerms);
+			// get functions in DB
+			final Map<String, Long> params = new HashMap<>();
+			final Map<String, CentralV2RoleFunction> roleFuncMap = new HashMap<>();
+			params.put(APP_ID, app.getId());
+			List<CentralV2RoleFunction> appFunctions = dataAccessService.executeNamedQuery("getAllRoleFunctions",
+					params, null);
+			if (!appFunctions.isEmpty()) {
+				for (CentralV2RoleFunction roleFunc : appFunctions) {
+					roleFuncMap.put(roleFunc.getCode(), roleFunc);
+				}
+			}
+			// get Roles for portal in DB
+			List<EPRole> portalRoleList = getGlobalRolesOfPortal();
+			final Map<String, EPRole> existingPortalRolesMap = new HashMap<>();
+			for (EPRole epRole : portalRoleList) {
+				existingPortalRolesMap.put(epRole.getName().replaceAll(
+						EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), epRole);
+			}
+			// get Roles in DB
+			final Map<String, EPRole> currentRolesInDB = getAppRoleNamesWithUnderscoreMap(app);
+			// store External Permissions with Pipe and without Pipe (just
+			// instance)
+			final Map<String, ExternalAccessPermsDetail> extAccessPermsContainsPipeMap = new HashMap<>();
+			final Map<String, ExternalAccessPermsDetail> extAccessPermsMap = new HashMap<>();
+			for (ExternalAccessPermsDetail permsDetailInfoWithPipe : permsDetailList) {
+				extAccessPermsContainsPipeMap.put(permsDetailInfoWithPipe.getInstance(), permsDetailInfoWithPipe);
+				String finalFunctionCodeVal = EcompPortalUtils.getFunctionCode(permsDetailInfoWithPipe.getInstance());
+				extAccessPermsMap.put(finalFunctionCodeVal, permsDetailInfoWithPipe);
+			}
+			// Add if new functions and app role functions were added in
+			// external auth system
+			for (ExternalAccessPermsDetail permsDetail : permsDetailList) {
+				String code = permsDetail.getInstance();
+				CentralV2RoleFunction getFunctionCodeKey = roleFuncMap.get(permsDetail.getInstance());
+				List<CentralV2RoleFunction> roleFunctionList = addGetLocalFunction(app, roleFuncMap, permsDetail, code,
+						getFunctionCodeKey);
+				List<String> roles = permsDetail.getRoles();
+				if (roles != null) {
+					// Check if function has any roles and which does not exist
+					// in External Auth System. If exists delete in local
+					addRemoveIfFunctionsRolesIsSyncWithExternalAuth(app, currentRolesInDB, roleFunctionList, roles,
+							existingPortalRolesMap);
+				}
+			}
+			// Check if function does exits in External Auth System but exits in
+			// local then delete function and its dependencies
+			for (CentralV2RoleFunction roleFunc : appFunctions) {
+				try {
+					ExternalAccessPermsDetail getFunctionCodeContainsPipeKey = extAccessPermsContainsPipeMap
+							.get(roleFunc.getCode());
+					if (null == getFunctionCodeContainsPipeKey) {
+						ExternalAccessPermsDetail getFunctionCodeKey = extAccessPermsMap.get(roleFunc.getCode());
+						if (null == getFunctionCodeKey) {
+							deleteAppRoleFuncDoesNotExitsInExtSystem(app, roleFunc);
+						}
+					}
+				} catch (Exception e) {
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"syncRoleFunctionFromExternalAccessSystem: Failed to delete function", e);
+				}
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"syncRoleFunctionFromExternalAccessSystem: Finished syncRoleFunctionFromExternalAccessSystem");
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"syncRoleFunctionFromExternalAccessSystem: Failed syncRoleFunctionFromExternalAccessSystem", e);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private void addRemoveIfFunctionsRolesIsSyncWithExternalAuth(EPApp app, final Map<String, EPRole> currentRolesInDB,
+			List<CentralV2RoleFunction> roleFunctionList, List<String> roles,
+			Map<String, EPRole> existingPortalRolesMap) throws Exception {
+		if (!roleFunctionList.isEmpty()) {
+			final Map<String, String> appRoleFuncParams = new HashMap<>();
+			final Map<String, LocalRole> currentAppRoleFunctionsMap = new HashMap<>();
+			final Map<String, String> currentRolesInExtSystem = new HashMap<>();
+			appRoleFuncParams.put("functionCd", roleFunctionList.get(0).getCode());
+			appRoleFuncParams.put("appId", String.valueOf(app.getId()));
+			List<LocalRole> localRoleList = dataAccessService.executeNamedQuery("getCurrentAppRoleFunctions",
+					appRoleFuncParams, null);
+			for (LocalRole localRole : localRoleList) {
+				currentAppRoleFunctionsMap.put(localRole.getRolename().replaceAll(
+						EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), localRole);
+			}
+			for (String addRole : roles) {
+				currentRolesInExtSystem.put(addRole.substring(addRole.indexOf(FUNCTION_PIPE) + 1), addRole);
+			}
+			for (String extAuthrole : roles) {
+				String roleNameSpace = extAuthrole.substring(0, extAuthrole.indexOf(FUNCTION_PIPE));
+				boolean isNameSpaceMatching = EcompPortalUtils.checkNameSpaceMatching(roleNameSpace,
+						app.getNameSpace());
+				if (isNameSpaceMatching) {
+					if (!currentAppRoleFunctionsMap
+							.containsKey(extAuthrole.substring(app.getNameSpace().length() + 1))) {
+						EPRole localAddFuntionRole = currentRolesInDB
+								.get(extAuthrole.substring(app.getNameSpace().length() + 1));
+						if (localAddFuntionRole == null) {
+							checkAndAddRoleInDB(app, currentRolesInDB, roleFunctionList, extAuthrole);
+						} else {
+							EPAppRoleFunction addAppRoleFunc = new EPAppRoleFunction();
+							addAppRoleFunc.setAppId(app.getId());
+							addAppRoleFunc.setCode(roleFunctionList.get(0).getCode());
+							addAppRoleFunc.setRoleId(localAddFuntionRole.getId());
+							dataAccessService.saveDomainObject(addAppRoleFunc, null);
+						}
+					}
+					// This block is to save global role function if exists
+				} else {
+					String extAuthAppRoleName = extAuthrole.substring(extAuthrole.indexOf(FUNCTION_PIPE) + 1);
+					boolean checkIfGlobalRoleExists = existingPortalRolesMap.containsKey(extAuthAppRoleName);
+					if (checkIfGlobalRoleExists) {
+						final Map<String, Long> params = new HashMap<>();
+						EPRole role = existingPortalRolesMap.get(extAuthAppRoleName);
+						EPAppRoleFunction addGlobalRoleFunctions = new EPAppRoleFunction();
+						params.put("appId", app.getId());
+						params.put("roleId", role.getId());
+						List<EPAppRoleFunction> currentGlobalRoleFunctionsList = dataAccessService
+								.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", params, null);
+						boolean checkIfRoleFunctionExists = currentGlobalRoleFunctionsList.stream()
+								.anyMatch(currentGlobalRoleFunction -> currentGlobalRoleFunction.getCode()
+										.equals(roleFunctionList.get(0).getCode()));
+						if (role != null && !checkIfRoleFunctionExists) {
+							addGlobalRoleFunctions.setAppId(app.getId());
+							addGlobalRoleFunctions.setRoleId(role.getId());
+							if (!app.getId().equals(role.getAppRoleId())) {
+								addGlobalRoleFunctions.setRoleAppId((PortalConstants.PORTAL_APP_ID).toString());
+							} else {
+								addGlobalRoleFunctions.setRoleAppId(null);
+							}
+							addGlobalRoleFunctions.setCode(roleFunctionList.get(0).getCode());
+							dataAccessService.saveDomainObject(addGlobalRoleFunctions, null);
+						}
+					}
+				}
+			}
+			for (LocalRole localRoleDelete : localRoleList) {
+				if (!currentRolesInExtSystem.containsKey(localRoleDelete.getRolename()
+						.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"))) {
+					dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
+							APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunctionList.get(0).getCode()
+									+ "'" + " and role_id = " + localRoleDelete.getRoleId().longValue(),
+							null);
+				}
+			}
+		}
+	}
+
+	private void deleteAppRoleFuncDoesNotExitsInExtSystem(EPApp app, CentralV2RoleFunction roleFunc) {
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncRoleFunctionFromExternalAccessSystem: Deleting app role function {}", roleFunc.getCode());
+		dataAccessService.deleteDomainObjects(EPAppRoleFunction.class,
+				APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunc.getCode() + "'", null);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncRoleFunctionFromExternalAccessSystem: Deleted app role function {}", roleFunc.getCode());
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncRoleFunctionFromExternalAccessSystem: Deleting app function {}", roleFunc.getCode());
+		dataAccessService.deleteDomainObjects(CentralV2RoleFunction.class,
+				APP_ID_EQUALS + app.getId() + AND_FUNCTION_CD_EQUALS + roleFunc.getCode() + "'", null);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncRoleFunctionFromExternalAccessSystem: Deleted app function {}", roleFunc.getCode());
+	}
+
+	private void checkAndAddRoleInDB(EPApp app, final Map<String, EPRole> currentRolesInDB,
+			List<CentralV2RoleFunction> roleFunctionList, String roleList) throws Exception {
+		if (!currentRolesInDB.containsKey(roleList.substring(app.getNameSpace().length() + 1))) {
+			Role role = addRoleInDBIfDoesNotExists(app, roleList.substring(app.getNameSpace().length() + 1));
+			addRoleDescriptionInExtSystem(role, app);
+			if (!roleFunctionList.isEmpty()) {
+				try {
+					if (!roleFunctionList.isEmpty()) {
+						EPAppRoleFunction addAppRoleFunc = new EPAppRoleFunction();
+						addAppRoleFunc.setAppId(app.getId());
+						addAppRoleFunc.setCode(roleFunctionList.get(0).getCode());
+						addAppRoleFunc.setRoleId(role.getId());
+						dataAccessService.saveDomainObject(addAppRoleFunc, null);
+					}
+				} catch (Exception e) {
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"syncRoleFunctionFromExternalAccessSystem: Failed to save app role function ", e);
+				}
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private List<CentralV2RoleFunction> addGetLocalFunction(EPApp app,
+			final Map<String, CentralV2RoleFunction> roleFuncMap, ExternalAccessPermsDetail permsDetail, String code,
+			CentralV2RoleFunction getFunctionCodeKey) {
+		String finalFunctionCodeVal = addToLocalIfFunctionNotExists(app, roleFuncMap, permsDetail, code,
+				getFunctionCodeKey);
+		final Map<String, String> appSyncFuncsParams = new HashMap<>();
+		appSyncFuncsParams.put("appId", String.valueOf(app.getId()));
+		appSyncFuncsParams.put("functionCd", finalFunctionCodeVal);
+		List<CentralV2RoleFunction> roleFunctionList = null;
+		roleFunctionList = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams,
+				null);
+		if (roleFunctionList.isEmpty()) {
+			appSyncFuncsParams.put("functionCd", code);
+			roleFunctionList = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId", appSyncFuncsParams,
+					null);
+		}
+		return roleFunctionList;
+	}
+
+	private String addToLocalIfFunctionNotExists(EPApp app, final Map<String, CentralV2RoleFunction> roleFuncMap,
+			ExternalAccessPermsDetail permsDetail, String code, CentralV2RoleFunction getFunctionCodeKey) {
+		String finalFunctionCodeVal = "";
+		if (null == getFunctionCodeKey) {
+			finalFunctionCodeVal = EcompPortalUtils.getFunctionCode(permsDetail.getInstance());
+			CentralV2RoleFunction checkIfCodeStillExits = roleFuncMap.get(finalFunctionCodeVal);
+			// If function does not exist in local then add!
+			if (null == checkIfCodeStillExits) {
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"syncRoleFunctionFromExternalAccessSystem: Adding function: {} ", code);
+				addFunctionInEcompDB(app, permsDetail, code);
+				logger.debug(EELFLoggerDelegate.debugLogger,
+						"syncRoleFunctionFromExternalAccessSystem: Finished adding function: {} ", code);
+			}
+		}
+		return finalFunctionCodeVal;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Map<String, EPRole> getAppRoleNamesWithUnderscoreMap(EPApp app) {
+		final Map<String, EPRole> currentRolesInDB = new HashMap<>();
+		List<EPRole> getCurrentRoleList = null;
+		final Map<String, Long> appParams = new HashMap<>();
+		if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+			getCurrentRoleList = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
+		} else {
+			appParams.put("appId", app.getId());
+			getCurrentRoleList = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
+		}
+		for (EPRole role : getCurrentRoleList) {
+			currentRolesInDB.put(role.getName()
+					.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"), role);
+		}
+		return currentRolesInDB;
+	}
+
+	@SuppressWarnings("unchecked")
+	private Map<String, EPRole> getAppRoleNamesMap(EPApp app) {
+		final Map<String, EPRole> currentRolesInDB = new HashMap<>();
+		List<EPRole> getCurrentRoleList = null;
+		final Map<String, Long> appParams = new HashMap<>();
+		if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+			getCurrentRoleList = dataAccessService.executeNamedQuery("getPortalAppRolesList", null, null);
+		} else {
+			appParams.put("appId", app.getId());
+			getCurrentRoleList = dataAccessService.executeNamedQuery("getPartnerAppRolesList", appParams, null);
+		}
+		for (EPRole role : getCurrentRoleList) {
+			currentRolesInDB.put(role.getName(), role);
+		}
+		return currentRolesInDB;
+	}
+
+	private List<ExternalAccessPermsDetail> getExtAuthPerrmissonList(EPApp app, JSONArray extPerms) throws IOException {
+		ExternalAccessPermsDetail permDetails = null;
+		List<ExternalAccessPermsDetail> permsDetailList = new ArrayList<>();
+		for (int i = 0; i < extPerms.length(); i++) {
+			String description = null;
+			if (extPerms.getJSONObject(i).has("description")) {
+				description = extPerms.getJSONObject(i).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
+			} else {
+				description = extPerms.getJSONObject(i).getString("type").substring(app.getNameSpace().length() + 1) + "|"
+						+ extPerms.getJSONObject(i).getString("instance") + "|"
+						+ extPerms.getJSONObject(i).getString("action");
+			}
+			if (extPerms.getJSONObject(i).has("roles")) {
+				ObjectMapper rolesListMapper = new ObjectMapper();
+				JSONArray resRoles = extPerms.getJSONObject(i).getJSONArray("roles");
+				List<String> list = rolesListMapper.readValue(resRoles.toString(),
+						TypeFactory.defaultInstance().constructCollectionType(List.class, String.class));
+				permDetails = new ExternalAccessPermsDetail(extPerms.getJSONObject(i).getString("type"),
+						extPerms.getJSONObject(i).getString("type").substring(app.getNameSpace().length() + 1)
+								+ FUNCTION_PIPE + extPerms.getJSONObject(i).getString("instance") + FUNCTION_PIPE
+								+ extPerms.getJSONObject(i).getString("action"),
+						extPerms.getJSONObject(i).getString("action"), list, description);
+				permsDetailList.add(permDetails);
+			} else {
+				permDetails = new ExternalAccessPermsDetail(extPerms.getJSONObject(i).getString("type"),
+						extPerms.getJSONObject(i).getString("type").substring(app.getNameSpace().length() + 1)
+								+ FUNCTION_PIPE + extPerms.getJSONObject(i).getString("instance") + FUNCTION_PIPE
+								+ extPerms.getJSONObject(i).getString("action"),
+						extPerms.getJSONObject(i).getString("action"), description);
+				permsDetailList.add(permDetails);
+			}
+		}
+		return permsDetailList;
+	}
+
+	private JSONArray getExtAuthPermissions(EPApp app) throws Exception {
+		ResponseEntity<String> response = null;
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+		response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+				+ "perms/ns/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
+		String res = response.getBody();
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncRoleFunctionFromExternalAccessSystem: Finished GET permissions from External Auth system and response: {} ",
+				response.getBody());
+		JSONObject jsonObj = new JSONObject(res);
+		JSONArray extPerms = jsonObj.getJSONArray("perm");
+		for (int i = 0; i < extPerms.length(); i++) {
+			if (extPerms.getJSONObject(i).getString("type").equals(app.getNameSpace() + ".access")) {
+				extPerms.remove(i);
+				i--;
+			}
+		}
+		return extPerms;
+	}
+
+	/**
+	 * 
+	 * Add function into local DB
+	 * 
+	 * @param app
+	 * @param permsDetail
+	 * @param code
+	 */
+	private void addFunctionInEcompDB(EPApp app, ExternalAccessPermsDetail permsDetail, String code) {
+		try {
+			CentralV2RoleFunction addFunction = new CentralV2RoleFunction();
+			addFunction.setAppId(app.getId());
+			addFunction.setCode(code);
+			addFunction.setName(permsDetail.getDescription());
+			dataAccessService.saveDomainObject(addFunction, null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addFunctionInEcompDB: Failed to add function", e);
+		}
+	}
+
+	/**
+	 * 
+	 * It updates description of a role in external auth system
+	 * 
+	 * @param role
+	 * @param app
+	 * @throws Exception
+	 */
+	private boolean addRoleDescriptionInExtSystem(Role role, EPApp app) throws Exception {
+		boolean status = false;
+		try {
+			String addRoleNew = updateExistingRoleInExternalSystem(role, app);
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			HttpEntity<String> entity = new HttpEntity<>(addRoleNew, headers);
+			template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
+					HttpMethod.PUT, entity, String.class);
+			status = true;
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to addRoleDescriptionInExtSystem", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addRoleDescriptionInExtSystem: Failed", e);
+		}
+		return status;
+	}
+
+	/**
+	 * 
+	 * While sync functions form external auth system if new role found we should
+	 * add in local and return Role.class object
+	 * 
+	 * @param app
+	 * @param role
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	private Role addRoleInDBIfDoesNotExists(EPApp app, String role) {
+		Role setNewRole = new Role();
+		try {
+			// functions can have new role created in External Auth System
+			// prevent
+			// duplication here
+			boolean isCreated = checkIfRoleExitsElseCreateInSyncFunctions(role, app);
+			final Map<String, String> getRoleByNameParams = new HashMap<>();
+			List<EPRole> getRoleCreated = null;
+			getRoleByNameParams.put(APP_ROLE_NAME_PARAM, role);
+			if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				getRoleByNameParams.put("appId", String.valueOf(app.getId()));
+				List<EPRole> roleCreated = dataAccessService
+						.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, getRoleByNameParams, null);
+				if (!isCreated) {
+					EPRole epUpdateRole = roleCreated.get(0);
+					epUpdateRole.setAppRoleId(epUpdateRole.getId());
+					dataAccessService.saveDomainObject(epUpdateRole, null);
+					getRoleCreated = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
+							getRoleByNameParams, null);
+				} else {
+					getRoleCreated = roleCreated;
+				}
+			} else {
+				getRoleCreated = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, getRoleByNameParams,
+						null);
+			}
+			if (getRoleCreated != null && !getRoleCreated.isEmpty()) {
+				EPRole roleObject = getRoleCreated.get(0);
+				setNewRole.setId(roleObject.getId());
+				setNewRole.setName(roleObject.getName());
+				setNewRole.setActive(roleObject.getActive());
+				setNewRole.setPriority(roleObject.getPriority());
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "addRoleInDBIfDoesNotExists: Failed", e);
+		}
+		return setNewRole;
+	}
+
+	@SuppressWarnings("unchecked")
+	private boolean checkIfRoleExitsElseCreateInSyncFunctions(String role, EPApp app) {
+		boolean isCreated = false;
+		final Map<String, String> roleParams = new HashMap<>();
+		roleParams.put(APP_ROLE_NAME_PARAM, role);
+		List<EPRole> roleCreated = null;
+		if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+			roleCreated = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, roleParams, null);
+		} else {
+			roleParams.put("appId", String.valueOf(app.getId()));
+			roleCreated = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, roleParams,
+					null);
+		}
+		if (roleCreated == null || roleCreated.isEmpty()) {
+			roleParams.put("appId", String.valueOf(app.getId()));
+			EPRole epRoleNew = new EPRole();
+			epRoleNew.setActive(true);
+			epRoleNew.setName(role);
+			if (app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				epRoleNew.setAppId(null);
+			} else {
+				epRoleNew.setAppId(app.getId());
+			}
+			dataAccessService.saveDomainObject(epRoleNew, null);
+			isCreated = false;
+		} else {
+			isCreated = true;
+		}
+		return isCreated;
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Integer bulkUploadFunctions(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		List<RoleFunction> roleFuncList = dataAccessService.executeNamedQuery("getAllFunctions", null, null);
+		CentralV2RoleFunction cenRoleFunc = null;
+		Integer functionsAdded = 0;
+		try {
+			for (RoleFunction roleFunc : roleFuncList) {
+				cenRoleFunc = new CentralV2RoleFunction(roleFunc.getCode(), roleFunc.getName());
+				addRoleFunctionInExternalSystem(cenRoleFunc, app);
+				functionsAdded++;
+			}
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - bulkUploadFunctions failed", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadFunctions: failed", e.getMessage(), e);
+		}
+		return functionsAdded;
+	}
+
+	@Override
+	public Integer bulkUploadRoles(String uebkey) throws Exception {
+		List<EPApp> app = getApp(uebkey);
+		List<EPRole> roles = getAppRoles(app.get(0).getId());
+		List<CentralV2Role> cenRoleList = new ArrayList<>();
+		final Map<String, Long> params = new HashMap<>();
+		Integer rolesListAdded = 0;
+		try {
+			cenRoleList = createCentralRoleObject(app, roles, cenRoleList, params);
+			ObjectMapper mapper = new ObjectMapper();
+			mapper.configure(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES, false);
+			String roleList = mapper.writeValueAsString(cenRoleList);
+			List<Role> roleObjectList = mapper.readValue(roleList,
+					TypeFactory.defaultInstance().constructCollectionType(List.class, Role.class));
+			for (Role role : roleObjectList) {
+				addRoleInExternalSystem(role, app.get(0));
+				rolesListAdded++;
+			}
+			if (!app.get(0).getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				// Add Account Admin role in External AUTH System
+				try {
+					String addAccountAdminRole = "";
+					ExternalAccessRole extRole = new ExternalAccessRole();
+					extRole.setName(app.get(0).getNameSpace() + "." + PortalConstants.ADMIN_ROLE
+							.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+					addAccountAdminRole = mapper.writeValueAsString(extRole);
+					HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+					HttpEntity<String> entity = new HttpEntity<>(addAccountAdminRole, headers);
+					template.exchange(
+							SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
+							HttpMethod.POST, entity, String.class);
+					rolesListAdded++;
+				} catch (HttpClientErrorException e) {
+					logger.error(EELFLoggerDelegate.errorLogger,
+							"HttpClientErrorException - Failed to create Account Admin role", e);
+					EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+				} catch (Exception e) {
+					if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
+						logger.error(EELFLoggerDelegate.errorLogger,
+								"bulkUploadRoles: Account Admin Role already exits but does not break functionality",
+								e);
+					} else {
+						logger.error(EELFLoggerDelegate.errorLogger,
+								"bulkUploadRoles: Failed to create Account Admin role", e.getMessage());
+					}
+				}
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRoles: failed", e);
+			throw e;
+		}
+		return rolesListAdded;
+	}
+
+	/**
+	 * It creating new role in external auth system while doing bulk upload
+	 * 
+	 * @param role
+	 * @param app
+	 * @throws Exception
+	 */
+	private void addRoleInExternalSystem(Role role, EPApp app) throws Exception {
+		String addRoleNew = updateExistingRoleInExternalSystem(role, app);
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		try {
+			HttpEntity<String> entity = new HttpEntity<>(addRoleNew, headers);
+			template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role",
+					HttpMethod.POST, entity, String.class);
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - Failed to addRoleInExternalSystem",
+					e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleInExternalSystem: Role already exits but does not break functionality", e);
+			} else {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleInExternalSystem: Failed to addRoleInExternalSystem", e.getMessage());
+			}
+		}
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public Integer bulkUploadRolesFunctions(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		List<EPRole> roles = getAppRoles(app.getId());
+		final Map<String, Long> params = new HashMap<>();
+		Integer roleFunctions = 0;
+		try {
+			for (EPRole role : roles) {
+				params.put("roleId", role.getId());
+				List<BulkUploadRoleFunction> appRoleFunc = dataAccessService.executeNamedQuery("uploadAllRoleFunctions",
+						params, null);
+				if (!appRoleFunc.isEmpty()) {
+					for (BulkUploadRoleFunction addRoleFunc : appRoleFunc) {
+						addRoleFunctionsInExternalSystem(addRoleFunc, role, app);
+						roleFunctions++;
+					}
+				}
+			}
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to bulkUploadRolesFunctions", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRolesFunctions: failed", e);
+		}
+		return roleFunctions;
+	}
+
+	/**
+	 * Its adding a role function while doing bulk upload
+	 * 
+	 * @param addRoleFunc
+	 * @param role
+	 * @param app
+	 */
+	private void addRoleFunctionsInExternalSystem(BulkUploadRoleFunction addRoleFunc, EPRole role, EPApp app) {
+		String type = "";
+		String instance = "";
+		String action = "";
+		if (addRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
+			type = EcompPortalUtils.getFunctionType(addRoleFunc.getFunctionCd());
+			instance = EcompPortalUtils.getFunctionCode(addRoleFunc.getFunctionCd());
+			action = EcompPortalUtils.getFunctionAction(addRoleFunc.getFunctionCd());
+		} else {
+			type = addRoleFunc.getFunctionCd().contains("menu") ? "menu" : "url";
+			instance = addRoleFunc.getFunctionCd();
+			action = "*";
+		}
+		ExternalAccessRolePerms extRolePerms = null;
+		ExternalAccessPerms extPerms = null;
+		ObjectMapper mapper = new ObjectMapper();
+		try {
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, instance, action,
+					addRoleFunc.getFunctionName());
+			extRolePerms = new ExternalAccessRolePerms(extPerms, app.getNameSpace() + "." + role.getName()
+					.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+			String updateRolePerms = mapper.writeValueAsString(extRolePerms);
+			HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+			template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
+					HttpMethod.POST, entity, String.class);
+		} catch (Exception e) {
+			if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleFunctionsInExternalSystem: RoleFunction already exits but does not break functionality",
+						e);
+			} else {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addRoleFunctionsInExternalSystem: Failed to addRoleFunctionsInExternalSystem", e.getMessage());
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Integer bulkUploadPartnerFunctions(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		final Map<String, Long> params = new HashMap<>();
+		params.put("appId", app.getId());
+		List<CentralV2RoleFunction> roleFuncList = dataAccessService.executeNamedQuery("getPartnerAppFunctions", params,
+				null);
+		Integer functionsAdded = 0;
+		try {
+			for (CentralV2RoleFunction roleFunc : roleFuncList) {
+				addFunctionInExternalSystem(roleFunc, app);
+				functionsAdded++;
+			}
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "HttpClientErrorException - bulkUploadPartnerFunctions failed",
+					e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadPartnerFunctions: failed", e.getMessage(), e);
+		}
+		return functionsAdded;
+	}
+
+	private void addFunctionInExternalSystem(CentralV2RoleFunction roleFunc, EPApp app) throws Exception {
+		ObjectMapper mapper = new ObjectMapper();
+		ExternalAccessPerms extPerms = new ExternalAccessPerms();
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		String type = "";
+		String instance = "";
+		String action = "";
+		if ((roleFunc.getCode().contains(FUNCTION_PIPE))
+				|| (roleFunc.getType() != null && roleFunc.getAction() != null)) {
+			type = EcompPortalUtils.getFunctionType(roleFunc.getCode());
+			instance = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+			action = EcompPortalUtils.getFunctionAction(roleFunc.getCode());
+		} else {
+			type = roleFunc.getCode().contains("menu") ? "menu" : "url";
+			instance = roleFunc.getCode();
+			action = "*";
+		}
+		try {
+			extPerms.setAction(action);
+			extPerms.setInstance(instance);
+			extPerms.setType(app.getNameSpace() + "." + type);
+			extPerms.setDescription(roleFunc.getName());
+			String addFunction = mapper.writeValueAsString(extPerms);
+			HttpEntity<String> entity = new HttpEntity<>(addFunction, headers);
+			logger.debug(EELFLoggerDelegate.debugLogger, "addFunctionInExternalSystem: {} for POST: {}",
+					CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, addFunction);
+			ResponseEntity<String> addPermResponse = template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "perm",
+					HttpMethod.POST, entity, String.class);
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"addFunctionInExternalSystem: Finished adding permission for POST: {} and status code: {} ",
+					addPermResponse.getStatusCode().value(), addFunction);
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to add function in external central auth system", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+			throw e;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"addFunctionInExternalSystem: Failed to add fucntion in external central auth system", e);
+			throw e;
+		}
+	}
+
+	@Override
+	public void bulkUploadPartnerRoles(String uebkey, List<Role> roleList) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		for (Role role : roleList) {
+			addRoleInExternalSystem(role, app);
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Integer bulkUploadPartnerRoleFunctions(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		List<EPRole> roles = getAppRoles(app.getId());
+		final Map<String, Long> params = new HashMap<>();
+		Integer roleFunctions = 0;
+		try {
+			for (EPRole role : roles) {
+				params.put("roleId", role.getId());
+				List<BulkUploadRoleFunction> appRoleFunc = dataAccessService
+						.executeNamedQuery("uploadPartnerRoleFunctions", params, null);
+				if (!appRoleFunc.isEmpty()) {
+					for (BulkUploadRoleFunction addRoleFunc : appRoleFunc) {
+						addRoleFunctionsInExternalSystem(addRoleFunc, role, app);
+						roleFunctions++;
+					}
+				}
+			}
+			// upload global role functions to ext auth system
+			if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+				roleFunctions = bulkUploadGlobalRoleFunctions(app, roleFunctions);
+			}
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to bulkUploadRolesFunctions", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "bulkUploadRolesFunctions: failed", e);
+		}
+		return roleFunctions;
+	}
+
+	@SuppressWarnings("unchecked")
+	private Integer bulkUploadGlobalRoleFunctions(EPApp app, Integer roleFunctions) throws Exception {
+		try {
+			EPApp portalApp = epAppService.getApp(1l);
+			final Map<String, Long> params = new HashMap<>();
+			params.put("appId", app.getId());
+			List<GlobalRoleWithApplicationRoleFunction> globalRoleFuncs = dataAccessService
+					.executeNamedQuery("getBulkUploadPartnerGlobalRoleFunctions", params, null);
+			ObjectMapper mapper = new ObjectMapper();
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			for (GlobalRoleWithApplicationRoleFunction globalRoleFunc : globalRoleFuncs) {
+				ExternalAccessRolePerms extRolePerms;
+				ExternalAccessPerms extPerms;
+				String type = "";
+				String instance = "";
+				String action = "";
+				if (globalRoleFunc.getFunctionCd().contains(FUNCTION_PIPE)) {
+					type = EcompPortalUtils.getFunctionType(globalRoleFunc.getFunctionCd());
+					instance = EcompPortalUtils.getFunctionCode(globalRoleFunc.getFunctionCd());
+					action = EcompPortalUtils.getFunctionAction(globalRoleFunc.getFunctionCd());
+				} else {
+					type = globalRoleFunc.getFunctionCd().contains("menu") ? "menu" : "url";
+					instance = globalRoleFunc.getFunctionCd();
+					action = "*";
+				}
+				extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + type, instance, action);
+				extRolePerms = new ExternalAccessRolePerms(extPerms,
+						portalApp.getNameSpace() + "." + globalRoleFunc.getRoleName().replaceAll(
+								EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+				String updateRolePerms = mapper.writeValueAsString(extRolePerms);
+				HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+				updateRoleFunctionInExternalSystem(updateRolePerms, entity);
+				roleFunctions++;
+			}
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to add role function in external central auth system", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+			throw e;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"bulkUploadGlobalRoleFunctions: Failed to add role fucntion in external central auth system", e);
+			throw e;
+		}
+		return roleFunctions;
+	}
+
+	@Override
+	@Transactional
+	public void syncApplicationRolesWithEcompDB(EPApp app) {
+		try {
+			logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: Started");
+			// Sync functions and roles assigned to it which also creates new roles if does
+			// not exits in portal
+			syncRoleFunctionFromExternalAccessSystem(app);
+			logger.debug(EELFLoggerDelegate.debugLogger, "syncRoleFunctionFromExternalAccessSystem: Finished");
+			ObjectMapper mapper = new ObjectMapper();
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering to getAppRolesJSONFromExtAuthSystem");
+			// Get Permissions from External Auth System
+			JSONArray extRole = getAppRolesJSONFromExtAuthSystem(app);
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering into getExternalRoleDetailsList");
+			// refactoring done
+			List<ExternalRoleDetails> externalRoleDetailsList = getExternalRoleDetailsList(app, mapper, extRole);
+			List<EPRole> finalRoleList = new ArrayList<>();
+			for (ExternalRoleDetails externalRole : externalRoleDetailsList) {
+				EPRole ecompRole = convertExternalRoleDetailstoEpRole(externalRole);
+				finalRoleList.add(ecompRole);
+			}
+			List<EPRole> applicationRolesList;
+			applicationRolesList = getAppRoles(app.getId());
+			List<String> applicationRoleIdList = new ArrayList<>();
+			for (EPRole applicationRole : applicationRolesList) {
+				applicationRoleIdList.add(applicationRole.getName());
+			}
+			List<EPRole> roleListToBeAddInEcompDB = new ArrayList<>();
+			for (EPRole aafRole : finalRoleList) {
+				if (!applicationRoleIdList.contains(aafRole.getName())) {
+					roleListToBeAddInEcompDB.add(aafRole);
+				}
+			}
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering into inactiveRolesNotInExternalAuthSystem");
+			// Check if roles exits in external Access system and if not make inactive in DB
+			inactiveRolesNotInExternalAuthSystem(app, finalRoleList, applicationRolesList);
+			logger.debug(EELFLoggerDelegate.debugLogger, "Entering into addNewRoleInEcompDBUpdateDescInExtAuthSystem");
+			// Add new roles in DB and updates role description in External Auth System
+			addNewRoleInEcompDBUpdateDescInExtAuthSystem(app, roleListToBeAddInEcompDB);
+			logger.debug(EELFLoggerDelegate.debugLogger, "syncApplicationRolesWithEcompDB: Finished");
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"syncApplicationRolesWithEcompDB: Failed due to the External Auth System", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "syncApplicationRolesWithEcompDB: Failed ", e);
+		}
+	}
+
+	/**
+	 * 
+	 * It adds new roles in DB and updates description in External Auth System
+	 * 
+	 * @param app
+	 * @param roleListToBeAddInEcompDB
+	 */
+	@SuppressWarnings("unchecked")
+	private void addNewRoleInEcompDBUpdateDescInExtAuthSystem(EPApp app, List<EPRole> roleListToBeAddInEcompDB) {
+		EPRole roleToBeAddedInEcompDB;
+		for (int i = 0; i < roleListToBeAddInEcompDB.size(); i++) {
+			try {
+				roleToBeAddedInEcompDB = roleListToBeAddInEcompDB.get(i);
+				if (app.getId() == 1) {
+					roleToBeAddedInEcompDB.setAppRoleId(null);
+				}
+				dataAccessService.saveDomainObject(roleToBeAddedInEcompDB, null);
+				List<EPRole> getRoleCreatedInSync = null;
+				if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
+					final Map<String, String> globalRoleParams = new HashMap<>();
+					globalRoleParams.put("appId", String.valueOf(app.getId()));
+					globalRoleParams.put("appRoleName", roleToBeAddedInEcompDB.getName());
+					getRoleCreatedInSync = dataAccessService
+							.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, globalRoleParams, null);
+					EPRole epUpdateRole = getRoleCreatedInSync.get(0);
+					epUpdateRole.setAppRoleId(epUpdateRole.getId());
+					dataAccessService.saveDomainObject(epUpdateRole, null);
+				}
+				List<EPRole> roleList = new ArrayList<>();
+				final Map<String, String> params = new HashMap<>();
+				params.put(APP_ROLE_NAME_PARAM, roleToBeAddedInEcompDB.getName());
+				boolean isPortalRole = false;
+				if (app.getId() == 1) {
+					isPortalRole = true;
+					roleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, params, null);
+				} else {
+					isPortalRole = false;
+					params.put(APP_ID, app.getId().toString());
+					roleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM, params,
+							null);
+				}
+				EPRole role = roleList.get(0);
+				Role aaFrole = new Role();
+				aaFrole.setId(role.getId());
+				aaFrole.setActive(role.getActive());
+				aaFrole.setPriority(role.getPriority());
+				aaFrole.setName(role.getName());
+				updateRoleInExternalSystem(aaFrole, app, isPortalRole);
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"SyncApplicationRolesWithEcompDB: Failed to add or update role in external auth system", e);
+			}
+		}
+	}
+
+	/**
+	 * 
+	 * It de-activates application roles in DB if not present in External Auth
+	 * system
+	 * 
+	 * @param app
+	 * @param finalRoleList        contains list of current roles present in
+	 *                             External Auth System
+	 * @param applicationRolesList contains list of current roles present in DB
+	 */
+	@SuppressWarnings("unchecked")
+	private void inactiveRolesNotInExternalAuthSystem(EPApp app, List<EPRole> finalRoleList,
+			List<EPRole> applicationRolesList) {
+		final Map<String, EPRole> checkRolesInactive = new HashMap<>();
+		for (EPRole extrole : finalRoleList) {
+			checkRolesInactive.put(extrole.getName(), extrole);
+		}
+		for (EPRole role : applicationRolesList) {
+			try {
+				final Map<String, String> extRoleParams = new HashMap<>();
+				List<EPRole> roleList = null;
+				extRoleParams.put(APP_ROLE_NAME_PARAM, role.getName());
+				if (!checkRolesInactive.containsKey(role.getName())) {
+					if (app.getId() == 1) {
+						roleList = dataAccessService.executeNamedQuery(GET_PORTAL_APP_ROLES_QUERY, extRoleParams, null);
+					} else {
+						extRoleParams.put(APP_ID, app.getId().toString());
+						roleList = dataAccessService.executeNamedQuery(GET_ROLE_TO_UPDATE_IN_EXTERNAL_AUTH_SYSTEM,
+								extRoleParams, null);
+					}
+					if (!roleList.isEmpty()) {
+						EPRole updateRoleInactive = roleList.get(0);
+						updateRoleInactive.setActive(false);
+						dataAccessService.saveDomainObject(updateRoleInactive, null);
+					}
+				}
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"syncApplicationRolesWithEcompDB: Failed to de-activate role ", e);
+			}
+		}
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public List<ExternalRoleDetails> getExternalRoleDetailsList(EPApp app, ObjectMapper mapper, JSONArray extRole)
+			throws IOException {
+		List<ExternalRoleDetails> externalRoleDetailsList = new ArrayList<>();
+		ExternalAccessPerms externalAccessPerms = new ExternalAccessPerms();
+		List<String> functionCodelist = new ArrayList<>();
+		Map<String, EPRole> curRolesMap = getAppRoleNamesMap(app);
+		Map<String, EPRole> curRolesUnderscoreMap = getAppRoleNamesWithUnderscoreMap(app);
+		for (int i = 0; i < extRole.length(); i++) {
+			ExternalRoleDetails externalRoleDetail = new ExternalRoleDetails();
+			EPAppRoleFunction ePAppRoleFunction = new EPAppRoleFunction();
+			JSONObject Role = (JSONObject) extRole.get(i);
+			String name = extRole.getJSONObject(i).getString(ROLE_NAME);
+			String actualRoleName = name.substring(app.getNameSpace().length() + 1);
+			if (extRole.getJSONObject(i).has(EXTERNAL_AUTH_ROLE_DESCRIPTION)) {
+				actualRoleName = extRole.getJSONObject(i).getString(EXTERNAL_AUTH_ROLE_DESCRIPTION);
+			}
+			SortedSet<ExternalAccessPerms> externalAccessPermsOfRole = new TreeSet<>();
+			if (extRole.getJSONObject(i).has(EXTERNAL_AUTH_PERMS)) {
+				JSONArray extPerm = (JSONArray) Role.get(EXTERNAL_AUTH_PERMS);
+				for (int j = 0; j < extPerm.length(); j++) {
+					JSONObject perms = extPerm.getJSONObject(j);
+					boolean isNamespaceMatching = EcompPortalUtils.checkNameSpaceMatching(perms.getString("type"),
+							app.getNameSpace());
+					if (isNamespaceMatching) {
+						externalAccessPerms = new ExternalAccessPerms(perms.getString("type"),
+								perms.getString("instance"), perms.getString("action"));
+						ePAppRoleFunction.setCode(externalAccessPerms.getInstance());
+						functionCodelist.add(ePAppRoleFunction.getCode());
+						externalAccessPermsOfRole.add(externalAccessPerms);
+					}
+				}
+			}
+			externalRoleDetail.setActive(true);
+			externalRoleDetail.setName(actualRoleName);
+			if (app.getId() == 1) {
+				externalRoleDetail.setAppId(null);
+			} else {
+				externalRoleDetail.setAppId(app.getId());
+			}
+			EPRole currRole = null;
+			currRole = (!extRole.getJSONObject(i).has(EXTERNAL_AUTH_ROLE_DESCRIPTION))
+					? curRolesUnderscoreMap.get(actualRoleName)
+					: curRolesMap.get(actualRoleName);
+			Long roleId = null;
+			if (currRole != null)
+				roleId = currRole.getId();
+			final Map<String, EPAppRoleFunction> roleFunctionsMap = new HashMap<>();
+			final Map<String, Long> appRoleFuncsParams = new HashMap<>();
+			if (roleId != null) {
+				appRoleFuncsParams.put("appId", app.getId());
+				appRoleFuncsParams.put("roleId", roleId);
+				// get role functions from DB
+				List<EPAppRoleFunction> appRoleFunctions = dataAccessService
+						.executeNamedQuery("getAppRoleFunctionOnRoleIdandAppId", appRoleFuncsParams, null);
+				if (!appRoleFunctions.isEmpty()) {
+					for (EPAppRoleFunction roleFunc : appRoleFunctions) {
+						roleFunctionsMap.put(roleFunc.getCode(), roleFunc);
+					}
+				}
+			}
+			if (!externalAccessPermsOfRole.isEmpty()) {
+				// Adding functions to role
+				for (ExternalAccessPerms externalpermission : externalAccessPermsOfRole) {
+					EPAppRoleFunction checkRoleFunctionExits = roleFunctionsMap.get(externalpermission.getInstance());
+					if (checkRoleFunctionExits == null) {
+						String funcCode = externalpermission.getType().substring(app.getNameSpace().length() + 1)
+								+ FUNCTION_PIPE + externalpermission.getInstance() + FUNCTION_PIPE
+								+ externalpermission.getAction();
+						EPAppRoleFunction checkRoleFunctionPipeExits = roleFunctionsMap.get(funcCode);
+						if (checkRoleFunctionPipeExits == null) {
+							try {
+								final Map<String, String> appFuncsParams = new HashMap<>();
+								appFuncsParams.put("appId", String.valueOf(app.getId()));
+								appFuncsParams.put("functionCd", externalpermission.getInstance());
+								logger.debug(EELFLoggerDelegate.debugLogger,
+										"SyncApplicationRolesWithEcompDB: Adding function to the role: {}",
+										externalpermission.getInstance());
+								List<CentralV2RoleFunction> roleFunction = null;
+								roleFunction = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId",
+										appFuncsParams, null);
+								if (roleFunction.isEmpty()) {
+									appFuncsParams.put("functionCd", funcCode);
+									roleFunction = dataAccessService.executeNamedQuery("getAppFunctionOnCodeAndAppId",
+											appFuncsParams, null);
+								}
+								if (!roleFunction.isEmpty()) {
+									EPAppRoleFunction apRoleFunction = new EPAppRoleFunction();
+									apRoleFunction.setAppId(app.getId());
+									apRoleFunction.setRoleId(roleId);
+									apRoleFunction.setCode(roleFunction.get(0).getCode());
+									dataAccessService.saveDomainObject(apRoleFunction, null);
+								}
+							} catch (Exception e) {
+								logger.error(EELFLoggerDelegate.errorLogger,
+										"SyncApplicationRolesWithEcompDB: Failed to add role function", e);
+							}
+						}
+					}
+				}
+			}
+			externalRoleDetailsList.add(externalRoleDetail);
+		}
+		return externalRoleDetailsList;
+	}
+
+	@Override
+	public JSONArray getAppRolesJSONFromExtAuthSystem(EPApp app) throws Exception {
+		ResponseEntity<String> response = null;
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "syncApplicationRolesWithEcompDB: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+		response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+				+ "roles/ns/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
+		String res = response.getBody();
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncApplicationRolesWithEcompDB: Finished GET roles from External Auth system and the result is :",
+				res);
+		JSONObject jsonObj = new JSONObject(res);
+		JSONArray extRole = jsonObj.getJSONArray("role");
+		for (int i = 0; i < extRole.length(); i++) {
+			if (extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + ADMIN)
+					|| extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + OWNER)
+					|| (extRole.getJSONObject(i).getString(ROLE_NAME).equals(app.getNameSpace() + ACCOUNT_ADMINISTRATOR)
+							&& !app.getId().equals(PortalConstants.PORTAL_APP_ID))) {
+				extRole.remove(i);
+				i--;
+			}
+		}
+		return extRole;
+	}
+
+	@Override
+	public JSONArray getAllUsersByRole(String roleName) throws Exception {
+		ResponseEntity<String> response = null;
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "getAllUsersByRole: {} ",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE);
+		response = template.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+				+ "userRoles/role/" + roleName, HttpMethod.GET, entity, String.class);
+		String res = response.getBody();
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"syncApplicationRolesWithEcompDB: Finished GET roles from External Auth system and the result is :",
+				res);
+		if (res == null || res.trim().isEmpty())
+			return null;
+		JSONObject jsonObj = new JSONObject(res);
+		JSONArray extRole = jsonObj.getJSONArray("userRole");
+		return extRole;
+	}
+
+	/**
+	 * 
+	 * It converts from ExternalRoleDetails.class object to EPRole.class object
+	 * 
+	 * @param externalRoleDetails
+	 * @return EPRole object
+	 */
+	private EPRole convertExternalRoleDetailstoEpRole(ExternalRoleDetails externalRoleDetails) {
+		EPRole role = new EPRole();
+		role.setActive(true);
+		role.setAppId(externalRoleDetails.getAppId());
+		role.setAppRoleId(externalRoleDetails.getAppRoleId());
+		role.setName(externalRoleDetails.getName());
+		role.setPriority(externalRoleDetails.getPriority());
+		return role;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Integer bulkUploadUserRoles(String uebkey) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		final Map<String, String> params = new HashMap<>();
+		params.put("uebKey", app.getUebKey());
+		List<BulkUploadUserRoles> userRolesList = null;
+		Integer userRolesAdded = 0;
+		if (app.getCentralAuth()) {
+			userRolesList = dataAccessService.executeNamedQuery("getBulkUserRoles", params, null);
+			for (BulkUploadUserRoles userRolesUpload : userRolesList) {
+				if (!userRolesUpload.getOrgUserId().equals("su1234")) {
+					addUserRoleInExternalSystem(userRolesUpload);
+					userRolesAdded++;
+				}
+			}
+		}
+		return userRolesAdded;
+	}
+
+	/**
+	 * Its adding a user role in external auth system while doing bulk upload
+	 * 
+	 * @param userRolesUpload
+	 */
+	private void addUserRoleInExternalSystem(BulkUploadUserRoles userRolesUpload) {
+		try {
+			String name = "";
+			ObjectMapper mapper = new ObjectMapper();
+			if (EPCommonSystemProperties
+					.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) {
+				name = userRolesUpload.getOrgUserId()
+						+ SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN);
+			}
+			ExternalAccessUser extUser = new ExternalAccessUser(name,
+					userRolesUpload.getAppNameSpace() + "." + userRolesUpload.getRoleName()
+							.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+			String userRole = mapper.writeValueAsString(extUser);
+			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+			HttpEntity<String> entity = new HttpEntity<>(userRole, headers);
+			template.exchange(
+					SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "userRole",
+					HttpMethod.POST, entity, String.class);
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to addUserRoleInExternalSystem", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+		} catch (Exception e) {
+			if (e.getMessage().equalsIgnoreCase("409 Conflict")) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addUserRoleInExternalSystem: UserRole already exits but does not break functionality");
+			} else {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addUserRoleInExternalSystem: Failed to addUserRoleInExternalSystem", e);
+			}
+		}
+	}
+
+	@Override
+	public void deleteRoleDependencyRecords(Session localSession, Long roleId, Long appId, boolean isPortalRequest)
+			throws Exception {
+		try {
+			String sql = "";
+			Query query = null;
+			// It should delete only when it portal's roleId
+			if (appId.equals(PortalConstants.PORTAL_APP_ID)) {
+				// Delete from fn_role_function
+				sql = "DELETE FROM fn_role_function WHERE role_id=" + roleId;
+				logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+				query = localSession.createSQLQuery(sql);
+				query.executeUpdate();
+				// Delete from fn_role_composite
+				sql = "DELETE FROM fn_role_composite WHERE parent_role_id=" + roleId + " OR child_role_id=" + roleId;
+				logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+				query = localSession.createSQLQuery(sql);
+				query.executeUpdate();
+			}
+			// Delete from ep_app_role_function
+			sql = "DELETE FROM ep_app_role_function WHERE role_id=" + roleId;
+			logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+			query = localSession.createSQLQuery(sql);
+			query.executeUpdate();
+			// Delete from ep_role_notification
+			sql = "DELETE FROM ep_role_notification WHERE role_id=" + roleId;
+			logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+			query = localSession.createSQLQuery(sql);
+			query.executeUpdate();
+			// Delete from fn_user_pseudo_role
+			sql = "DELETE FROM fn_user_pseudo_role WHERE pseudo_role_id=" + roleId;
+			logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+			query = localSession.createSQLQuery(sql);
+			query.executeUpdate();
+			// Delete form EP_WIDGET_CATALOG_ROLE
+			sql = "DELETE FROM EP_WIDGET_CATALOG_ROLE WHERE role_id=" + roleId;
+			logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+			query = localSession.createSQLQuery(sql);
+			query.executeUpdate();
+			// Delete form EP_WIDGET_CATALOG_ROLE
+			sql = "DELETE FROM ep_user_roles_request_det WHERE requested_role_id=" + roleId;
+			logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+			query = localSession.createSQLQuery(sql);
+			query.executeUpdate();
+			if (!isPortalRequest) {
+				// Delete form fn_menu_functional_roles
+				sql = "DELETE FROM fn_menu_functional_roles WHERE role_id=" + roleId;
+				logger.debug(EELFLoggerDelegate.debugLogger, "Executing query: " + sql);
+				query = localSession.createSQLQuery(sql);
+				query.executeUpdate();
+			}
+		} catch (Exception e) {
+			logger.debug(EELFLoggerDelegate.debugLogger, "deleteRoleDependeciesRecord: failed ", e);
+			throw new DeleteDomainObjectFailedException("delete Failed" + e.getMessage());
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<String> getMenuFunctionsList(String uebkey) throws Exception {
+		List<String> appMenuFunctionsList = null;
+		List<String> appMenuFunctionsFinalList = new ArrayList<>();
+		try {
+			EPApp app = getApp(uebkey).get(0);
+			final Map<String, Long> appParams = new HashMap<>();
+			appParams.put(APP_ID, app.getId());
+			appMenuFunctionsList = dataAccessService.executeNamedQuery("getMenuFunctions", appParams, null);
+			for (String appMenuFunction : appMenuFunctionsList) {
+				if (appMenuFunction.contains(FUNCTION_PIPE)) {
+					appMenuFunctionsFinalList.add(EcompPortalUtils.getFunctionCode(appMenuFunction));
+				} else {
+					appMenuFunctionsFinalList.add(appMenuFunction);
+				}
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getMenuFunctionsList: Failed", e);
+			return appMenuFunctionsFinalList;
+		}
+		return appMenuFunctionsFinalList;
+	}
+
+	@SuppressWarnings({ "unchecked" })
+	@Override
+	public List<EcompUser> getAllAppUsers(String uebkey) throws Exception {
+		List<String> usersList = new ArrayList<>();
+		List<EcompUser> usersfinalList = new ArrayList<>();
+		try {
+			EPApp app = getApp(uebkey).get(0);
+			final Map<String, Long> appParams = new HashMap<>();
+			appParams.put("appId", app.getId());
+			List<EcompUserRoles> userList = (List<EcompUserRoles>) dataAccessService
+					.executeNamedQuery("ApplicationUserRoles", appParams, null);
+			for (EcompUserRoles ecompUserRole : userList) {
+				boolean found = false;
+				Set<EcompRole> roles = null;
+				for (EcompUser user : usersfinalList) {
+					if (user.getOrgUserId().equals(ecompUserRole.getOrgUserId())) {
+						EcompRole ecompRole = new EcompRole();
+						ecompRole.setId(ecompUserRole.getRoleId());
+						ecompRole.setName(ecompUserRole.getRoleName());
+						roles = user.getRoles();
+						EcompRole role = roles.stream().filter(x -> x.getName().equals(ecompUserRole.getRoleName()))
+								.findAny().orElse(null);
+						SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
+						if (role != null) {
+							roleFunctionSet = (SortedSet<EcompRoleFunction>) role.getRoleFunctions();
+						}
+						String functionCode = EcompPortalUtils.getFunctionCode(ecompUserRole.getFunctionCode());
+						functionCode = EPUserUtils.decodeFunctionCode(functionCode);
+						EcompRoleFunction epRoleFunction = new EcompRoleFunction();
+						epRoleFunction.setName(ecompUserRole.getFunctionName());
+						epRoleFunction.setCode(EPUserUtils.decodeFunctionCode(functionCode));
+						epRoleFunction.setType(getFunctionCodeType(ecompUserRole.getFunctionCode()));
+						epRoleFunction.setAction(getFunctionCodeAction(ecompUserRole.getFunctionCode()));
+						roleFunctionSet.add(epRoleFunction);
+						ecompRole.setRoleFunctions(roleFunctionSet);
+						roles.add(ecompRole);
+						user.setRoles(roles);
+						found = true;
+						break;
+					}
+				}
+				if (!found) {
+					EcompUser epUser = new EcompUser();
+					epUser.setOrgId(ecompUserRole.getOrgId());
+					epUser.setManagerId(ecompUserRole.getManagerId());
+					epUser.setFirstName(ecompUserRole.getFirstName());
+					epUser.setLastName(ecompUserRole.getLastName());
+					epUser.setPhone(ecompUserRole.getPhone());
+					epUser.setEmail(ecompUserRole.getEmail());
+					epUser.setOrgUserId(ecompUserRole.getOrgUserId());
+					epUser.setOrgCode(ecompUserRole.getOrgCode());
+					epUser.setOrgManagerUserId(ecompUserRole.getOrgManagerUserId());
+					epUser.setJobTitle(ecompUserRole.getJobTitle());
+					epUser.setLoginId(ecompUserRole.getLoginId());
+					epUser.setActive(true);
+					roles = new HashSet<>();
+					EcompRole ecompRole = new EcompRole();
+					ecompRole.setId(ecompUserRole.getRoleId());
+					ecompRole.setName(ecompUserRole.getRoleName());
+					SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
+					String functionCode = EcompPortalUtils.getFunctionCode(ecompUserRole.getFunctionCode());
+					functionCode = EPUserUtils.decodeFunctionCode(functionCode);
+					EcompRoleFunction epRoleFunction = new EcompRoleFunction();
+					epRoleFunction.setName(ecompUserRole.getFunctionName());
+					epRoleFunction.setCode(EPUserUtils.decodeFunctionCode(functionCode));
+					epRoleFunction.setType(getFunctionCodeType(ecompUserRole.getFunctionCode()));
+					epRoleFunction.setAction(getFunctionCodeAction(ecompUserRole.getFunctionCode()));
+					roleFunctionSet.add(epRoleFunction);
+					ecompRole.setRoleFunctions(roleFunctionSet);
+					roles.add(ecompRole);
+					epUser.setRoles(roles);
+					usersfinalList.add(epUser);
+				}
+			}
+			ObjectMapper mapper = new ObjectMapper();
+			for (EcompUser u1 : usersfinalList) {
+				String str = mapper.writeValueAsString(u1);
+				usersList.add(str);
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getAllUsers failed", e);
+			throw e;
+		}
+		return usersfinalList;
+	}
+
+	@Override
+	public Role ConvertCentralRoleToRole(String result) {
+		ObjectMapper mapper = new ObjectMapper();
+		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+		Role newRole = new Role();
+		try {
+			newRole = mapper.readValue(result, Role.class);
+		} catch (IOException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "Failed to convert the result to Role Object", e);
+		}
+		if (newRole.getRoleFunctions() != null) {
+			@SuppressWarnings("unchecked")
+			Set<RoleFunction> roleFunctionList = newRole.getRoleFunctions();
+			Set<RoleFunction> roleFunctionListNew = new HashSet<>();
+			Iterator<RoleFunction> itetaror = roleFunctionList.iterator();
+			while (itetaror.hasNext()) {
+				Object nextValue = itetaror.next();
+				RoleFunction roleFun = mapper.convertValue(nextValue, RoleFunction.class);
+				roleFunctionListNew.add(roleFun);
+			}
+			newRole.setRoleFunctions(roleFunctionListNew);
+		}
+		return newRole;
+	}
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public List<CentralizedApp> getCentralizedAppsOfUser(String userId) {
+		Map<String, String> params = new HashMap<>();
+		params.put("userId", userId);
+		List<CentralizedApp> centralizedAppsList = new ArrayList<>();
+		try {
+			centralizedAppsList = dataAccessService.executeNamedQuery("getCentralizedAppsOfUser", params, null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getCentralizedAppsOfUser failed", e);
+		}
+		return centralizedAppsList;
+	}
+
+	@SuppressWarnings("unchecked")
+	public List<CentralV2Role> getGlobalRolesOfApplication(Long appId) {
+		Map<String, Long> params = new HashMap<>();
+		params.put("appId", appId);
+		List<GlobalRoleWithApplicationRoleFunction> globalRoles = new ArrayList<>();
+		try {
+			globalRoles = dataAccessService.executeNamedQuery("getGlobalRoleWithApplicationRoleFunctions", params,
+					null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getCentralizedAppsOfUser failed", e);
+		}
+		List<CentralV2Role> rolesfinalList = new ArrayList<>();
+		if (globalRoles.size() > 0)
+			rolesfinalList = finalListOfCentralRoles(globalRoles);
+		return rolesfinalList;
+	}
+
+	@SuppressWarnings("unchecked")
+	private CentralV2Role getGlobalRoleForRequestedApp(long requestedAppId, long roleId) {
+		CentralV2Role finalGlobalrole = null;
+		List<GlobalRoleWithApplicationRoleFunction> roleWithApplicationRoleFucntions = new ArrayList<>();
+		Map<String, Long> params = new HashMap<>();
+		params.put("roleId", roleId);
+		params.put("requestedAppId", requestedAppId);
+		try {
+			roleWithApplicationRoleFucntions = dataAccessService.executeNamedQuery("getGlobalRoleForRequestedApp",
+					params, null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getGlobalRoleForRequestedApp failed", e);
+		}
+		if (roleWithApplicationRoleFucntions.size() > 0) {
+			List<CentralV2Role> rolesfinalList = finalListOfCentralRoles(roleWithApplicationRoleFucntions);
+			finalGlobalrole = rolesfinalList.get(0);
+		} else {
+			List<EPRole> roleList = getPortalAppRoleInfo(roleId);
+			finalGlobalrole = convertRoleToCentralV2Role(roleList.get(0));
+		}
+		return finalGlobalrole;
+	}
+
+	private List<CentralV2Role> finalListOfCentralRoles(List<GlobalRoleWithApplicationRoleFunction> globalRoles) {
+		List<CentralV2Role> rolesfinalList = new ArrayList<>();
+		for (GlobalRoleWithApplicationRoleFunction role : globalRoles) {
+			boolean found = false;
+			for (CentralV2Role cenRole : rolesfinalList) {
+				if (role.getRoleId().equals(cenRole.getId())) {
+					SortedSet<CentralV2RoleFunction> roleFunctions = cenRole.getRoleFunctions();
+					CentralV2RoleFunction cenRoleFun = createCentralRoleFunctionForGlobalRole(role);
+					roleFunctions.add(cenRoleFun);
+					cenRole.setRoleFunctions(roleFunctions);
+					found = true;
+					break;
+				}
+			}
+			if (!found) {
+				CentralV2Role cenrole = new CentralV2Role();
+				cenrole.setName(role.getRoleName());
+				cenrole.setId(role.getRoleId());
+				cenrole.setActive(role.isActive());
+				cenrole.setPriority(role.getPriority());
+				SortedSet<CentralV2RoleFunction> roleFunctions = new TreeSet<>();
+				CentralV2RoleFunction cenRoleFun = createCentralRoleFunctionForGlobalRole(role);
+				roleFunctions.add(cenRoleFun);
+				cenrole.setRoleFunctions(roleFunctions);
+				rolesfinalList.add(cenrole);
+			}
+		}
+		return rolesfinalList;
+	}
+
+	private CentralV2RoleFunction createCentralRoleFunctionForGlobalRole(GlobalRoleWithApplicationRoleFunction role) {
+		String instance;
+		String type;
+		String action;
+		CentralV2RoleFunction cenRoleFun;
+		if (role.getFunctionCd().contains(FUNCTION_PIPE)) {
+			instance = EcompPortalUtils.getFunctionCode(role.getFunctionCd());
+			type = EcompPortalUtils.getFunctionType(role.getFunctionCd());
+			action = EcompPortalUtils.getFunctionAction(role.getFunctionCd());
+			cenRoleFun = new CentralV2RoleFunction(null, instance, role.getFunctionName(), null, type, action, null);
+		} else {
+			type = getFunctionCodeType(role.getFunctionCd());
+			action = getFunctionCodeAction(role.getFunctionCd());
+			cenRoleFun = new CentralV2RoleFunction(null, role.getFunctionCd(), role.getFunctionName(), null, type,
+					action, null);
+		}
+		return cenRoleFun;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public List<EPRole> getGlobalRolesOfPortal() {
+		List<EPRole> globalRoles = new ArrayList<>();
+		try {
+			globalRoles = dataAccessService.executeNamedQuery("getGlobalRolesOfPortal", null, null);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getGlobalRolesOfPortal failed", e);
+		}
+		return globalRoles;
+	}
+
+	private CentralV2Role convertRoleToCentralV2Role(EPRole role) {
+		return new CentralV2Role(role.getId(), role.getCreated(), role.getModified(), role.getCreatedId(),
+				role.getModifiedId(), role.getRowNum(), role.getName(), role.getActive(), role.getPriority(),
+				new TreeSet<>(), new TreeSet<>(), new TreeSet<>());
+	}
+
+	@Override
+	public List<CentralRoleFunction> convertCentralRoleFunctionToRoleFunctionObject(
+			List<CentralV2RoleFunction> answer) {
+		List<CentralRoleFunction> addRoleFuncList = new ArrayList<>();
+		for (CentralV2RoleFunction cenRoleFunc : answer) {
+			CentralRoleFunction setRoleFunc = new CentralRoleFunction();
+			setRoleFunc.setCode(cenRoleFunc.getCode());
+			setRoleFunc.setName(cenRoleFunc.getName());
+			addRoleFuncList.add(setRoleFunc);
+		}
+		return addRoleFuncList;
+	}
+
+	@Override
+	public CentralUser getUserRoles(String loginId, String uebkey) throws Exception {
+		CentralUser sendUserRoles = null;
+		try {
+			CentralV2User cenV2User = getV2UserAppRoles(loginId, uebkey);
+			sendUserRoles = convertV2UserRolesToOlderVersion(cenV2User);
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "getUserRoles: failed", e);
+			throw e;
+		}
+		return sendUserRoles;
+	}
+
+	/**
+	 * 
+	 * It returns V2 CentralUser object if user has any roles and permissions
+	 * 
+	 * @param loginId
+	 * @param uebkey
+	 * @return CentralUser object
+	 * @throws Exception
+	 */
+	private CentralV2User getV2UserAppRoles(String loginId, String uebkey) throws Exception {
+		EPApp app;
+		List<EPUser> epUserList;
+		List<EPApp> appList = getApp(uebkey);
+		app = appList.get(0);
+		epUserList = getUser(loginId);
+		EPUser user = epUserList.get(0);
+		Set<EPUserApp> userAppSet = user.getEPUserApps();
+		return createEPUser(user, userAppSet, app);
+	}
+
+	private List<EcompRole> getUserAppRoles(EPApp app, EPUser user) {
+		final Map<String, Long> userParams = new HashMap<>();
+		userParams.put("appId", app.getId());
+		userParams.put("userId", user.getId());
+		@SuppressWarnings("unchecked")
+		List<EPUserAppCurrentRoles> userAppsRolesList = dataAccessService.executeNamedQuery("getUserAppCurrentRoles",
+				userParams, null);
+		List<EcompRole> setUserRoles = new ArrayList<>();
+		for (EPUserAppCurrentRoles role : userAppsRolesList) {
+			logger.debug(EELFLoggerDelegate.debugLogger, "In getUserAppRoles()- get userRolename = {}",
+					role.getRoleName());
+			EcompRole ecompRole = new EcompRole();
+			ecompRole.setId(role.getRoleId());
+			ecompRole.setName(role.getRoleName());
+			setUserRoles.add(ecompRole);
+		}
+		logger.debug(EELFLoggerDelegate.debugLogger, "In getUserAppRoles()- get userrole list size = {}",
+				setUserRoles.size());
+		return setUserRoles;
+	}
+
+	@Override
+	public List<EcompRole> missingUserApplicationRoles(String uebkey, String loginId, Set<EcompRole> CurrentUserRoles)
+			throws Exception {
+		List<EPApp> appList = getApp(uebkey);
+		EPApp app = appList.get(0);
+		List<EPUser> epUserList;
+		epUserList = getUser(loginId);
+		List<EcompRole> missingUserAppRoles = new ArrayList<>();
+		List<String> roleNamesList = CurrentUserRoles.stream().map(EcompRole::getName).collect(Collectors.toList());
+		logger.debug(EELFLoggerDelegate.debugLogger, "Roles of User from hibernate :" + roleNamesList);
+		List<EcompRole> userApplicationsRolesfromDB = getUserAppRoles(app, epUserList.get(0));
+		if (userApplicationsRolesfromDB.size() > 0) {
+			missingUserAppRoles = userApplicationsRolesfromDB.stream().filter(x -> !roleNamesList.contains(x.getName()))
+					.collect(Collectors.toList());
+		}
+		List<String> MissingroleNamesList = missingUserAppRoles.stream().map(EcompRole::getName)
+				.collect(Collectors.toList());
+		logger.debug(EELFLoggerDelegate.debugLogger, "MissingUserAppRoles():" + MissingroleNamesList);
+
+		List<EcompRole> finalMissingRoleList = new ArrayList<>();
+		if (missingUserAppRoles.size() > 0) {
+			final Map<String, Long> params = new HashMap<>();
+			for (EcompRole role : missingUserAppRoles) {
+				params.put("roleId", role.getId());
+				params.put(APP_ID, app.getId());
+
+				EcompRole epRole = new EcompRole();
+				epRole.setId(role.getId());
+				epRole.setName(role.getName());
+				@SuppressWarnings("unchecked")
+				List<CentralV2RoleFunction> appRoleFunctionList = dataAccessService
+						.executeNamedQuery("getAppRoleFunctionList", params, null);
+				SortedSet<EcompRoleFunction> roleFunctionSet = new TreeSet<>();
+				for (CentralV2RoleFunction roleFunc : appRoleFunctionList) {
+					String functionCode = EcompPortalUtils.getFunctionCode(roleFunc.getCode());
+					String type = getFunctionCodeType(roleFunc.getCode());
+					String action = getFunctionCodeAction(roleFunc.getCode());
+					EcompRoleFunction fun = new EcompRoleFunction();
+					fun.setAction(action);
+					fun.setCode(functionCode);
+					fun.setType(type);
+					fun.setName(roleFunc.getName());
+					roleFunctionSet.add(fun);
+
+				}
+				epRole.setRoleFunctions(roleFunctionSet);
+				finalMissingRoleList.add(epRole);
+			}
+		}
+
+		return finalMissingRoleList;
+	}
+
+	/**
+	 * It converts V2 CentralUser object to old version CentralUser object
+	 * 
+	 * @param cenV2User
+	 * @return EPUser object
+	 */
+	private CentralUser convertV2UserRolesToOlderVersion(CentralV2User cenV2User) {
+		Set<CentralV2UserApp> userV2Apps = cenV2User.getUserApps();
+		Set<CentralUserApp> userApps = new TreeSet<>();
+		for (CentralV2UserApp userApp : userV2Apps) {
+			CentralApp app = userApp.getApp();
+			CentralUserApp cua = new CentralUserApp();
+			cua.setUserId(null);
+			cua.setApp(app);
+			SortedSet<CentralRoleFunction> cenRoleFunction = new TreeSet<>();
+			for (CentralV2RoleFunction cenV2RoleFunc : userApp.getRole().getRoleFunctions()) {
+				CentralRoleFunction cenRoleFunc = new CentralRoleFunction(cenV2RoleFunc.getCode(),
+						cenV2RoleFunc.getName());
+				cenRoleFunction.add(cenRoleFunc);
+			}
+			CentralRole role = new CentralRole(userApp.getRole().getId(), userApp.getRole().getName(),
+					userApp.getRole().getActive(), userApp.getRole().getPriority(), cenRoleFunction);
+			cua.setRole(role);
+			userApps.add(cua);
+		}
+		return new CentralUser(cenV2User.getId(), cenV2User.getCreated(), cenV2User.getModified(),
+				cenV2User.getCreatedId(), cenV2User.getModifiedId(), cenV2User.getRowNum(), cenV2User.getOrgId(),
+				cenV2User.getManagerId(), cenV2User.getFirstName(), cenV2User.getMiddleInitial(),
+				cenV2User.getLastName(), cenV2User.getPhone(), cenV2User.getFax(), cenV2User.getCellular(),
+				cenV2User.getEmail(), cenV2User.getAddressId(), cenV2User.getAlertMethodCd(), cenV2User.getHrid(),
+				cenV2User.getOrgUserId(), cenV2User.getOrgCode(), cenV2User.getAddress1(), cenV2User.getAddress2(),
+				cenV2User.getCity(), cenV2User.getState(), cenV2User.getZipCode(), cenV2User.getCountry(),
+				cenV2User.getOrgManagerUserId(), cenV2User.getLocationClli(), cenV2User.getBusinessCountryCode(),
+				cenV2User.getBusinessCountryName(), cenV2User.getBusinessUnit(), cenV2User.getBusinessUnitName(),
+				cenV2User.getDepartment(), cenV2User.getDepartmentName(), cenV2User.getCompanyCode(),
+				cenV2User.getCompany(), cenV2User.getZipCodeSuffix(), cenV2User.getJobTitle(),
+				cenV2User.getCommandChain(), cenV2User.getSiloStatus(), cenV2User.getCostCenter(),
+				cenV2User.getFinancialLocCode(), cenV2User.getLoginId(), cenV2User.getLoginPwd(),
+				cenV2User.getLastLoginDate(), cenV2User.isActive(), cenV2User.isInternal(),
+				cenV2User.getSelectedProfileId(), cenV2User.getTimeZoneId(), cenV2User.isOnline(),
+				cenV2User.getChatId(), userApps);
+	}
+
+	@Override
+	public List<CentralRole> convertV2CentralRoleListToOldVerisonCentralRoleList(List<CentralV2Role> v2CenRoleList) {
+		List<CentralRole> cenRoleList = new ArrayList<>();
+		for (CentralV2Role v2CenRole : v2CenRoleList) {
+			SortedSet<CentralRoleFunction> cenRoleFuncList = new TreeSet<>();
+			for (CentralV2RoleFunction v2CenRoleFunc : v2CenRole.getRoleFunctions()) {
+				CentralRoleFunction roleFunc = new CentralRoleFunction(v2CenRoleFunc.getCode(),
+						v2CenRoleFunc.getName());
+				cenRoleFuncList.add(roleFunc);
+			}
+			CentralRole role = new CentralRole(v2CenRole.getId(), v2CenRole.getName(), v2CenRole.getActive(),
+					v2CenRole.getPriority(), cenRoleFuncList);
+			cenRoleList.add(role);
+		}
+		return cenRoleList;
+	}
+
+	@Override
+	public ResponseEntity<String> getNameSpaceIfExists(EPApp app) throws Exception {
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> entity = new HttpEntity<>(headers);
+		logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists: Connecting to External Auth system");
+		ResponseEntity<String> response = null;
+		try {
+			response = template
+					.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+							+ "nss/" + app.getNameSpace(), HttpMethod.GET, entity, String.class);
+			logger.debug(EELFLoggerDelegate.debugLogger, "checkIfNameSpaceExists: Finished ",
+					response.getStatusCode().value());
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "checkIfNameSpaceExists failed", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+			if (e.getStatusCode() == HttpStatus.NOT_FOUND)
+				throw new InvalidApplicationException("Invalid NameSpace");
+			else
+				throw e;
+		}
+		return response;
+	}
+
+	@Override
+	public CentralRole convertV2CentralRoleToOldVerisonCentralRole(CentralV2Role v2CenRole) {
+		SortedSet<CentralRoleFunction> cenRoleFuncList = new TreeSet<>();
+		for (CentralV2RoleFunction v2CenRoleFunc : v2CenRole.getRoleFunctions()) {
+			CentralRoleFunction roleFunc = new CentralRoleFunction(v2CenRoleFunc.getCode(), v2CenRoleFunc.getName());
+			cenRoleFuncList.add(roleFunc);
+		}
+		return new CentralRole(v2CenRole.getId(), v2CenRole.getName(), v2CenRole.getActive(), v2CenRole.getPriority(),
+				cenRoleFuncList);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Integer bulkUploadUsersSingleRole(String uebkey, Long roleId, String modifiedRoleName) throws Exception {
+		EPApp app = getApp(uebkey).get(0);
+		final Map<String, String> params = new HashMap<>();
+		params.put("uebKey", app.getUebKey());
+		params.put("roleId", String.valueOf(roleId));
+		List<BulkUploadUserRoles> userRolesList = null;
+		Integer userRolesAdded = 0;
+		if (app.getCentralAuth()) {
+			userRolesList = dataAccessService.executeNamedQuery("getBulkUsersForSingleRole", params, null);
+			for (BulkUploadUserRoles userRolesUpload : userRolesList) {
+				userRolesUpload.setRoleName(modifiedRoleName);
+				if (!userRolesUpload.getOrgUserId().equals("su1234")) {
+					addUserRoleInExternalSystem(userRolesUpload);
+					userRolesAdded++;
+				}
+			}
+		}
+		return userRolesAdded;
+	}
+
+	@Override
+	public void bulkUploadRoleFunc(UploadRoleFunctionExtSystem data, EPApp app) throws Exception {
+		ObjectMapper mapper = new ObjectMapper();
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		try {
+			ExternalAccessRolePerms extRolePerms;
+			ExternalAccessPerms extPerms;
+			extPerms = new ExternalAccessPerms(app.getNameSpace() + "." + data.getType(),
+					EcompPortalUtils.encodeFunctionCode(data.getInstance()), data.getAction());
+			String appNameSpace = "";
+			if (data.getIsGlobalRolePartnerFunc()) {
+				appNameSpace = epAppService.getApp(1l).getNameSpace();
+			} else {
+				appNameSpace = app.getNameSpace();
+			}
+			extRolePerms = new ExternalAccessRolePerms(extPerms, appNameSpace + "." + data.getRoleName()
+					.replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
+			String updateRolePerms = mapper.writeValueAsString(extRolePerms);
+			HttpEntity<String> entity = new HttpEntity<>(updateRolePerms, headers);
+			updateRoleFunctionInExternalSystem(updateRolePerms, entity);
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"HttpClientErrorException - Failed to add role function in external central auth system", e);
+			EPLogUtil.logExternalAuthAccessAlarm(logger, e.getStatusCode());
+			throw e;
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"addFunctionInExternalSystem: Failed to add role fucntion in external central auth system", e);
+			throw e;
+		}
+	}
+
+	private void updateRoleFunctionInExternalSystem(String updateRolePerms, HttpEntity<String> entity) {
+		logger.debug(EELFLoggerDelegate.debugLogger, "bulkUploadRoleFunc: {} for POST: {}",
+				CONNECTING_TO_EXTERNAL_AUTH_SYSTEM_LOG_MESSAGE, updateRolePerms);
+		ResponseEntity<String> addPermResponse = template.exchange(
+				SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL) + "role/perm",
+				HttpMethod.POST, entity, String.class);
+		logger.debug(EELFLoggerDelegate.debugLogger,
+				"bulkUploadRoleFunc: Finished adding permission for POST: {} and status code: {} ",
+				addPermResponse.getStatusCode().value(), updateRolePerms);
+	}
+
+	@Override
+	public void syncApplicationUserRolesFromExtAuthSystem(String loginId) throws Exception {
+		String name = "";
+		if (EPCommonSystemProperties.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) {
+			name = loginId + SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN);
+		}
+		HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
+		HttpEntity<String> getUserRolesEntity = new HttpEntity<>(headers);
+		ResponseEntity<String> getResponse = getUserRolesFromExtAuthSystem(name, getUserRolesEntity);
+		List<ExternalAccessUserRoleDetail> userRoleDetailList = new ArrayList<>();
+		String res = getResponse.getBody();
+		JSONObject jsonObj = null;
+		JSONArray extRoles = null;
+		if (!res.equals("{}")) {
+			jsonObj = new JSONObject(res);
+			extRoles = jsonObj.getJSONArray("role");
+		}
+		updateUserRolesInLocal(userRoleDetailList, extRoles, loginId);
+	}
+
+	@SuppressWarnings("unchecked")
+	private void updateUserRolesInLocal(List<ExternalAccessUserRoleDetail> userRoleDetailList, JSONArray extRoles,
+			String loginId) throws InvalidUserException {
+		HashMap<String, String> userParams = new HashMap<>();
+		userParams.put("orgUserId", loginId);
+		// Get all centralized applications existing user roles from local
+		List<CentralizedAppRoles> currentUserAppRoles = dataAccessService
+				.executeNamedQuery("getUserCentralizedAppRoles", userParams, null);
+		EPUser user = getUser(loginId).get(0);
+		// Get all centralized applications roles from local
+		HashMap<String, CentralizedAppRoles> cenAppRolesMap = getCentralizedAppRoleList();
+		HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap = getCurrentUserCentralizedAppRoles(
+				currentUserAppRoles);
+		// Get all centralized applications + admin role from local
+		HashMap<String, EPApp> centralisedAppsMap = getCentralizedAdminAppsInfo();
+		if (extRoles != null) {
+			ExternalAccessUserRoleDetail userRoleDetail = null;
+			for (int i = 0; i < extRoles.length(); i++) {
+				if (!extRoles.getJSONObject(i).getString("name").endsWith(ADMIN)
+						&& !extRoles.getJSONObject(i).getString("name").endsWith(OWNER)) {
+					userRoleDetail = new ExternalAccessUserRoleDetail(extRoles.getJSONObject(i).getString("name"),
+							null);
+					userRoleDetailList.add(userRoleDetail);
+				}
+			}
+			addUserRolesInLocal(userRoleDetailList, user, cenAppRolesMap, currentCentralizedUserAppRolesMap,
+					centralisedAppsMap);
+		}
+	}
+
+	private void addUserRolesInLocal(List<ExternalAccessUserRoleDetail> userRoleDetailList, EPUser user,
+			HashMap<String, CentralizedAppRoles> cenAppRolesMap,
+			HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap,
+			HashMap<String, EPApp> centralisedAppsMap) {
+		for (ExternalAccessUserRoleDetail extUserRoleDetail : userRoleDetailList) {
+			try {
+				// check if user already has role in local
+				if (!currentCentralizedUserAppRolesMap.containsKey(extUserRoleDetail.getName())) {
+					CentralizedAppRoles getCenAppRole = cenAppRolesMap.get(extUserRoleDetail.getName());
+					if (getCenAppRole != null) {
+						logger.debug(EELFLoggerDelegate.debugLogger,
+								"addUserRolesInLocal: Adding user role from external auth system  {}",
+								extUserRoleDetail.toString());
+						EPUserApp userApp = new EPUserApp();
+						EPApp app = new EPApp();
+						app.setId(getCenAppRole.getAppId());
+						EPRole epRole = new EPRole();
+						epRole.setId(getCenAppRole.getRoleId());
+						userApp.setApp(app);
+						userApp.setUserId(user.getId());
+						userApp.setRole(epRole);
+						dataAccessService.saveDomainObject(userApp, null);
+						logger.debug(EELFLoggerDelegate.debugLogger,
+								"addUserRolesInLocal: Finished user role from external auth system  {}",
+								extUserRoleDetail.toString());
+					} else if (getCenAppRole == null // check if user has app
+														// account admin role
+							&& extUserRoleDetail.getName().endsWith(PortalConstants.ADMIN_ROLE.replaceAll(
+									EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"))) {
+						EPApp app = centralisedAppsMap.get(extUserRoleDetail.getName());
+						if (app != null) {
+							logger.debug(EELFLoggerDelegate.debugLogger,
+									"addUserRolesInLocal: Adding user role from external auth system  {}",
+									extUserRoleDetail.toString());
+							EPUserApp userApp = new EPUserApp();
+							EPRole epRole = new EPRole();
+							epRole.setId(PortalConstants.ACCOUNT_ADMIN_ROLE_ID);
+							userApp.setApp(app);
+							userApp.setUserId(user.getId());
+							userApp.setRole(epRole);
+							dataAccessService.saveDomainObject(userApp, null);
+							logger.debug(EELFLoggerDelegate.debugLogger,
+									"addUserRolesInLocal: Finished user role from external auth system  {}",
+									extUserRoleDetail.toString());
+						}
+					}
+				}
+			} catch (Exception e) {
+				logger.error(EELFLoggerDelegate.errorLogger,
+						"addUserRolesInLocal - Failed to update user role in local from external auth system {} ",
+						extUserRoleDetail.toString(), e);
+			}
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	private HashMap<String, EPApp> getCentralizedAdminAppsInfo() {
+		List<EPApp> centralizedApps = dataAccessService.executeNamedQuery("getCentralizedApps", null, null);
+		HashMap<String, EPApp> centralisedAppsMap = new HashMap<>();
+		for (EPApp cenApp : centralizedApps) {
+			centralisedAppsMap.put(
+					cenApp.getNameSpace() + "."
+							+ PortalConstants.ADMIN_ROLE.replaceAll(
+									EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+					cenApp);
+		}
+		return centralisedAppsMap;
+	}
+
+	private HashMap<String, CentralizedAppRoles> getCurrentUserCentralizedAppRoles(
+			List<CentralizedAppRoles> currentUserAppRoles) {
+		HashMap<String, CentralizedAppRoles> currentCentralizedUserAppRolesMap = new HashMap<>();
+		for (CentralizedAppRoles cenAppUserRole : currentUserAppRoles) {
+			currentCentralizedUserAppRolesMap.put(
+					cenAppUserRole.getAppNameSpace() + "."
+							+ cenAppUserRole.getRoleName().replaceAll(
+									EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+					cenAppUserRole);
+		}
+		return currentCentralizedUserAppRolesMap;
+	}
+
+	@SuppressWarnings("unchecked")
+	private HashMap<String, CentralizedAppRoles> getCentralizedAppRoleList() {
+		List<CentralizedAppRoles> centralizedAppRoles = dataAccessService
+				.executeNamedQuery("getAllCentralizedAppsRoles", null, null);
+		HashMap<String, CentralizedAppRoles> cenAppRolesMap = new HashMap<>();
+		for (CentralizedAppRoles CentralizedAppRole : centralizedAppRoles) {
+			cenAppRolesMap.put(
+					CentralizedAppRole.getAppNameSpace() + "."
+							+ CentralizedAppRole.getRoleName().replaceAll(
+									EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"),
+					CentralizedAppRole);
+		}
+		return cenAppRolesMap;
+	}
+
+	@Override
+	public ResponseEntity<String> getUserRolesFromExtAuthSystem(String name, HttpEntity<String> getUserRolesEntity) {
+		logger.debug(EELFLoggerDelegate.debugLogger, "Connecting to external system to get current user roles");
+		ResponseEntity<String> getResponse = template
+				.exchange(SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_URL)
+						+ "roles/user/" + name, HttpMethod.GET, getUserRolesEntity, String.class);
+		if (getResponse.getStatusCode().value() == 200) {
+			logger.debug(EELFLoggerDelegate.debugLogger,
+					"getAllUserRoleFromExtAuthSystem: Finished GET user roles from external system and received user roles {}",
+					getResponse.getBody());
+		} else {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"getAllUserRoleFromExtAuthSystem: Failed GET user roles from external system and received user roles {}",
+					getResponse.getBody());
+			EPLogUtil.logExternalAuthAccessAlarm(logger, getResponse.getStatusCode());
+		}
+		return getResponse;
+	}
+
+	@Override
+	public Integer updateAppRoleDescription(String uebkey) {
+		Integer roleDescUpdated = 0;
+		EPApp app;
+		try {
+			app = getApp(uebkey).get(0);
+			List<EPRole> roles = getAppRoles(app.getId());
+			for (EPRole epRole : roles) {
+				Role role = new Role();
+				role.setName(epRole.getName());
+				boolean status = addRoleDescriptionInExtSystem(role, app);
+				if (status)
+					roleDescUpdated++;
+			}
+		} catch (Exception e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "updateAppRoleDescription: Failed! ", e);
+		}
+		return roleDescUpdated;
+	}
+
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/UserRolesCommonServiceImpl.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/UserRolesCommonServiceImpl.java
index aaaf91bd..1904d8e2 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/UserRolesCommonServiceImpl.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/service/UserRolesCommonServiceImpl.java
@@ -114,6 +114,7 @@ import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.HttpClientErrorException;
 import org.springframework.web.client.RestTemplate;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
@@ -176,10 +177,10 @@ public class UserRolesCommonServiceImpl  {
 	 * 
 	 * @param userId
 	 */
-	protected boolean createLocalUserIfNecessary(String userId) {
+	protected void createLocalUserIfNecessary(String userId,boolean isSystemUser) {
 		if (StringUtils.isEmpty(userId)) {
 			logger.error(EELFLoggerDelegate.errorLogger, "createLocalUserIfNecessary : empty userId!");
-			return false;
+			return;
 		}
 		Session localSession = null;
 		Transaction transaction = null;
@@ -193,7 +194,15 @@ public class UserRolesCommonServiceImpl  {
 					.setParameter("userId",userId)
 					.list();
 			if (userList.size() == 0) {
-				EPUser client = searchService.searchUserByUserId(userId);
+				EPUser client = null;
+				if (!isSystemUser) {
+					client = searchService.searchUserByUserId(userId);
+				} else {
+					client = new EPUser();
+					client.setOrgUserId(userId);
+					client.setSystemUser(true);
+					client.setFirstName(userId.substring(0,userId.indexOf("@")));
+				}
 				if (client == null) {
 					String msg = "createLocalUserIfNecessary: cannot create user " + userId
 							+ ", because not found in phonebook";
@@ -205,11 +214,9 @@ public class UserRolesCommonServiceImpl  {
 				}
 			}
 			transaction.commit();
-			return true;
 		} catch (Exception e) {
 			EPLogUtil.logEcompError(logger, EPAppMessagesEnum.BeDaoSystemError, e);
 			EcompPortalUtils.rollbackTransaction(transaction, "searchOrCreateUser rollback, exception = " + e);
-			return false;
 		} finally {
 			EcompPortalUtils.closeLocalSession(localSession, "searchOrCreateUser");
 		}
@@ -630,6 +637,7 @@ public class UserRolesCommonServiceImpl  {
 		result = new RolesInAppForUser();
 		result.appId = appId;
 		result.orgUserId = userId;
+
 		for (EcompRole role : userRolesInRemoteApp) {
 			RoleInAppForUser roleInAppForUser = new RoleInAppForUser();
 			roleInAppForUser.roleId = role.getId();
@@ -667,7 +675,7 @@ public class UserRolesCommonServiceImpl  {
 	 * @throws HTTPException
 	 */
 	protected Set<EcompRole> postUsersRolesToRemoteApp(List<RoleInAppForUser> roleInAppForUserList, ObjectMapper mapper,
-			ApplicationsRestClientService applicationsRestClientService, Long appId, String userId)
+			ApplicationsRestClientService applicationsRestClientService, Long appId, String userId,boolean systemUser)
 			throws JsonProcessingException, HTTPException {
 		Set<EcompRole> updatedUserRolesinRemote = constructUsersRemoteAppRoles(roleInAppForUserList);
 		Set<EcompRole> updateUserRolesInEcomp = constructUsersEcompRoles(roleInAppForUserList);
@@ -744,13 +752,13 @@ public class UserRolesCommonServiceImpl  {
 	 * 			set to false if requests from Users page otherwise true
 	 * @return true on success, false otherwise
 	 */
-	protected boolean applyChangesInUserRolesForAppToEcompDB(RolesInAppForUser rolesInAppForUser, boolean externalSystemRequest, String reqType) throws Exception {
+	protected boolean applyChangesInUserRolesForAppToEcompDB(RolesInAppForUser rolesInAppForUser, boolean externalSystemRequest, String reqType,boolean isSystemUser) throws Exception {
 		boolean result = false;
 		String userId = rolesInAppForUser.orgUserId;
 		Long appId = rolesInAppForUser.appId;
 		synchronized (syncRests) {
 			if (rolesInAppForUser != null) {
-				createLocalUserIfNecessary(userId);
+				createLocalUserIfNecessary(userId, isSystemUser);
 			}
 
 			if (rolesInAppForUser != null) {
@@ -857,22 +865,42 @@ public class UserRolesCommonServiceImpl  {
 		return addRemoteUser;
 	}
 
+	@SuppressWarnings("unchecked")
 	protected void pushUserOnRemoteApp(String userId, EPApp app,
 			ApplicationsRestClientService applicationsRestClientService, SearchService searchService,
 			ObjectMapper mapper, boolean postOpenSource, List<RoleInAppForUser> roleInAppForUserList,boolean appRoleIdUsed) throws Exception {
 
-		EPUser client = searchService.searchUserByUserId(userId);
+		EPUser client  = null;
+			client = searchService.searchUserByUserId(userId);
 
-		mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-
-		if (client == null) {
-			String msg = "cannot create user " + userId + ", because he/she cannot be found in phonebook.";
-			logger.error(EELFLoggerDelegate.errorLogger, msg);
-			throw new Exception(msg);
-		}
+			mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+			if (client == null) {
+				String msg = "cannot create user " + userId + ", because he/she cannot be found in directory.";
+				logger.error(EELFLoggerDelegate.errorLogger, msg);
+				// throw new Exception(msg);
+				final Map<String, String> loginIdParams = new HashMap<>();
+				loginIdParams.put("orgUserIdValue", userId);
+				List<EPUser> userList = new ArrayList<>();
+				userList = dataAccessService.executeNamedQuery("epUserAppId", loginIdParams, null);
+				if (userList.size() > 0) {
+					logger.debug(EELFLoggerDelegate.debugLogger,
+							userList.get(0).getOrgUserId() + " User was found in Portal");
+					client = userList.get(0);
+					SortedSet<EPUserApp> userApps = new TreeSet<>();
+					client.setEPUserApps(userApps);
+					client.setSystemUser(false);
+				} else {
+					logger.error(EELFLoggerDelegate.errorLogger, "user cannot be found be in directory or in portal");
+					throw new Exception(msg);
+				}
 
+			}
+		
 		client.setLoginId(userId);
-		client.setActive(true);
+	    client.setActive(true);
+	    client.setOrgUserId(userId);
+	
+		
 		roleInAppForUserList.removeIf(role -> role.isApplied.equals(false));
 		SortedSet<Role> roles = new TreeSet<>();
 
@@ -978,7 +1006,7 @@ public class UserRolesCommonServiceImpl  {
 		}
 		Long appId = newAppRolesForUser.appId;
 		List<RoleInAppForUser> roleInAppForUserList = newAppRolesForUser.appRoles;
-		if (userId.length() > 0) {
+		if (userId.length() > 0 ) {
 			ObjectMapper mapper = new ObjectMapper();
 			mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 
@@ -986,7 +1014,27 @@ public class UserRolesCommonServiceImpl  {
 				EPApp app = appsService.getApp(appId);
 				applyChangesToUserAppRolesForMyLoginsRequest(user, appId);
 
-				// if centralized app
+				boolean systemUser = newAppRolesForUser.isSystemUser;
+				if ((app.getCentralAuth() || app.getId().equals(PortalConstants.PORTAL_APP_ID)) && systemUser) {
+
+					Set<EcompRole> userRolesInLocalApp = postUsersRolesToLocalApp(roleInAppForUserList, mapper,
+							applicationsRestClientService, appId, userId);
+					RolesInAppForUser rolesInAppForUser = constructRolesInAppForUserUpdate(userId, appId,
+							userRolesInLocalApp);
+					List<RoleInAppForUser> roleAppUserList = rolesInAppForUser.roles;
+					if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
+						// Apply changes in external Access system
+						updateUserRolesInExternalSystem(app, rolesInAppForUser.orgUserId, roleAppUserList,
+								epRequestValue, systemUser);
+					}
+					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, "Portal",
+							systemUser);
+
+				}else if (!app.getCentralAuth() && systemUser)
+				{
+					throw new Exception("For non-centralized application we cannot add systemUser");
+				}
+				else{	// if centralized app
 				if (app.getCentralAuth()) {
 					if (!app.getId().equals(PortalConstants.PORTAL_APP_ID)) {
 						pushRemoteUser(roleInAppForUserList, userId, app, mapper, searchService,
@@ -1001,9 +1049,9 @@ public class UserRolesCommonServiceImpl  {
 					if (EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
 						// Apply changes in external Access system
 						updateUserRolesInExternalSystem(app, rolesInAppForUser.orgUserId, roleAppUserList,
-								epRequestValue);
+								epRequestValue,false);
 					}
-					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, "Portal");
+					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, "Portal", systemUser);
 				} 
 				// In case if portal is not centralized then follow existing approach
 				else if(!app.getCentralAuth() && app.getId().equals(PortalConstants.PORTAL_APP_ID)){
@@ -1011,7 +1059,7 @@ public class UserRolesCommonServiceImpl  {
 							applicationsRestClientService, appId, userId);	
 					RolesInAppForUser rolesInAppForUser = constructRolesInAppForUserUpdate(userId, appId,
 							userRolesInLocalApp);
-					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, "Portal");
+					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, "Portal",false);
 				} else{// remote app
 					EPUser remoteAppUser = null;
 					if(!app.getCentralAuth() && !app.getId().equals(PortalConstants.PORTAL_APP_ID)){
@@ -1022,10 +1070,10 @@ public class UserRolesCommonServiceImpl  {
 							remoteAppUser = addRemoteUser(roleInAppForUserList, userId, app, mapper, searchService, applicationsRestClientService);
 						}
 						Set<EcompRole> userRolesInRemoteApp = postUsersRolesToRemoteApp(roleInAppForUserList, mapper,
-									applicationsRestClientService, appId, userId);
+									applicationsRestClientService, appId, userId,systemUser);
 							RolesInAppForUser rolesInAppForUser = constructRolesInAppForUserUpdate(userId, appId,
 									userRolesInRemoteApp);
-							result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, null);
+							result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, epRequestValue, null,false);
 
 							// If no roles remain, request app to set user inactive.
 							if (userRolesInRemoteApp.size() == 0) {
@@ -1037,6 +1085,7 @@ public class UserRolesCommonServiceImpl  {
 						}
 					}
 				}
+			}
 			} catch (Exception e) {
 				/*String message = String.format(
 						"Failed to create user or update user roles for User %s, AppId %s",
@@ -1067,7 +1116,7 @@ public class UserRolesCommonServiceImpl  {
 	 * @param roleInAppUser Contains list of active roles 
 	 */
 	@SuppressWarnings("unchecked")
-	private void updateUserRolesInExternalSystem(EPApp app, String orgUserId, List<RoleInAppForUser> roleInAppUser, boolean isPortalRequest) throws Exception
+	private void updateUserRolesInExternalSystem(EPApp app, String orgUserId, List<RoleInAppForUser> roleInAppUser, boolean isPortalRequest,boolean isSystemUser) throws Exception
 	{
 		try {
 			// check if user exists
@@ -1075,13 +1124,15 @@ public class UserRolesCommonServiceImpl  {
 			userParams.put("orgUserIdValue", orgUserId);
 			List<EPUser> userInfo = checkIfUserExists(userParams);
 			if (userInfo.isEmpty()) {
-				createLocalUserIfNecessary(orgUserId);
+				createLocalUserIfNecessary(orgUserId, isSystemUser);
 			}
 			String name = "";
 			if (EPCommonSystemProperties
-					.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN)) {
+					.containsProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN) && !isSystemUser) {
 				name = orgUserId
 						+ SystemProperties.getProperty(EPCommonSystemProperties.EXTERNAL_CENTRAL_ACCESS_USER_DOMAIN);
+			} else {
+				name = orgUserId;
 			}
 			ObjectMapper mapper = new ObjectMapper();
 			HttpHeaders headers = EcompPortalUtils.base64encodeKeyForAAFBasicAuth();
@@ -1173,7 +1224,7 @@ public class UserRolesCommonServiceImpl  {
 			for (RoleInAppForUser addUserRole : roleInAppUserNonDupls) {
 				if (!(currentUserRolesInExternalSystem
 						.containsKey(app.getNameSpace() + "." + addUserRole.getRoleName().replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_")))) {
-					ExternalAccessUser extUser = new ExternalAccessUser(name,
+ 					ExternalAccessUser extUser = new ExternalAccessUser(name,
 							app.getNameSpace() + "." + addUserRole.getRoleName().replaceAll(EcompPortalUtils.EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS, "_"));
 					String formattedUserRole = mapper.writeValueAsString(extUser);
 					HttpEntity<String> entity = new HttpEntity<>(formattedUserRole, headers);
@@ -1193,7 +1244,23 @@ public class UserRolesCommonServiceImpl  {
 					}
 				}
 			}
-		} catch (Exception e) {
+		} catch (HttpClientErrorException e) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"updateUserRolesInExternalSystem: Failed to add user role for application {} due to {}",
+					app.getId(), e);
+			if (e.getStatusCode() == HttpStatus.FORBIDDEN) {
+				logger.error(EELFLoggerDelegate.errorLogger, "Please enter the valid systemUser", orgUserId);
+				throw new HttpClientErrorException(HttpStatus.FORBIDDEN, "Please enter the valid systemUser");
+			}
+			if (e.getStatusCode() == HttpStatus.NOT_FOUND) {
+				logger.error(EELFLoggerDelegate.errorLogger, "Please enter the valid role");
+				throw new HttpClientErrorException(HttpStatus.NOT_FOUND, "Please enter the valid role");
+			}
+			EPLogUtil.logExternalAuthAccessAlarm(logger, HttpStatus.BAD_REQUEST);
+			throw e;
+		}
+
+		catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "updateUserRolesInExternalSystem: Failed to add user role for application {} due to {}", app.getId(), e);
 			EPLogUtil.logExternalAuthAccessAlarm(logger, HttpStatus.BAD_REQUEST);
 			throw e;
@@ -1489,11 +1556,11 @@ public class UserRolesCommonServiceImpl  {
 					List<RoleInAppForUser> roleAppUserList = rolesInAppForUser.roles;
 					if(EcompPortalUtils.checkIfRemoteCentralAccessAllowed()) {
 					// Apply changes in external Access system
-					updateUserRolesInExternalSystem(app, rolesInAppForUser.orgUserId, roleAppUserList, externalSystemRequest);
+					updateUserRolesInExternalSystem(app, rolesInAppForUser.orgUserId, roleAppUserList, externalSystemRequest,false);
 					}
 					logger.info(EELFLoggerDelegate.debugLogger, "setExternalRequestUserAppRole: {} user app roles: for app {}, user {}", logMessage,
 							newAppRolesForUser.getApplicationName(), newAppRolesForUser.getLoginId());
-					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest, reqType);
+					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest, reqType,false);
 				} 
 				// If local application is not centralized 
 				else if(!app.getCentralAuth() && app.getId().equals(PortalConstants.PORTAL_APP_ID)){
@@ -1501,7 +1568,7 @@ public class UserRolesCommonServiceImpl  {
 							applicationsRestClientService, app.getId(), orgUserId);	
 					RolesInAppForUser rolesInAppForUser = constructRolesInAppForUserUpdate(orgUserId, app.getId(),
 							userRolesInLocalApp);
-					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest, reqType);
+					result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest, reqType,false);
 				} else {// remote app
 					// If adding just account admin role don't do remote application user call
 					if (!((roleInAppForUserList.size() == 1 || reqType.equals("DELETE")) && checkIfAdminRoleExists)) {
@@ -1514,7 +1581,7 @@ public class UserRolesCommonServiceImpl  {
 						}
 
 						Set<EcompRole> userRolesInRemoteApp = postUsersRolesToRemoteApp(roleInAppForUserList, mapper,
-								applicationsRestClientService, app.getId(), orgUserId);
+								applicationsRestClientService, app.getId(), orgUserId,false);
 
 						RolesInAppForUser rolesInAppForUser = constructRolesInAppForUserUpdate(orgUserId, app.getId(),
 								userRolesInRemoteApp);
@@ -1522,7 +1589,7 @@ public class UserRolesCommonServiceImpl  {
 								"setExternalRequestUserAppRole: {} user app roles: for app {}, user {}", logMessage,
 								newAppRolesForUser.getApplicationName(), newAppRolesForUser.getLoginId());
 						result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest,
-								reqType);
+								reqType,false);
 						// If no roles remain, request app to set user inactive.
 						/*
 						 * if (userRolesInRemoteApp.size() == 0) {
@@ -1545,7 +1612,7 @@ public class UserRolesCommonServiceImpl  {
 						logger.info(EELFLoggerDelegate.debugLogger, "setExternalRequestUserAppRole: {} user app roles: for app {}, user {}",
 								logMessage, newAppRolesForUser.getApplicationName(), newAppRolesForUser.getLoginId());
 						result = applyChangesInUserRolesForAppToEcompDB(rolesInAppForUser, externalSystemRequest,
-								reqType);
+								reqType,false);
 					}
 					if(!result){
 						reqMessage = "Failed to save the user app role(s)";
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/transport/AppWithRolesForUser.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/transport/AppWithRolesForUser.java
index 60bc7fce..e2336dbd 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/transport/AppWithRolesForUser.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/transport/AppWithRolesForUser.java
@@ -42,6 +42,8 @@ import java.util.List;
 public class AppWithRolesForUser {
 
 	public String orgUserId;
+		
+	public boolean isSystemUser;
 
 	public Long appId;
 
@@ -81,10 +83,20 @@ public class AppWithRolesForUser {
 		this.appRoles = appRoles;
 	}
 
+	
+
+	public boolean isSystemUser() {
+		return isSystemUser;
+	}
+
+	public void setSystemUser(boolean isSystemUser) {
+		this.isSystemUser = isSystemUser;
+	}
+
 	@Override
 	public String toString() {
-		return "AppWithRolesForUser [orgUserId=" + orgUserId + ", appId=" + appId + ", appName=" + appName
-				+ ", appRoles=" + appRoles + "]";
+		return "AppWithRolesForUser [orgUserId=" + orgUserId + ", isSystemUser=" + isSystemUser + ", appId=" + appId
+				+ ", appName=" + appName + ", appRoles=" + appRoles + "]";
 	}
 
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/utils/EcompPortalUtils.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/utils/EcompPortalUtils.java
index 1b5613ca..30eeac04 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/utils/EcompPortalUtils.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/portal/utils/EcompPortalUtils.java
@@ -47,10 +47,12 @@ import java.util.Arrays;
 import java.util.Base64;
 import java.util.Date;
 import java.util.List;
+import java.util.regex.Pattern;
 
 import javax.servlet.http.HttpServletResponse;
 import javax.xml.bind.DatatypeConverter;
 
+import org.apache.commons.codec.binary.Hex;
 import org.apache.commons.lang.StringUtils;
 import org.hibernate.Session;
 import org.hibernate.Transaction;
@@ -70,19 +72,21 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 public class EcompPortalUtils {
 
 	private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(EcompPortalUtils.class);
-	
+
 	private static final String FUNCTION_PIPE = "|";
-	
+
 	// TODO: GLOBAL_LOGIN_URL is the same as in SessionTimeoutInterceptor.
 	// It should be defined in SystemProperties.
 	private static final String GLOBAL_LOGIN_URL = "global-login-url";
-	
-	// It is a regular expression used for while creating a External Central Auth Role 
+
+	// It is a regular expression used for while creating a External Central Auth
+	// Role
 	public static final String EXTERNAL_CENTRAL_AUTH_ROLE_HANDLE_SPECIAL_CHARACTERS = "([^A-Z^a-z^0-9^\\.^%^(^)^=^:])";
-	
+
+	public static final String slash = "/";
+
 	/**
-	 * @param orgUserId
-	 *            User ID to validate
+	 * @param orgUserId User ID to validate
 	 * @return true if orgUserId is not empty and contains only alphanumeric, false
 	 *         otherwise
 	 */
@@ -94,10 +98,8 @@ public class EcompPortalUtils {
 	 * Splits the string into a list of tokens using the specified regular
 	 * expression
 	 * 
-	 * @param source
-	 *            String to split
-	 * @param regex
-	 *            tokens
+	 * @param source String to split
+	 * @param regex  tokens
 	 * @return List of tokens split from the source
 	 */
 	public static List<String> parsingByRegularExpression(String source, String regex) {
@@ -116,10 +118,8 @@ public class EcompPortalUtils {
 	/**
 	 * Builds a JSON object with error code and message information.
 	 * 
-	 * @param errorCode
-	 *            error code
-	 * @param errorMessage
-	 *            message
+	 * @param errorCode    error code
+	 * @param errorMessage message
 	 * @return JSON object as a String
 	 */
 	public static String jsonErrorMessageResponse(int errorCode, String errorMessage) {
@@ -129,8 +129,7 @@ public class EcompPortalUtils {
 	/**
 	 * Builds a JSON object with the specified message
 	 * 
-	 * @param message
-	 *            Message to embed
+	 * @param message Message to embed
 	 * @return JSON object as a String
 	 */
 	public static String jsonMessageResponse(String message) {
@@ -141,15 +140,11 @@ public class EcompPortalUtils {
 	 * Serializes the specified object as JSON and writes the result to the debug
 	 * log. If serialization fails, logs a message to the error logger.
 	 * 
-	 * @param logger
-	 *            Logger for the class where the object was built; the logger
-	 *            carries the class name.
-	 * @param source
-	 *            First portion of the log message
-	 * @param msg
-	 *            Second portion of the log message
-	 * @param obj
-	 *            Object to serialize as JSON
+	 * @param logger Logger for the class where the object was built; the logger
+	 *               carries the class name.
+	 * @param source First portion of the log message
+	 * @param msg    Second portion of the log message
+	 * @param obj    Object to serialize as JSON
 	 */
 	public static void logAndSerializeObject(EELFLoggerDelegate logger, String source, String msg, Object obj) {
 		try {
@@ -169,12 +164,9 @@ public class EcompPortalUtils {
 	 * Serializes the specified object as JSON and writes the result to the debug
 	 * log. If serialization fails, logs a message to the error logger.
 	 * 
-	 * @param source
-	 *            First portion of the log message
-	 * @param msg
-	 *            Second portion of the log message
-	 * @param obj
-	 *            Object to serialize as JSON
+	 * @param source First portion of the log message
+	 * @param msg    Second portion of the log message
+	 * @param obj    Object to serialize as JSON
 	 */
 	public static void logAndSerializeObject(String source, String msg, Object obj) {
 		logAndSerializeObject(logger, source, msg, obj);
@@ -209,12 +201,9 @@ public class EcompPortalUtils {
 	 * Set response status to Unauthorized if user == null and to Forbidden in all
 	 * (!) other cases. Logging is not performed if invocator == null
 	 * 
-	 * @param user
-	 *            User object
-	 * @param response
-	 *            HttpServletResponse
-	 * @param invocator
-	 *            may be null
+	 * @param user      User object
+	 * @param response  HttpServletResponse
+	 * @param invocator may be null
 	 */
 	public static void setBadPermissions(EPUser user, HttpServletResponse response, String invocator) {
 		if (user == null) {
@@ -248,13 +237,15 @@ public class EcompPortalUtils {
 	// This method might be just for testing purposes.
 	public static void setExternalAppResponseCode(int responseCode) {
 		try {
-			/*String code = String.valueOf(responseCode);
-			MDC.put(EPCommonSystemProperties.EXTERNAL_API_RESPONSE_CODE,code );
-			code=StringUtils.EMPTY;*/
+			/*
+			 * String code = String.valueOf(responseCode);
+			 * MDC.put(EPCommonSystemProperties.EXTERNAL_API_RESPONSE_CODE,code );
+			 * code=StringUtils.EMPTY;
+			 */
 			String code = Integer.toString(responseCode);
-			MDC.put(EPCommonSystemProperties.EXTERNAL_API_RESPONSE_CODE,code );
-			char[] chars=code.toCharArray();
-	        Arrays.fill(chars, ' ');
+			MDC.put(EPCommonSystemProperties.EXTERNAL_API_RESPONSE_CODE, code);
+			char[] chars = code.toCharArray();
+			Arrays.fill(chars, ' ');
 		} catch (Exception e) {
 			logger.error(EELFLoggerDelegate.errorLogger, "setExternalAppResponseCode failed", e);
 		}
@@ -337,10 +328,8 @@ public class EcompPortalUtils {
 	/**
 	 * Returns a default property if the expected one is not available
 	 * 
-	 * @param property
-	 *            Key
-	 * @param defaultValue
-	 *            default Value
+	 * @param property     Key
+	 * @param defaultValue default Value
 	 * @return Default value if property is not defined or yields the empty string;
 	 *         else the property value.
 	 */
@@ -360,10 +349,8 @@ public class EcompPortalUtils {
 	 * "MDC.remove(SystemProperties.MDC_TIMER);" after this method call to clean up
 	 * the record in MDC
 	 *
-	 * @param beginDateTime
-	 *            the given begin time for the call
-	 * @param endDateTime
-	 *            the given end time for the call
+	 * @param beginDateTime the given begin time for the call
+	 * @param endDateTime   the given end time for the call
 	 * 
 	 */
 	public static void calculateDateTimeDifferenceForLog(String beginDateTime, String endDateTime) {
@@ -405,8 +392,7 @@ public class EcompPortalUtils {
 	 * 
 	 * @return header which contains external central auth username and password
 	 *         base64 encoded
-	 * @throws Exception
-	 *             if unable to decrypt the password
+	 * @throws Exception if unable to decrypt the password
 	 */
 	public static HttpHeaders base64encodeKeyForAAFBasicAuth() throws Exception {
 		String userName = "";
@@ -429,7 +415,8 @@ public class EcompPortalUtils {
 		String result = "";
 		if (encrypted != null && encrypted.length() > 0) {
 			try {
-				result = CipherUtil.decryptPKC(encrypted, SystemProperties.getProperty(SystemProperties.Decryption_Key));
+				result = CipherUtil.decryptPKC(encrypted,
+						SystemProperties.getProperty(SystemProperties.Decryption_Key));
 			} catch (Exception e) {
 				logger.error(EELFLoggerDelegate.errorLogger, "decryptedPassword failed", e);
 				throw e;
@@ -438,8 +425,8 @@ public class EcompPortalUtils {
 		return result;
 	}
 
-	public static String truncateString(String originString, int size){
-		if(originString.length()>=size){
+	public static String truncateString(String originString, int size) {
+		if (originString.length() >= size) {
 			StringBuilder stringBuilder = new StringBuilder();
 			stringBuilder.append(originString);
 			stringBuilder.setLength(size);
@@ -448,11 +435,10 @@ public class EcompPortalUtils {
 		}
 		return originString;
 	}
-	
+
 	/**
 	 * 
-	 * If function code value has any pipes it does pipe filter and 
-	 * returns value.
+	 * If function code value has any pipes it does pipe filter and returns value.
 	 * 
 	 * @param functionCode
 	 * @return function instance without pipe
@@ -462,22 +448,19 @@ public class EcompPortalUtils {
 		if (functionCode.contains(FUNCTION_PIPE)) {
 			int count = StringUtils.countMatches(functionCode, FUNCTION_PIPE);
 			if (count == 2)
-				finalFunctionCodeVal = functionCode.substring(
-						functionCode.indexOf(FUNCTION_PIPE) + 1,
+				finalFunctionCodeVal = functionCode.substring(functionCode.indexOf(FUNCTION_PIPE) + 1,
 						functionCode.lastIndexOf(FUNCTION_PIPE));
 			else
-				finalFunctionCodeVal = functionCode
-						.substring(functionCode.lastIndexOf(FUNCTION_PIPE) + 1);
-		} else{
+				finalFunctionCodeVal = functionCode.substring(functionCode.lastIndexOf(FUNCTION_PIPE) + 1);
+		} else {
 			finalFunctionCodeVal = functionCode;
 		}
 		return finalFunctionCodeVal;
 	}
-	
+
 	/**
 	 * 
-	 * If function code value has any pipes it does pipe filter and 
-	 * returns value.
+	 * If function code value has any pipes it does pipe filter and returns value.
 	 * 
 	 * @param functionCode
 	 * @return function Type without pipe
@@ -486,20 +469,19 @@ public class EcompPortalUtils {
 		String finalFunctionCodeVal = "";
 		if (functionCode.contains(FUNCTION_PIPE)) {
 			int count = StringUtils.countMatches(functionCode, FUNCTION_PIPE);
-			if (count == 2){
-				String[] getTypeValue = functionCode.split("\\"+FUNCTION_PIPE);		
+			if (count == 2) {
+				String[] getTypeValue = functionCode.split("\\" + FUNCTION_PIPE);
 				finalFunctionCodeVal = getTypeValue[0];
 			}
-		} else{
+		} else {
 			finalFunctionCodeVal = functionCode;
 		}
 		return finalFunctionCodeVal;
 	}
-	
+
 	/**
 	 * 
-	 * If function code value has any pipes it does pipe filter and 
-	 * returns value.
+	 * If function code value has any pipes it does pipe filter and returns value.
 	 * 
 	 * @param functionCode
 	 * @return function Action without pipe
@@ -509,17 +491,17 @@ public class EcompPortalUtils {
 		if (functionCode.contains(FUNCTION_PIPE)) {
 			int count = StringUtils.countMatches(functionCode, FUNCTION_PIPE);
 			if (count == 2)
-				finalFunctionCodeVal = functionCode.substring(
-						functionCode.lastIndexOf(FUNCTION_PIPE)+1);
-		} else{
+				finalFunctionCodeVal = functionCode.substring(functionCode.lastIndexOf(FUNCTION_PIPE) + 1);
+		} else {
 			finalFunctionCodeVal = functionCode;
 		}
 		return finalFunctionCodeVal;
 	}
-	
+
 	/**
 	 * 
-	 * It check whether the external auth namespace is matching with current namespace exists in local DB
+	 * It check whether the external auth namespace is matching with current
+	 * namespace exists in local DB
 	 * 
 	 * @param permTypeVal
 	 * @param appNamespaceVal
@@ -539,20 +521,22 @@ public class EcompPortalUtils {
 		}
 		return isNamespaceMatching;
 	}
-	
+
 	public static boolean checkIfRemoteCentralAccessAllowed() {
 		boolean result = false;
-		String rmtCentralAccess = SystemProperties.getProperty(EPCommonSystemProperties.REMOTE_CENTRALISED_SYSTEM_ACCESS);
-		if(rmtCentralAccess == null) {
-	    	logger.error(EELFLoggerDelegate.errorLogger, "Please check in system.properties whether the property exists or not!");
+		String rmtCentralAccess = SystemProperties
+				.getProperty(EPCommonSystemProperties.REMOTE_CENTRALISED_SYSTEM_ACCESS);
+		if (rmtCentralAccess == null) {
+			logger.error(EELFLoggerDelegate.errorLogger,
+					"Please check in system.properties whether the property exists or not!");
 			return false;
-		}else if(new Boolean(rmtCentralAccess)){
-	    	logger.debug(EELFLoggerDelegate.debugLogger, "checkIfRemoteCentralAccessAllowed: {}",rmtCentralAccess);
+		} else if (new Boolean(rmtCentralAccess)) {
+			logger.debug(EELFLoggerDelegate.debugLogger, "checkIfRemoteCentralAccessAllowed: {}", rmtCentralAccess);
 			result = true;
 		}
 		return result;
 	}
-	
+
 	/**
 	 * 
 	 * It validates whether given string is JSON or not
@@ -560,28 +544,48 @@ public class EcompPortalUtils {
 	 * @param jsonInString
 	 * @return true or false
 	 */
-	  public static boolean isJSONValid(String jsonInString ) {
-		    try {
-		       final ObjectMapper mapper = new ObjectMapper();
-		       mapper.readTree(jsonInString);
-		       return true;
-		    } catch (IOException e) {
-		    	logger.error(EELFLoggerDelegate.errorLogger, "Failed to parse Json!", e);
-		       return false;
-		    }
-		  }
-	  /**
-	   * 
-	   *  It retrieves account information from input String
-	   * 
-	   * @param authValue
-	   * @return Array of Account information
-	   * 
-	   */
-	  public static String[] getUserNamePassword(String authValue) {
-			String base64Credentials = authValue.substring("Basic".length()).trim();
-			String credentials = new String(Base64.getDecoder().decode(base64Credentials), Charset.forName("UTF-8"));
-			final String[] values = credentials.split(":", 2);
-			return values;
+	public static boolean isJSONValid(String jsonInString) {
+		try {
+			final ObjectMapper mapper = new ObjectMapper();
+			mapper.readTree(jsonInString);
+			return true;
+		} catch (IOException e) {
+			logger.error(EELFLoggerDelegate.errorLogger, "Failed to parse Json!", e);
+			return false;
 		}
+	}
+
+	/**
+	 * 
+	 * It retrieves account information from input String
+	 * 
+	 * @param authValue
+	 * @return Array of Account information
+	 * 
+	 */
+	public static String[] getUserNamePassword(String authValue) {
+		String base64Credentials = authValue.substring("Basic".length()).trim();
+		String credentials = new String(Base64.getDecoder().decode(base64Credentials), Charset.forName("UTF-8"));
+		final String[] values = credentials.split(":", 2);
+		return values;
+	}
+
+	/**
+	 * It encodes the function code based on Hex encoding
+	 * 
+	 * @param funCode
+	 * 
+	 */
+	public static String encodeFunctionCode(String funCode) {
+		String encodedString = funCode;
+		Pattern encodePattern = Pattern.compile(EcompPortalUtils.slash);
+		return encodedString = encodePattern.matcher(encodedString)
+				.replaceAll("%" + Hex.encodeHexString(encodePattern.toString().getBytes()))
+				.replaceAll("\\*", "%" + Hex.encodeHexString("*".getBytes()));
+	}
+
+	public static boolean checkFunctionCodeHasEncodePattern(String code) {
+		return code.contains(EcompPortalUtils.slash);
+	}
+
 }
diff --git a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/util/EPUserUtils.java b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/util/EPUserUtils.java
index 51f48b16..99a29116 100644
--- a/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/util/EPUserUtils.java
+++ b/ecomp-portal-BE-common/src/main/java/org/onap/portalapp/util/EPUserUtils.java
@@ -45,7 +45,9 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.UUID;
+import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServletRequest;
@@ -398,4 +400,40 @@ public class EPUserUtils {
 		return "";
 	}
 
+	public static Boolean matchRoleFunctions(String portalApiPath, Set<? extends String> roleFunctions) {
+		String[] path = portalApiPath.split("/");
+		List<String> roleFunList = new ArrayList<>();
+		if (path.length > 1) {
+			roleFunList = roleFunctions.stream().filter(item -> item.startsWith(path[0])).collect(Collectors.toList());
+			if (roleFunList.size() >= 1) {
+				for (String roleFunction : roleFunList) {
+					String[] roleFunctionArray = roleFunction.split("/");
+					boolean b = true;
+					if (roleFunctionArray.length == path.length) {
+						for (int i = 0; i < roleFunctionArray.length; i++) {
+							if (b) {
+								if (!roleFunctionArray[i].equals("*")) {
+									Pattern p = Pattern.compile(Pattern.quote(path[i]), Pattern.CASE_INSENSITIVE);
+									Matcher m = p.matcher(roleFunctionArray[i]);
+									b = m.matches();
+
+								}
+							}
+						}
+							if (b)
+								return b;
+					}
+				}
+			}
+		} else {
+			for (String roleFunction : roleFunctions) {
+				if (roleFunction.equals(("*"))) {
+					return true;
+				} else if (portalApiPath.matches(roleFunction)) {
+					return true;
+				}
+			}
+		}
+		return false;
+	}
 }
diff --git a/ecomp-portal-BE-common/src/main/webapp/WEB-INF/fusion/orm/EP.hbm.xml b/ecomp-portal-BE-common/src/main/webapp/WEB-INF/fusion/orm/EP.hbm.xml
index e38b398e..e03c9762 100644
--- a/ecomp-portal-BE-common/src/main/webapp/WEB-INF/fusion/orm/EP.hbm.xml
+++ b/ecomp-portal-BE-common/src/main/webapp/WEB-INF/fusion/orm/EP.hbm.xml
@@ -229,6 +229,7 @@
 		<property name="createdId" column="created_id" />
 		<property name="modifiedId" column="modified_id" />
 		<property name="timeZoneId" column="timezone" />
+		<property name="systemUser" column="is_system_user" type="yes_no"/>
 		<property name="languageId" column="language_id" />
 
 		<set name="EPUserApps" table="FN_USER_ROLE" lazy="false" sort="natural"
@@ -1160,7 +1161,7 @@ where fn_role.app_id = fn_app.app_id and fn_app.enabled='Y' and fn_role.active_y
 	<sql-query name="getAppsAdmins">
 		<return alias="adminUserApp" class="org.onap.portalapp.portal.domain.AdminUserApp" />   
 	<![CDATA[
-    	SELECT apps.APP_NAME, apps.APP_ID, user.USER_ID, user.FIRST_NAME, user.LAST_NAME, user.org_user_id FROM fn_user_role userrole INNER JOIN fn_user user ON user.USER_ID = userrole.USER_ID INNER JOIN fn_app apps ON apps.APP_ID = userrole.APP_ID  WHERE user.active_yn='Y' AND userrole.ROLE_ID = :accountAdminRoleId AND (apps.ENABLED = 'Y' OR apps.APP_ID=1)      
+    	SELECT apps.APP_NAME, apps.APP_ID, user.USER_ID, user.FIRST_NAME, user.LAST_NAME, user.org_user_id FROM fn_user_role userrole INNER JOIN fn_user user ON user.USER_ID = userrole.USER_ID INNER JOIN fn_app apps ON apps.APP_ID = userrole.APP_ID  WHERE user.active_yn='Y' AND userrole.ROLE_ID = :accountAdminRoleId       
 	]]>
 	</sql-query>
 	
@@ -2549,6 +2550,32 @@ where fn_role.app_id = fn_app.app_id and fn_app.enabled='Y' and fn_role.active_y
  		]]>
 	</sql-query>
 	
+	<sql-query name="getAllAdminAppsofTheUser">
+		<![CDATA[
+		select fa.app_id  from fn_user_role ur,fn_app fa where ur.user_id =:userId and ur.app_id=fa.app_id and ur.role_id= 999
+
+		]]>
+    </sql-query>
+	<sql-query name="getAllAppsFunctionsOfUser">
+			<![CDATA[
+			select distinct ep.function_cd from fn_user_role fu, ep_app_role_function ep, ep_app_function ea, fn_app fa , fn_role fr
+			where fu.role_id = ep.role_id 
+			and fu.app_id = ep.app_id
+			and fu.user_id =:userId
+			and ea.function_cd = ep.function_cd
+            and ((fu.app_id = fa.app_id  and fa.enabled = 'Y' ) or (fa.app_id = 1))
+            and fr.role_id = fu.role_id and fr.active_yn='Y' 
+		    union
+            select distinct app_r_f.function_cd from ep_app_role_function app_r_f, ep_app_function a_f
+			where role_id = 999
+			and app_r_f.function_cd = a_f.function_cd
+			and exists
+			(
+			select fa.app_id from fn_user fu, fn_user_role ur, fn_app fa where fu.user_id =:userId and fu.user_id = ur.user_id
+			and ur.role_id = 999 and ur.app_id = fa.app_id and fa.enabled = 'Y'
+			);
+			]]>
+	</sql-query>
 	<sql-query name="updateFnUser">
 		<![CDATA[
 			UPDATE fn_user fu SET fu.language_id=:language_id WHERE fu.login_id=:login_id