+@WebServlet(
+ value = "/fm/*",
+ loadOnStartup = 1,
+ initParams = {@WebInitParam(
+ name = "XACML_PROPERTIES_NAME",
+ value = "xacml.admin.properties",
+ description = "The location of the properties file holding configuration information.")})
+public class PolicyManagerServlet extends HttpServlet {
+ private static final Logger LOGGER = FlexLogger.getLogger(PolicyManagerServlet.class);
+ private static final long serialVersionUID = -8453502699403909016L;
+ private static final String VERSION = "version";
+ private static final String NAME = "name";
+ private static final String DATE = "date";
+ private static final String SIZE = "size";
+ private static final String TYPE = "type";
+ private static final String ROLETYPE = "roleType";
+ private static final String CREATED_BY = "createdBy";
+ private static final String MODIFIED_BY = "modifiedBy";
+ private static final String CONTENTTYPE = "application/json";
+ private static final String SUPERADMIN = "super-admin";
+ private static final String SUPEREDITOR = "super-editor";
+ private static final String SUPERGUEST = "super-guest";
+ private static final String ADMIN = "admin";
+ private static final String EDITOR = "editor";
+ private static final String GUEST = "guest";
+ private static final String RESULT = "result";
+ private static final String DELETE = "delete";
+ private static final String EXCEPTION_OCCURED = "Exception Occured";
+ private static final String CONFIG = ".Config_";
+ private static final String CONFIG1 = ":Config_";
+ private static final String ACTION = ".Action_";
+ private static final String ACTION1 = ":Action_";
+ private static final String DECISION = ".Decision_";
+ private static final String DECISION1 = ":Decision_";
+ private static final String CONFIG2 = "Config_";
+ private static final String ACTION2 = "Action_";
+ private static final String DECISION2 = "Decision_";
+ private static final String FORWARD_SLASH = "/";
+ private static final String BACKSLASH = "\\";
+ private static final String ESCAPE_BACKSLASH = "\\\\";
+ private static final String BACKSLASH_8TIMES = "\\\\\\\\";
+ private static final String DELETE_POLICY_VERSION_WHERE_POLICY_NAME =
+ "delete from PolicyVersion where policy_name ='";
+ private static final String UPDATE_POLICY_VERSION_SET_ACTIVE_VERSION = "update PolicyVersion set active_version='";
+ private static final String SPLIT_1 = "split_1";
+ private static final String SPLIT_0 = "split_0";
+ private static final String FROM_POLICY_EDITOR_SCOPES_WHERE_SCOPENAME_LIKE_SCOPE_NAME =
+ "from PolicyEditorScopes where SCOPENAME like :scopeName";
+ private static final String SCOPE_NAME = "scopeName";
+ private static final String SUCCESS = "success";
+ private static final String SUB_SCOPENAME = "subScopename";
+ private static final String ALLSCOPES = "@All@";
+ private static final String PERCENT_AND_ID_GT_0 = "%' and id >0";
+ private static List<String> serviceTypeNamesList = new ArrayList<>();
+ private static JsonArray policyNames;
+ private static String testUserId = null;
+
+ private enum Mode {
+ LIST,
+ RENAME,
+ COPY,
+ DELETE,
+ EDITFILE,
+ ADDFOLDER,
+ DESCRIBEPOLICYFILE,
+ VIEWPOLICY,
+ ADDSUBSCOPE,
+ SWITCHVERSION,
+ EXPORT,
+ SEARCHLIST
+ }
+
+ private static PolicyController policyController;
+
+ private synchronized PolicyController getPolicyController() {
+ return policyController;
+ }
+
+ public static synchronized void setPolicyController(PolicyController policyController) {
+ PolicyManagerServlet.policyController = policyController;
+ }
+
+ public static JsonArray getPolicyNames() {
+ return policyNames;
+ }
+
+ public static void setPolicyNames(JsonArray policyNames) {
+ PolicyManagerServlet.policyNames = policyNames;
+ }
+
+ public static List<String> getServiceTypeNamesList() {
+ return serviceTypeNamesList;
+ }
+
+ @Override
+ public void init(ServletConfig servletConfig) throws ServletException {
+ super.init(servletConfig);
+ //
+ // Common initialization
+ //
+ XacmlRest.xacmlInit(servletConfig);
+ // init aes key from prop or env
+ PeCryptoUtils.initAesKey(XACMLProperties.getProperty(XacmlRestProperties.PROP_AES_KEY));
+ //
+ // Initialize ClosedLoop JSON
+ //
+ PolicyManagerServlet.initializeJsonLoad();
+ }
+
+ private static void initializeJsonLoad() {
+ Path closedLoopJsonLocation = Paths.get(XACMLProperties.getProperty(XacmlRestProperties.PROP_ADMIN_CLOSEDLOOP));
+ String location = closedLoopJsonLocation.toString();
+ if (!location.endsWith("json")) {
+ LOGGER.warn("JSONConfig file does not end with extension .json");
+ return;
+ }
+ try (FileInputStream inputStream = new FileInputStream(location);
+ JsonReader jsonReader = Json.createReader(inputStream)) {
+ policyNames = jsonReader.readArray();
+ serviceTypeNamesList = new ArrayList<>();
+ for (int i = 0; i < policyNames.size(); i++) {
+ javax.json.JsonObject policyName = policyNames.getJsonObject(i);
+ String name = policyName.getJsonString("serviceTypePolicyName").getString();
+ serviceTypeNamesList.add(name);
+ }
+ } catch (IOException e) {
+ LOGGER.error("Exception Occured while initializing the JSONConfig file" + e);
+ }
+ }
+
+ @Override
+ protected void doPost(HttpServletRequest request, HttpServletResponse response) {
+ LOGGER.debug("doPost");
+ try {
+ // if request contains multipart-form-data
+ if (ServletFileUpload.isMultipartContent(request)) {
+ uploadFile(request, response);
+ }
+ // all other post request has json params in body
+ else {
+ fileOperation(request, response);
+ }
+ } catch (Exception e) {
+ try {
+ setError(e, response);
+ } catch (Exception e1) {
+ LOGGER.error(EXCEPTION_OCCURED + e1);
+ }
+ }
+ }
+
+ // Set Error Message for Exception
+ private void setError(Exception exception, HttpServletResponse response) throws IOException {
+ try {
+ JSONObject responseJsonObject = error(exception.getMessage());
+ response.setContentType(CONTENTTYPE);
+ PrintWriter out = response.getWriter();
+ out.print(responseJsonObject);
+ out.flush();
+ } catch (Exception x) {
+ LOGGER.error(EXCEPTION_OCCURED + x);
+ response.sendError(HttpStatus.SC_INTERNAL_SERVER_ERROR, x.getMessage());
+ }
+ }
+
+ // Policy Import Functionality
+ private void uploadFile(HttpServletRequest request, HttpServletResponse response) throws ServletException {
+ try {
+ Map<String, InputStream> files = new HashMap<>();
+
+ List<FileItem> items = new ServletFileUpload(new DiskFileItemFactory()).parseRequest(request);
+ for (FileItem item : items) {
+ if (!item.isFormField()) {
+ // Process form file field (input type="file").
+ files.put(item.getName(), item.getInputStream());
+ processFormFile(request, item);
+ }
+ }
+
+ 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 jsonObject = new JSONObject(sb.toString());
+ JSONObject params = jsonObject.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) {
+ JSONArray policyList = null;
+ if (params.has("policyList")) {
+ policyList = (JSONArray) params.get("policyList");
+ }
+ PolicyController controller = getPolicyControllerInstance();
+ List<JSONObject> resultList = new ArrayList<>();
+ try {
+ if (!lookupPolicyData(request, new ArrayList<>(), 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) {
+ 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);
+ List<String> roles = pair.second;
+ Set<String> scopes = pair.first;
+ 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 data : policyData) {
+ PolicyVersion policy = (PolicyVersion) data;
+ 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 scopeItem : scopesList) {
+ PolicyEditorScopes tempScope = (PolicyEditorScopes) scopeItem;
+ 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;
+ final 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 {
+ 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);
+ }
+ 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(getPolicyControllerInstance(), 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);
+ }
+ JSONObject 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 {
+ // Get the Login Id of the User from Request
+ String testUserID = getTestUserId();
+ String userId = testUserID != null ? testUserID : UserUtils.getUserSession(request).getOrgUserId();
+ List<Object> userRoles = getPolicyControllerInstance().getRoles(userId);
+ Pair<Set<String>, List<String>> pair = org.onap.policy.utils.UserUtils.checkRoleAndScope(userRoles);
+ List<String> roles = pair.second;
+ Set<String> scopes = pair.first;
+ 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) {
+ 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(getPolicyControllerInstance(), query, params);
+ List<Object> scopesList = getDataByQueryFromController(getPolicyControllerInstance(),
+ 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) {
+ UserInfo userInfo = (UserInfo) getPolicyControllerInstance().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);
+
+ final 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.");
+ }