+ JSONObject responseJsonObject;
+ responseJsonObject = this.success();
+ response.setContentType(CONTENTTYPE);
+ PrintWriter out = response.getWriter();
+ out.print(responseJsonObject);
+ out.flush();
+ } catch (Exception e) {
+ LOGGER.debug("Cannot write file");
+ throw new ServletException("Cannot write file", e);
+ }
+ }
+
+ private void processFormFile(HttpServletRequest request, FileItem item) {
+ String newFile;
+ if (item.getName().endsWith(".xls") && item.getSize() <= PolicyController.getFileSizeLimit()) {
+ File file = new File(item.getName());
+ try (OutputStream outputStream = new FileOutputStream(file)) {
+ IOUtils.copy(item.getInputStream(), outputStream);
+ newFile = file.toString();
+ PolicyExportAndImportController importController = new PolicyExportAndImportController();
+ importController.importRepositoryFile(newFile, request);
+ } catch (Exception e) {
+ LOGGER.error("Upload error : " + e);
+ }
+ } else if (!item.getName().endsWith(".xls")) {
+ LOGGER.error("Non .xls filetype uploaded: " + item.getName());
+ } else { // uploaded file size is greater than allowed
+ LOGGER.error("Upload file size limit exceeded! File size (Bytes) is: " + item.getSize());
+ }
+ }
+
+ // File Operation Functionality
+ private void fileOperation(HttpServletRequest request, HttpServletResponse response) throws ServletException {
+ JSONObject responseJsonObject;
+ StringBuilder sb = new StringBuilder();
+ try (BufferedReader br = request.getReader()) {
+ String str;
+ while ((str = br.readLine()) != null) {
+ sb.append(str);
+ }
+ } catch (Exception e) {
+ LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Exception Occured While doing File Operation" + e);
+ responseJsonObject = error(e.getMessage());
+ setResponse(response, responseJsonObject);
+ return;
+ }
+ try {
+ JSONObject jObj = new JSONObject(sb.toString());
+ JSONObject params = jObj.getJSONObject("params");
+ Mode mode = Mode.valueOf(params.getString("mode"));
+
+ String userId = UserUtils.getUserSession(request).getOrgUserId();
+ LOGGER.info(
+ "****************************************Logging UserID while doing actions on Editor tab*******************************************");
+ LOGGER.info(
+ "UserId: " + userId + "Action Mode: " + mode.toString() + "Action Params: " + params.toString());
+ LOGGER.info(
+ "***********************************************************************************************************************************");
+ responseJsonObject = operateBasedOnMode(mode, params, request);
+ } catch (Exception e) {
+ LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Exception Occured While Processing Json" + e);
+ responseJsonObject = error(e.getMessage());
+ }
+ setResponse(response, responseJsonObject);
+ }
+
+ private void setResponse(HttpServletResponse response, JSONObject responseJsonObject) {
+ response.setContentType(CONTENTTYPE);
+ try (PrintWriter out = response.getWriter()) {
+ out.print(responseJsonObject);
+ out.flush();
+ } catch (IOException e) {
+ LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Exception occured while writing response" + e);
+ }
+ }
+
+ private JSONObject operateBasedOnMode(Mode mode, JSONObject params, HttpServletRequest request)
+ throws ServletException {
+ JSONObject responseJsonObject;
+ switch (mode) {
+ case ADDFOLDER:
+ case ADDSUBSCOPE:
+ responseJsonObject = addFolder(params, request);
+ break;
+ case COPY:
+ responseJsonObject = copy(params, request);
+ break;
+ case DELETE:
+ responseJsonObject = delete(params, request);
+ break;
+ case EDITFILE:
+ case VIEWPOLICY:
+ responseJsonObject = editFile(params);
+ break;
+ case LIST:
+ responseJsonObject = list(params, request);
+ break;
+ case RENAME:
+ responseJsonObject = rename(params, request);
+ break;
+ case DESCRIBEPOLICYFILE:
+ responseJsonObject = describePolicy(params);
+ break;
+ case SWITCHVERSION:
+ responseJsonObject = switchVersion(params, request);
+ break;
+ case SEARCHLIST:
+ responseJsonObject = searchPolicyList(params, request);
+ break;
+ default:
+ throw new ServletException("not implemented");
+ }
+ if (responseJsonObject == null) {
+ responseJsonObject = error("generic error : responseJsonObject is null");
+ }
+ return responseJsonObject;
+ }
+
+ private JSONObject searchPolicyList(JSONObject params, HttpServletRequest request) {
+ List<Object> policyData = new ArrayList<>();
+ JSONArray policyList = null;
+ if (params.has("policyList")) {
+ policyList = (JSONArray) params.get("policyList");
+ }
+ PolicyController controller = getPolicyControllerInstance();
+ List<JSONObject> resultList = new ArrayList<>();
+ try {
+ if (!lookupPolicyData(request, policyData, policyList, controller, resultList))
+ return error("No Scopes has been Assigned to the User. Please, Contact Super-Admin");
+
+ } catch (Exception e) {
+ LOGGER.error(
+ "Exception occured while reading policy Data from Policy Version table for Policy Search Data" + e);
+ }
+
+ return new JSONObject().put(RESULT, resultList);
+ }
+
+ private boolean lookupPolicyData(HttpServletRequest request, List<Object> policyData, JSONArray policyList,
+ PolicyController controller, List<JSONObject> resultList) {
+ List<String> roles;
+ Set<String> scopes;// Get the Login Id of the User from Request
+ String userId = UserUtils.getUserSession(request).getOrgUserId();
+ List<Object> userRoles = controller.getRoles(userId);
+ Pair<Set<String>, List<String>> pair = org.onap.policy.utils.UserUtils.checkRoleAndScope(userRoles);
+ roles = pair.u;
+ scopes = pair.t;
+ if (roles.contains(ADMIN) || roles.contains(EDITOR) || roles.contains(GUEST)) {
+ if (scopes.isEmpty()) {
+ return false;
+ }
+ for (String scope : scopes) {
+ addScope(scopes, scope);
+ }
+ }
+ if (policyList != null) {
+ for (int i = 0; i < policyList.length(); i++) {
+ String policyName = policyList.get(i).toString().replace(".xml", "");
+ String version = policyName.substring(policyName.lastIndexOf('.') + 1);
+ policyName = policyName.substring(0, policyName.lastIndexOf('.')).replace(".", File.separator);
+ parsePolicyList(resultList, controller, policyName, version);
+ }
+ } else {
+ getPolicyDataForSUPERRoles(policyData, controller, resultList, roles, scopes);
+ }
+ return true;
+ }
+
+ private void getPolicyDataForSUPERRoles(List<Object> policyData, PolicyController controller,
+ List<JSONObject> resultList, List<String> roles, Set<String> scopes) {
+ if (roles.contains(SUPERADMIN) || roles.contains(SUPEREDITOR) || roles.contains(SUPERGUEST)) {
+ policyData = controller.getData(PolicyVersion.class);
+ } else {
+ List<Object> filterData = controller.getData(PolicyVersion.class);
+ for (Object filter : filterData) {
+ addFilterData(policyData, scopes, (PolicyVersion) filter);
+ }
+ }
+
+ if (!policyData.isEmpty()) {
+ updateResultList(policyData, resultList);
+ }
+ }
+
+ private void addFilterData(List<Object> policyData, Set<String> scopes, PolicyVersion filter) {
+ try {
+ String scopeName = filter.getPolicyName().substring(0, filter.getPolicyName().lastIndexOf(File.separator));
+ if (scopes.contains(scopeName)) {
+ policyData.add(filter);
+ }
+ } catch (Exception e) {
+ LOGGER.error("Exception occured while filtering policyversion data" + e);
+ }
+ }
+
+ private void updateResultList(List<Object> policyData, List<JSONObject> resultList) {
+ for (Object aPolicyData : policyData) {
+ PolicyVersion policy = (PolicyVersion) aPolicyData;
+ JSONObject el = new JSONObject();
+ el.put(NAME, policy.getPolicyName().replace(File.separator, FORWARD_SLASH));
+ el.put(DATE, policy.getModifiedDate());
+ el.put(VERSION, policy.getActiveVersion());
+ el.put(SIZE, "");
+ el.put(TYPE, "file");
+ el.put(CREATED_BY, getUserName(policy.getCreatedBy()));
+ el.put(MODIFIED_BY, getUserName(policy.getModifiedBy()));
+ resultList.add(el);
+ }
+ }
+
+ private void parsePolicyList(List<JSONObject> resultList, PolicyController controller, String policyName,
+ String version) {
+ if (policyName.contains(BACKSLASH)) {
+ policyName = policyName.replace(BACKSLASH, ESCAPE_BACKSLASH);
+ }
+ String policyVersionQuery =
+ "From PolicyVersion where policy_name = :policyName and active_version = :version and id >0";
+ SimpleBindings pvParams = new SimpleBindings();
+ pvParams.put("policyName", policyName);
+ pvParams.put(VERSION, version);
+ List<Object> activeData = controller.getDataByQuery(policyVersionQuery, pvParams);
+ if (!activeData.isEmpty()) {
+ PolicyVersion policy = (PolicyVersion) activeData.get(0);
+ JSONObject el = new JSONObject();
+ el.put(NAME, policy.getPolicyName().replace(File.separator, FORWARD_SLASH));
+ el.put(DATE, policy.getModifiedDate());
+ el.put(VERSION, policy.getActiveVersion());
+ el.put(SIZE, "");
+ el.put(TYPE, "file");
+ el.put(CREATED_BY, getUserName(policy.getCreatedBy()));
+ el.put(MODIFIED_BY, getUserName(policy.getModifiedBy()));
+ resultList.add(el);
+ }
+ }
+
+ private void addScope(Set<String> scopes, String scope) {
+ List<Object> scopesList = queryPolicyEditorScopes(scope);
+ if (!scopesList.isEmpty()) {
+ for (Object aScopesList : scopesList) {
+ PolicyEditorScopes tempScope = (PolicyEditorScopes) aScopesList;
+ scopes.add(tempScope.getScopeName());
+ }
+ }
+ }
+
+ // Switch Version Functionality
+ private JSONObject switchVersion(JSONObject params, HttpServletRequest request) throws ServletException {
+ String path = params.getString("path");
+ String userId = null;
+ try {
+ userId = UserUtils.getUserSession(request).getOrgUserId();
+ } catch (Exception e) {
+ LOGGER.error("Exception Occured while reading userid from cookie" + e);
+ }
+ String policyName;
+ String removeExtension = path.replace(".xml", "");
+ if (path.startsWith(FORWARD_SLASH)) {
+ policyName = removeExtension.substring(1, removeExtension.lastIndexOf('.'));
+ } else {
+ policyName = removeExtension.substring(0, removeExtension.lastIndexOf('.'));
+ }
+
+ String activePolicy;
+ PolicyController controller = getPolicyControllerInstance();
+ if (!params.toString().contains("activeVersion")) {
+ return controller.switchVersionPolicyContent(policyName);
+ }
+ String activeVersion = params.getString("activeVersion");
+ String highestVersion = params.get("highestVersion").toString();
+ if (Integer.parseInt(activeVersion) > Integer.parseInt(highestVersion)) {
+ return error("The Version shouldn't be greater than Highest Value");
+ }
+ activePolicy = policyName + "." + activeVersion + ".xml";
+ String[] splitDBCheckName = modifyPolicyName(activePolicy);
+ String peQuery = "FROM PolicyEntity where policyName = :splitDBCheckName_1 and scope = :splitDBCheckName_0";
+ SimpleBindings policyParams = new SimpleBindings();
+ policyParams.put("splitDBCheckName_1", splitDBCheckName[1]);
+ policyParams.put("splitDBCheckName_0", splitDBCheckName[0]);
+ List<Object> policyEntity = controller.getDataByQuery(peQuery, policyParams);
+ PolicyEntity pentity = (PolicyEntity) policyEntity.get(0);
+ if (pentity.isDeleted()) {
+ return error("The Policy is Not Existing in Workspace");
+ }
+ if (policyName.contains(FORWARD_SLASH)) {
+ policyName = policyName.replace(FORWARD_SLASH, File.separator);
+ }
+ policyName = policyName.substring(policyName.indexOf(File.separator) + 1);
+ if (policyName.contains(BACKSLASH)) {
+ policyName = policyName.replace(File.separator, BACKSLASH);
+ }
+ policyName = splitDBCheckName[0].replace(".", File.separator) + File.separator + policyName;
+ String watchPolicyName = policyName;
+ if (policyName.contains(FORWARD_SLASH)) {
+ policyName = policyName.replace(FORWARD_SLASH, File.separator);
+ }
+ if (policyName.contains(BACKSLASH)) {
+ policyName = policyName.replace(BACKSLASH, ESCAPE_BACKSLASH);
+ }
+ String query = UPDATE_POLICY_VERSION_SET_ACTIVE_VERSION + activeVersion + "' where policy_name ='" + policyName
+ + "' and id >0";
+ // query the database
+ controller.executeQuery(query);
+ // Policy Notification
+ PolicyVersion entity = new PolicyVersion();
+ entity.setPolicyName(watchPolicyName);
+ entity.setActiveVersion(Integer.parseInt(activeVersion));
+ entity.setModifiedBy(userId);
+ controller.watchPolicyFunction(entity, activePolicy, "SwitchVersion");
+ return success();
+ }
+
+ // Describe Policy
+ private JSONObject describePolicy(JSONObject params) throws ServletException {
+ JSONObject object;
+ String path = params.getString("path");
+ String policyName;
+ if (path.startsWith(FORWARD_SLASH)) {
+ path = path.substring(1);
+ policyName = path.substring(path.lastIndexOf('/') + 1);
+ path = path.replace(FORWARD_SLASH, ".");
+ } else {
+ path = path.replace(FORWARD_SLASH, ".");
+ policyName = path;
+ }
+ if (path.contains(CONFIG2)) {
+ path = path.replace(CONFIG, CONFIG1);
+ } else if (path.contains(ACTION2)) {
+ path = path.replace(ACTION, ACTION1);
+ } else if (path.contains(DECISION2)) {
+ path = path.replace(DECISION, DECISION1);
+ }
+ PolicyController controller = getPolicyControllerInstance();
+ String[] split = path.split(":");
+ String query = "FROM PolicyEntity where policyName = :split_1 and scope = :split_0";
+ SimpleBindings peParams = new SimpleBindings();
+ peParams.put(SPLIT_1, split[1]);
+ peParams.put(SPLIT_0, split[0]);
+ List<Object> queryData = getDataByQueryFromController(controller, query, peParams);
+ if (queryData.isEmpty()) {
+ return error("Error Occured while Describing the Policy - query is empty");
+ }
+ PolicyEntity entity = (PolicyEntity) queryData.get(0);
+ File temp;
+ try {
+ temp = File.createTempFile(policyName, ".tmp");
+ } catch (IOException e) {
+ String message = "Failed to create temp file " + policyName + ".tmp";
+ LOGGER.error(message + e);
+ return error(message);
+ }
+ try (BufferedWriter bw = new BufferedWriter(new FileWriter(temp))) {
+ bw.write(entity.getPolicyData());
+ } catch (IOException e) {
+ LOGGER.error("Exception Occured while Describing the Policy" + e);
+ }
+ object = HumanPolicyComponent.DescribePolicy(temp);
+ try {
+ Files.delete(temp.toPath());
+ } catch (IOException e) {
+ LOGGER.warn("Failed to delete " + temp.getName() + e);
+ }
+ return object;
+ }
+
+ // Get the List of Policies and Scopes for Showing in Editor tab
+ private JSONObject list(JSONObject params, HttpServletRequest request) throws ServletException {
+ try {
+ return processPolicyList(params, request);
+ } catch (Exception e) {
+ LOGGER.error("list", e);
+ return error(e.getMessage());
+ }
+ }
+
+ private JSONObject processPolicyList(JSONObject params, HttpServletRequest request) throws ServletException {
+ PolicyController controller = getPolicyControllerInstance();
+ // Get the Login Id of the User from Request
+ String testUserID = getTestUserId();
+ String userId = testUserID != null ? testUserID : UserUtils.getUserSession(request).getOrgUserId();
+ List<Object> userRoles = controller.getRoles(userId);
+ Pair<Set<String>, List<String>> pair = org.onap.policy.utils.UserUtils.checkRoleAndScope(userRoles);
+ List<String> roles = pair.u;
+ Set<String> scopes = pair.t;
+ Map<String, String> roleByScope = org.onap.policy.utils.UserUtils.getRoleByScope(userRoles);
+
+ List<JSONObject> resultList = new ArrayList<>();
+ String path = params.getString("path");
+ if (path.contains("..xml")) {
+ path = path.replaceAll("..xml", "").trim();
+ }
+
+ if (roles.contains(ADMIN) || roles.contains(EDITOR) || roles.contains(GUEST)) {
+ if (scopes.isEmpty()
+ && !(roles.contains(SUPERADMIN) || roles.contains(SUPEREDITOR) || roles.contains(SUPERGUEST))) {
+ return error("No Scopes has been Assigned to the User. Please, Contact Super-Admin");
+ } else {
+ if (!FORWARD_SLASH.equals(path)) {
+ String tempScope = path.substring(1);
+ tempScope = tempScope.replace(FORWARD_SLASH, File.separator);
+ scopes.add(tempScope);
+ }
+ }
+ }
+
+ if (!FORWARD_SLASH.equals(path)) {
+ try {
+ String scopeName = path.substring(path.indexOf('/') + 1);
+ activePolicyList(scopeName, resultList, roles, scopes, roleByScope);
+ } catch (Exception ex) {
+ LOGGER.error("Error Occurred While reading Policy Files List" + ex);
+ }
+ return new JSONObject().put(RESULT, resultList);
+ }
+ processRoles(scopes, roles, resultList, roleByScope);
+ return new JSONObject().put(RESULT, resultList);
+ }
+
+ private void processRoles(Set<String> scopes, List<String> roles, List<JSONObject> resultList,
+ Map<String, String> roleByScope) {
+ if (roles.contains(SUPERADMIN) || roles.contains(SUPEREDITOR) || roles.contains(SUPERGUEST)) {
+ List<Object> scopesList = queryPolicyEditorScopes(null);
+ scopesList.stream().map(list -> (PolicyEditorScopes) list).filter(
+ scope -> !(scope.getScopeName().contains(File.separator)) && !scopes.contains(scope.getScopeName()))
+ .forEach(scope -> {
+ JSONObject el = new JSONObject();
+ el.put(NAME, scope.getScopeName());
+ el.put(DATE, scope.getModifiedDate());
+ el.put(SIZE, "");
+ el.put(TYPE, "dir");
+ el.put(CREATED_BY, scope.getUserCreatedBy().getUserName());
+ el.put(MODIFIED_BY, scope.getUserModifiedBy().getUserName());
+ el.put(ROLETYPE, roleByScope.get(ALLSCOPES));
+ resultList.add(el);
+ });
+ }
+ if (roles.contains(ADMIN) || roles.contains(EDITOR) || roles.contains(GUEST)) {
+ scopes.stream().map(this::queryPolicyEditorScopes).filter(scopesList -> !scopesList.isEmpty())
+ .forEach(scopesList -> {
+ JSONObject el = new JSONObject();
+ PolicyEditorScopes scopeById = (PolicyEditorScopes) scopesList.get(0);
+ el.put(NAME, scopeById.getScopeName());
+ el.put(DATE, scopeById.getModifiedDate());
+ el.put(SIZE, "");
+ el.put(TYPE, "dir");
+ el.put(CREATED_BY, scopeById.getUserCreatedBy().getUserName());
+ el.put(MODIFIED_BY, scopeById.getUserModifiedBy().getUserName());
+ if ((resultList).stream()
+ .noneMatch(item -> item.get("name").equals(scopeById.getScopeName()))) {
+ el.put(ROLETYPE, roleByScope.get(scopeById.getScopeName()));
+ resultList.add(el);
+ }
+ });
+ }
+ }
+
+ private List<Object> queryPolicyEditorScopes(String scopeName) {
+ String scopeNameQuery;
+ SimpleBindings params = new SimpleBindings();
+ if (scopeName == null) {
+ scopeNameQuery = "from PolicyEditorScopes";
+ } else {
+ scopeNameQuery = FROM_POLICY_EDITOR_SCOPES_WHERE_SCOPENAME_LIKE_SCOPE_NAME;
+ params.put(SCOPE_NAME, scopeName + "%");
+ }
+ PolicyController controller = getPolicyControllerInstance();
+ return getDataByQueryFromController(controller, scopeNameQuery, params);
+ }
+
+ // Get Active Policy List based on Scope Selection from Policy Version table
+ private void activePolicyList(String inScopeName, List<JSONObject> resultList, List<String> roles,
+ Set<String> scopes, Map<String, String> roleByScope) {
+ PolicyController controller = getPolicyControllerInstance();
+ String scopeName = inScopeName;
+ if (scopeName.contains(FORWARD_SLASH)) {
+ scopeName = scopeName.replace(FORWARD_SLASH, File.separator);
+ }
+ if (scopeName.contains(BACKSLASH)) {
+ scopeName = scopeName.replace(BACKSLASH, ESCAPE_BACKSLASH);
+ }
+ String query = "from PolicyVersion where POLICY_NAME like :scopeName";
+
+ SimpleBindings params = new SimpleBindings();
+ params.put(SCOPE_NAME, scopeName + "%");
+
+ List<Object> activePolicies = getDataByQueryFromController(controller, query, params);
+ List<Object> scopesList = getDataByQueryFromController(controller,
+ FROM_POLICY_EDITOR_SCOPES_WHERE_SCOPENAME_LIKE_SCOPE_NAME, params);
+ for (Object list : scopesList) {
+ scopeName = checkScope(resultList, scopeName, (PolicyEditorScopes) list, roleByScope);
+ }
+ for (Object list : activePolicies) {
+ PolicyVersion policy = (PolicyVersion) list;
+ String scopeNameValue =
+ policy.getPolicyName().substring(0, policy.getPolicyName().lastIndexOf(File.separator));
+ if (roles.contains(SUPERADMIN) || roles.contains(SUPEREDITOR) || roles.contains(SUPERGUEST)) {
+ String scopeNameCheck =
+ scopeName.contains(ESCAPE_BACKSLASH) ? scopeName.replace(ESCAPE_BACKSLASH, File.separator)
+ : scopeName;
+ if (!scopeNameValue.equals(scopeNameCheck)) {
+ continue;
+ }
+ JSONObject el = new JSONObject();
+ el.put(NAME, policy.getPolicyName().substring(policy.getPolicyName().lastIndexOf(File.separator) + 1));
+ el.put(DATE, policy.getModifiedDate());
+ el.put(VERSION, policy.getActiveVersion());
+ el.put(SIZE, "");
+ el.put(TYPE, "file");
+ el.put(CREATED_BY, getUserName(policy.getCreatedBy()));
+ el.put(MODIFIED_BY, getUserName(policy.getModifiedBy()));
+ String roleType = Strings.isNullOrEmpty(roleByScope.get(scopeNameValue)) ? roleByScope.get(ALLSCOPES)
+ : roleByScope.get(scopeNameValue);
+ el.put(ROLETYPE, roleType);
+ resultList.add(el);
+ } else if (!scopes.isEmpty() && scopes.contains(scopeNameValue)) {
+ JSONObject el = new JSONObject();
+ el.put(NAME, policy.getPolicyName().substring(policy.getPolicyName().lastIndexOf(File.separator) + 1));
+ el.put(DATE, policy.getModifiedDate());
+ el.put(VERSION, policy.getActiveVersion());
+ el.put(SIZE, "");
+ el.put(TYPE, "file");
+ el.put(CREATED_BY, getUserName(policy.getCreatedBy()));
+ el.put(MODIFIED_BY, getUserName(policy.getModifiedBy()));
+ resultList.add(el);
+ }
+ }
+ }
+
+ private List<Object> getDataByQueryFromController(final PolicyController controller, final String query,
+ final SimpleBindings params) {
+ final List<Object> activePolicies;
+ if (PolicyController.isjUnit()) {
+ activePolicies = controller.getDataByQuery(query, null);
+ } else {
+ activePolicies = controller.getDataByQuery(query, params);
+ }
+ return activePolicies;
+ }
+
+ private String checkScope(List<JSONObject> resultList, String scopeName, PolicyEditorScopes scopeById,
+ Map<String, String> roleByScope) {
+ String scope = scopeById.getScopeName();
+ if (!scope.contains(File.separator)) {
+ return scopeName;
+ }
+ String targetScope = scope.substring(0, scope.lastIndexOf(File.separator));
+ if (scopeName.contains(ESCAPE_BACKSLASH)) {
+ scopeName = scopeName.replace(ESCAPE_BACKSLASH, File.separator);
+ }
+ if (scope.contains(File.separator)) {
+ scope = scope.substring(targetScope.length() + 1);
+ if (scope.contains(File.separator)) {
+ scope = scope.substring(0, scope.indexOf(File.separator));
+ }
+ }
+ if (scopeName.equalsIgnoreCase(targetScope)) {
+ JSONObject el = new JSONObject();
+ el.put(NAME, scope);
+ el.put(DATE, scopeById.getModifiedDate());
+ el.put(SIZE, "");
+ el.put(TYPE, "dir");
+ el.put(CREATED_BY, scopeById.getUserCreatedBy().getUserName());
+ el.put(MODIFIED_BY, scopeById.getUserModifiedBy().getUserName());
+ String roleType = roleByScope.get(ALLSCOPES); // Set default role type to ALL_SCOPES
+ if (!Strings.isNullOrEmpty(roleByScope.get(scopeName))) {
+ roleType = roleByScope.get(scopeName);
+ } else if (!Strings.isNullOrEmpty(roleByScope.get(scopeName + File.separator + scope))) {
+ roleType = roleByScope.get(scopeName + File.separator + scope);
+ }
+ el.put(ROLETYPE, roleType);
+ resultList.add(el);
+ }
+ return scopeName;
+ }
+
+ private String getUserName(String loginId) {
+ PolicyController controller = getPolicyControllerInstance();
+ UserInfo userInfo = (UserInfo) controller.getEntityItem(UserInfo.class, "userLoginId", loginId);
+ if (userInfo == null) {
+ return SUPERADMIN;
+ }
+ return userInfo.getUserName();
+ }
+
+ // Rename Policy
+ private JSONObject rename(JSONObject params, HttpServletRequest request) throws ServletException {
+ try {
+ return handlePolicyRename(params, request);
+ } catch (Exception e) {
+ LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Exception Occured While Renaming Policy" + e);
+ return error(e.getMessage());
+ }
+ }
+
+ private JSONObject handlePolicyRename(JSONObject params, HttpServletRequest request) throws ServletException {
+ boolean isActive = false;
+ List<String> policyActiveInPDP = new ArrayList<>();
+ Set<String> scopeOfPolicyActiveInPDP = new HashSet<>();
+ String userId = UserUtils.getUserSession(request).getOrgUserId();
+ String oldPath = params.getString("path");
+ String newPath = params.getString("newPath");
+ oldPath = oldPath.substring(oldPath.indexOf('/') + 1);
+ newPath = newPath.substring(newPath.indexOf('/') + 1);
+ String checkValidation;
+ if (oldPath.endsWith(".xml")) {
+ checkValidation = newPath.replace(".xml", "");
+ checkValidation =
+ checkValidation.substring(checkValidation.indexOf('_') + 1, checkValidation.lastIndexOf('.'));
+ checkValidation = checkValidation.substring(checkValidation.lastIndexOf(FORWARD_SLASH) + 1);
+ if (!PolicyUtils.policySpecialCharValidator(checkValidation).contains(SUCCESS)) {
+ return error("Policy Rename Failed. The Name contains special characters.");
+ }
+ JSONObject result = policyRename(oldPath, newPath, userId);
+ if (!(Boolean) (result.getJSONObject(RESULT).get(SUCCESS))) {
+ return result;
+ }
+ } else {
+ String scopeName = oldPath;
+ String newScopeName = newPath;
+ if (scopeName.contains(FORWARD_SLASH)) {
+ scopeName = scopeName.replace(FORWARD_SLASH, File.separator);
+ newScopeName = newScopeName.replace(FORWARD_SLASH, File.separator);
+ }
+ checkValidation = newScopeName.substring(newScopeName.lastIndexOf(File.separator) + 1);
+ if (scopeName.contains(BACKSLASH)) {
+ scopeName = scopeName.replace(BACKSLASH, BACKSLASH_8TIMES);
+ newScopeName = newScopeName.replace(BACKSLASH, BACKSLASH_8TIMES);
+ }
+ if (!PolicyUtils.policySpecialCharValidator(checkValidation).contains(SUCCESS)) {
+ return error("Scope Rename Failed. The Name contains special characters.");
+ }
+ PolicyController controller = getPolicyControllerInstance();
+ String query = "from PolicyVersion where POLICY_NAME like :scopeName";
+ SimpleBindings pvParams = new SimpleBindings();
+ pvParams.put(SCOPE_NAME, scopeName + "%");
+ List<Object> activePolicies = controller.getDataByQuery(query, pvParams);
+ List<Object> scopesList =
+ controller.getDataByQuery(FROM_POLICY_EDITOR_SCOPES_WHERE_SCOPENAME_LIKE_SCOPE_NAME, pvParams);
+ for (Object object : activePolicies) {
+ PolicyVersion activeVersion = (PolicyVersion) object;
+ String policyOldPath = activeVersion.getPolicyName().replace(File.separator, FORWARD_SLASH) + "."
+ + activeVersion.getActiveVersion() + ".xml";
+ String policyNewPath = policyOldPath.replace(oldPath, newPath);
+ JSONObject result = policyRename(policyOldPath, policyNewPath, userId);
+ if (!(Boolean) (result.getJSONObject("result").get(SUCCESS))) {
+ isActive = true;
+ policyActiveInPDP.add(policyOldPath);
+ String scope = policyOldPath.substring(0, policyOldPath.lastIndexOf('/'));
+ scopeOfPolicyActiveInPDP.add(scope.replace(FORWARD_SLASH, File.separator));
+ }
+ }
+ boolean rename = activePolicies.size() != policyActiveInPDP.size();
+ if (policyActiveInPDP.isEmpty()) {
+ renameScope(scopesList, scopeName, newScopeName, controller);
+ } else if (rename) {
+ renameScope(scopesList, scopeName, newScopeName, controller);
+ UserInfo userInfo = new UserInfo();
+ userInfo.setUserLoginId(userId);
+ scopeOfPolicyActiveInPDP.forEach(scope -> {
+ PolicyEditorScopes editorScopeEntity = new PolicyEditorScopes();
+ editorScopeEntity.setScopeName(scope.replace(BACKSLASH, BACKSLASH_8TIMES));
+ editorScopeEntity.setUserCreatedBy(userInfo);
+ editorScopeEntity.setUserModifiedBy(userInfo);
+ controller.saveData(editorScopeEntity);
+ });
+ }
+ if (isActive) {
+ return error("The Following policies rename failed. Since they are active in PDP Groups"
+ + policyActiveInPDP);
+ }
+ }
+ return success();
+ }
+
+ private void renameScope(List<Object> scopesList, String inScopeName, String newScopeName,
+ PolicyController controller) {
+ for (Object object : scopesList) {
+ PolicyEditorScopes editorScopeEntity = (PolicyEditorScopes) object;
+ String scopeName = inScopeName;
+ if (scopeName.contains(BACKSLASH_8TIMES)) {
+ scopeName = scopeName.replace(BACKSLASH_8TIMES, File.separator);
+ newScopeName = newScopeName.replace(BACKSLASH_8TIMES, File.separator);
+ }
+ String scope = editorScopeEntity.getScopeName().replace(scopeName, newScopeName);
+ editorScopeEntity.setScopeName(scope);
+ controller.updateData(editorScopeEntity);
+ }
+ }
+
+ private JSONObject policyRename(String oldPath, String newPath, String userId) throws ServletException {
+ try {
+ PolicyEntity entity;
+ PolicyController controller = getPolicyControllerInstance();
+
+ String policyVersionName = newPath.replace(".xml", "");
+ String policyName = policyVersionName.substring(0, policyVersionName.lastIndexOf('.'))
+ .replace(FORWARD_SLASH, File.separator);
+
+ String oldpolicyVersionName = oldPath.replace(".xml", "");
+ String oldpolicyName = oldpolicyVersionName.substring(0, oldpolicyVersionName.lastIndexOf('.'))
+ .replace(FORWARD_SLASH, File.separator);
+ String newpolicyName = newPath.replace("/", ".");
+ String[] newPolicySplit = modifyPolicyName(newPath);
+
+ String[] oldPolicySplit = modifyPolicyName(oldPath);
+
+ // Check PolicyEntity table with newPolicy Name
+ String policyEntityquery =
+ "FROM PolicyEntity where policyName = :newPolicySplit_1 and scope = :newPolicySplit_0";
+ SimpleBindings policyParams = new SimpleBindings();
+ policyParams.put("newPolicySplit_1", newPolicySplit[1]);
+ policyParams.put("newPolicySplit_0", newPolicySplit[0]);
+ List<Object> queryData = controller.getDataByQuery(policyEntityquery, policyParams);
+ if (!queryData.isEmpty()) {
+ return error("Policy rename failed. Since, the policy with same name already exists.");
+ }