/**
* getEncoding reads in the PDP properties and returns an encoding
* for the given pdp.
- *
+ *
* @param pdpID Input PDP Id
* @return String encoding
*/
private static final Logger LOGGER = FlexLogger.getLogger(PolicyAdapter.class);
+ /**
+ * configure.
+ *
+ * @param policyAdapter PolicyRestAdapter object
+ * @param entity PolicyEntity object
+ */
public void configure(PolicyRestAdapter policyAdapter, PolicyEntity entity) {
String policyNameValue = policyAdapter.getPolicyName().substring(0, policyAdapter.getPolicyName().indexOf('_'));
String configPolicyName = getConfigPolicyName(policyAdapter);
}
}
+ /**
+ * getInstance.
+ *
+ * @return Returns a PolicyAdapter instance
+ */
public static PolicyAdapter getInstance() {
try {
Class<?> policyAdapter = Class.forName(
private static String testUserId = null;
private enum Mode {
- LIST, RENAME, COPY, DELETE, EDITFILE, ADDFOLDER, DESCRIBEPOLICYFILE, VIEWPOLICY, ADDSUBSCOPE, SWITCHVERSION, EXPORT, SEARCHLIST
+ LIST,
+ RENAME,
+ COPY,
+ DELETE,
+ EDITFILE,
+ ADDFOLDER,
+ DESCRIBEPOLICYFILE,
+ VIEWPOLICY,
+ ADDSUBSCOPE,
+ SWITCHVERSION,
+ EXPORT,
+ SEARCHLIST
}
private static PolicyController policyController;
//
// Initialize ClosedLoop JSON
//
- PolicyManagerServlet.initializeJSONLoad();
+ PolicyManagerServlet.initializeJsonLoad();
}
- private static void initializeJSONLoad() {
+ private static void initializeJsonLoad() {
Path closedLoopJsonLocation = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_ADMIN_CLOSEDLOOP));
String location = closedLoopJsonLocation.toString();
if (!location.endsWith("json")) {
}
// Set Error Message for Exception
- private void setError(Exception t, HttpServletResponse response) throws IOException {
+ private void setError(Exception exception, HttpServletResponse response) throws IOException {
try {
- JSONObject responseJsonObject = error(t.getMessage());
+ JSONObject responseJsonObject = error(exception.getMessage());
response.setContentType(CONTENTTYPE);
PrintWriter out = response.getWriter();
out.print(responseJsonObject);
return;
}
try {
- JSONObject jObj = new JSONObject(sb.toString());
- JSONObject params = jObj.getJSONObject("params");
+ 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*******************************************");
+ "********************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);
PolicyController controller = getPolicyControllerInstance();
List<JSONObject> resultList = new ArrayList<>();
try {
- if (!lookupPolicyData(request, policyData, policyList, controller, resultList))
+ 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);
parsePolicyList(resultList, controller, policyName, version);
}
} else {
- getPolicyDataForSUPERRoles(policyData, controller, resultList, roles, scopes);
+ getPolicyDataForSuperRoles(policyData, controller, resultList, roles, scopes);
}
return true;
}
- private void getPolicyDataForSUPERRoles(List<Object> policyData, PolicyController controller,
+ 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);
}
private void updateResultList(List<Object> policyData, List<JSONObject> resultList) {
- for (Object aPolicyData : policyData) {
- PolicyVersion policy = (PolicyVersion) aPolicyData;
+ 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());
private void addScope(Set<String> scopes, String scope) {
List<Object> scopesList = queryPolicyEditorScopes(scope);
if (!scopesList.isEmpty()) {
- for (Object aScopesList : scopesList) {
- PolicyEditorScopes tempScope = (PolicyEditorScopes) aScopesList;
+ for (Object scopeItem : scopesList) {
+ PolicyEditorScopes tempScope = (PolicyEditorScopes) scopeItem;
scopes.add(tempScope.getScopeName());
}
}
return error("The Version shouldn't be greater than Highest Value");
}
activePolicy = policyName + "." + activeVersion + ".xml";
- String[] splitDBCheckName = modifyPolicyName(activePolicy);
+ 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]);
+ 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()) {
if (policyName.contains(BACKSLASH)) {
policyName = policyName.replace(File.separator, BACKSLASH);
}
- policyName = splitDBCheckName[0].replace(".", File.separator) + File.separator + policyName;
- String watchPolicyName = policyName;
+ 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);
}
// Describe Policy
private JSONObject describePolicy(JSONObject params) throws ServletException {
- JSONObject object;
String path = params.getString("path");
String policyName;
if (path.startsWith(FORWARD_SLASH)) {
} catch (IOException e) {
LOGGER.error("Exception Occured while Describing the Policy" + e);
}
- object = HumanPolicyComponent.DescribePolicy(temp);
+ JSONObject object = HumanPolicyComponent.DescribePolicy(temp);
try {
Files.delete(temp.toPath());
} catch (IOException e) {
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()))
+ scope -> !(scope.getScopeName().contains(File.separator)) && !scopes.contains(scope.getScopeName()))
.forEach(scope -> {
JSONObject el = new JSONObject();
el.put(NAME, scope.getScopeName());
// 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();
+ final PolicyController controller = getPolicyControllerInstance();
String scopeName = inScopeName;
if (scopeName.contains(FORWARD_SLASH)) {
scopeName = scopeName.replace(FORWARD_SLASH, File.separator);
private JSONObject handlePolicyRename(JSONObject params, HttpServletRequest request) throws ServletException {
boolean isActive = false;
- List<String> policyActiveInPDP = new ArrayList<>();
- Set<String> scopeOfPolicyActiveInPDP = new HashSet<>();
+ 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");
JSONObject result = policyRename(policyOldPath, policyNewPath, userId);
if (!(Boolean) (result.getJSONObject("result").get(SUCCESS))) {
isActive = true;
- policyActiveInPDP.add(policyOldPath);
+ policyActiveInPdp.add(policyOldPath);
String scope = policyOldPath.substring(0, policyOldPath.lastIndexOf('/'));
- scopeOfPolicyActiveInPDP.add(scope.replace(FORWARD_SLASH, File.separator));
+ scopeOfPolicyActiveInPdp.add(scope.replace(FORWARD_SLASH, File.separator));
}
}
- boolean rename = activePolicies.size() != policyActiveInPDP.size();
- if (policyActiveInPDP.isEmpty()) {
+ 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 -> {
+ scopeOfPolicyActiveInPdp.forEach(scope -> {
PolicyEditorScopes editorScopeEntity = new PolicyEditorScopes();
editorScopeEntity.setScopeName(scope.replace(BACKSLASH, BACKSLASH_8TIMES));
editorScopeEntity.setUserCreatedBy(userInfo);
}
if (isActive) {
return error("The Following policies rename failed. Since they are active in PDP Groups"
- + policyActiveInPDP);
+ + policyActiveInPdp);
}
}
return success();
String newpolicyName = newPath.replace("/", ".");
String[] newPolicySplit = modifyPolicyName(newPath);
- String[] oldPolicySplit = modifyPolicyName(oldPath);
+ final String[] oldPolicySplit = modifyPolicyName(oldPath);
// Check PolicyEntity table with newPolicy Name
String policyEntityquery =
List<Object> oldEntityData = controller.getDataByQuery(oldPolicyEntityQuery, params);
if (oldEntityData.isEmpty()) {
return error(
- "Policy rename failed due to policy not able to retrieve from database. Please, contact super-admin.");
+ "Policy rename failed due to policy not able to retrieve from database. Contact super-admin.");
}
StringBuilder groupQuery = new StringBuilder();
controller.updateData(entity);
PolicyRestController restController = new PolicyRestController();
- restController.notifyOtherPAPSToUpdateConfigurations("rename", newConfigurationName, oldConfigurationName);
+ restController.notifyOtherPapsToUpdateConfigurations("rename", newConfigurationName, oldConfigurationName);
PolicyVersion versionEntity =
(PolicyVersion) controller.getEntityItem(PolicyVersion.class, "policyName", oldPolicyName);
versionEntity.setPolicyName(policyName);
// Notify others paps regarding clone policy.
PolicyRestController restController = new PolicyRestController();
- restController.notifyOtherPAPSToUpdateConfigurations("clonePolicy", newConfigurationName, null);
+ restController.notifyOtherPapsToUpdateConfigurations("clonePolicy", newConfigurationName, null);
}
// Clone the Policy
String newPolicyName = newPath.replace(FORWARD_SLASH, ".");
- String originalPolicyName = oldPath.replace(FORWARD_SLASH, ".");
-
String newPolicyCheck = newPolicyName;
if (newPolicyCheck.contains(CONFIG2)) {
newPolicyCheck = newPolicyCheck.replace(CONFIG, CONFIG1);
return error("Policy Clone Failed. The Name contains special characters.");
}
- String[] oldPolicySplit = modifyPolicyName(originalPolicyName);
+ String originalPolicyName = oldPath.replace(FORWARD_SLASH, ".");
+
+ final String[] oldPolicySplit = modifyPolicyName(originalPolicyName);
PolicyController controller = getPolicyControllerInstance();
controller.watchPolicyFunction(versionEntity, policyNamewithExtension, "DeleteAll");
if (pdpCheck) {
// Delete from policyVersion table
- String getActivePDPPolicyVersion = activePolicyName.replace(".xml", "");
- getActivePDPPolicyVersion =
- getActivePDPPolicyVersion.substring(getActivePDPPolicyVersion.lastIndexOf('.') + 1);
- String policyVersionQuery = UPDATE_POLICY_VERSION_SET_ACTIVE_VERSION + getActivePDPPolicyVersion
- + "' , highest_version='" + getActivePDPPolicyVersion + "' where policy_name ='"
+ String getActivePdpPolicyVersion = activePolicyName.replace(".xml", "");
+ getActivePdpPolicyVersion =
+ getActivePdpPolicyVersion.substring(getActivePdpPolicyVersion.lastIndexOf('.') + 1);
+ String policyVersionQuery = UPDATE_POLICY_VERSION_SET_ACTIVE_VERSION + getActivePdpPolicyVersion
+ + "' , highest_version='" + getActivePdpPolicyVersion + "' where policy_name ='"
+ policyNamewithoutExtension.replace(BACKSLASH, ESCAPE_BACKSLASH) + "' and id >0";
controller.executeQuery(policyVersionQuery);
return error(
- "Policies with Same name has been deleted. Except the Active Policy in PDP. PolicyName: "
+ "Policies with Same name has been deleted. Except the Active Policy in PDP. PolicyName: "
+ activePolicyName);
} else {
// No Active Policy in PDP. So, deleting all entries from policyVersion table
String currentVersionScope =
policyNamewithExtension.substring(0, policyNamewithExtension.lastIndexOf(File.separator))
.replace(File.separator, ".");
- query = "FROM PolicyEntity where policyName = :currentVersionPolicyName and scope = :currentVersionScope";
+ query = "FROM PolicyEntity where policyName = :currentVersionPolicyName and "
+ + "scope = :currentVersionScope";
SimpleBindings peParams = new SimpleBindings();
peParams.put("currentVersionPolicyName", currentVersionPolicyName);
}
}
} else {
- List<String> activePoliciesInPDP = new ArrayList<>();
+ List<String> activePoliciesInPdp = new ArrayList<>();
if (policyEntityObjects.isEmpty()) {
String policyScopeQuery = "delete PolicyEditorScopes where SCOPENAME like '"
+ path.replace(BACKSLASH, ESCAPE_BACKSLASH) + PERCENT_AND_ID_GT_0;
List<Object> groupobject = controller.getDataByQuery(groupEntityQuery, geParams);
if (!groupobject.isEmpty()) {
pdpCheck = true;
- activePoliciesInPDP.add(policyEntity.getScope() + "." + policyEntity.getPolicyName());
+ activePoliciesInPdp.add(policyEntity.getScope() + "." + policyEntity.getPolicyName());
} else {
// Delete the entity from Elastic Search Database
String searchFileName = policyEntity.getScope() + "." + policyEntity.getPolicyName();
Files.deleteIfExists(Paths.get(PolicyController.getConfigHome() + File.separator
+ policyEntity.getConfigurationData().getConfigurationName()));
controller.deleteData(policyEntity.getConfigurationData());
- restController.notifyOtherPAPSToUpdateConfigurations(DELETE, null,
+ restController.notifyOtherPapsToUpdateConfigurations(DELETE, null,
policyEntity.getConfigurationData().getConfigurationName());
} else if (policyNamewithoutExtension.contains(ACTION2)) {
Files.deleteIfExists(Paths.get(PolicyController.getActionHome() + File.separator
+ policyEntity.getActionBodyEntity().getActionBodyName()));
controller.deleteData(policyEntity.getActionBodyEntity());
- restController.notifyOtherPAPSToUpdateConfigurations(DELETE, null,
+ restController.notifyOtherPapsToUpdateConfigurations(DELETE, null,
policyEntity.getActionBodyEntity().getActionBodyName());
}
}
controller.watchPolicyFunction(entity, path, "DeleteScope");
if (pdpCheck) {
// Add Active Policies List to PolicyVersionTable
- for (String anActivePoliciesInPDP : activePoliciesInPDP) {
- String activePDPPolicyName = anActivePoliciesInPDP.replace(".xml", "");
- int activePDPPolicyVersion = Integer
- .parseInt(activePDPPolicyName.substring(activePDPPolicyName.lastIndexOf('.') + 1));
- activePDPPolicyName = activePDPPolicyName.substring(0, activePDPPolicyName.lastIndexOf('.'))
+ for (String anActivePoliciesInPdp : activePoliciesInPdp) {
+ String activePdpPolicyName = anActivePoliciesInPdp.replace(".xml", "");
+ int activePdpPolicyVersion = Integer
+ .parseInt(activePdpPolicyName.substring(activePdpPolicyName.lastIndexOf('.') + 1));
+ activePdpPolicyName = activePdpPolicyName.substring(0, activePdpPolicyName.lastIndexOf('.'))
.replace(".", File.separator);
- PolicyVersion insertActivePDPVersion = new PolicyVersion();
- insertActivePDPVersion.setPolicyName(activePDPPolicyName);
- insertActivePDPVersion.setHigherVersion(activePDPPolicyVersion);
- insertActivePDPVersion.setActiveVersion(activePDPPolicyVersion);
- insertActivePDPVersion.setCreatedBy(userId);
- insertActivePDPVersion.setModifiedBy(userId);
- controller.saveData(insertActivePDPVersion);
+ PolicyVersion insertActivePdpVersion = new PolicyVersion();
+ insertActivePdpVersion.setPolicyName(activePdpPolicyName);
+ insertActivePdpVersion.setHigherVersion(activePdpPolicyVersion);
+ insertActivePdpVersion.setActiveVersion(activePdpPolicyVersion);
+ insertActivePdpVersion.setCreatedBy(userId);
+ insertActivePdpVersion.setModifiedBy(userId);
+ controller.saveData(insertActivePdpVersion);
}
return error("All the Policies has been deleted in Scope. Except the following list of Policies:"
- + activePoliciesInPDP);
+ + activePoliciesInPdp);
} else {
String policyScopeQuery = "delete PolicyEditorScopes where SCOPENAME like '"
+ path.replace(BACKSLASH, ESCAPE_BACKSLASH) + PERCENT_AND_ID_GT_0;
Files.deleteIfExists(Paths.get(PolicyController.getConfigHome() + File.separator
+ policyEntity.getConfigurationData().getConfigurationName()));
controller.deleteData(policyEntity.getConfigurationData());
- restController.notifyOtherPAPSToUpdateConfigurations(DELETE, null,
+ restController.notifyOtherPapsToUpdateConfigurations(DELETE, null,
policyEntity.getConfigurationData().getConfigurationName());
} else if (policyNamewithoutExtension.contains(ACTION2)) {
Files.deleteIfExists(Paths.get(PolicyController.getActionHome() + File.separator
+ policyEntity.getActionBodyEntity().getActionBodyName()));
controller.deleteData(policyEntity.getActionBodyEntity());
- restController.notifyOtherPAPSToUpdateConfigurations(DELETE, null,
+ restController.notifyOtherPapsToUpdateConfigurations(DELETE, null,
policyEntity.getActionBodyEntity().getActionBodyName());
}
}
private JSONObject editFile(JSONObject params) throws ServletException {
// get content
try {
- PolicyController controller = getPolicyControllerInstance();
- String mode = params.getString("mode");
+ final PolicyController controller = getPolicyControllerInstance();
+ final String mode = params.getString("mode");
String path = params.getString("path");
LOGGER.debug("editFile path: {}" + path);
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import org.springframework.mail.javamail.MimeMessageHelper;
/**
- * Send policy notification mail depending on the mode for every policy being watched
+ * Send policy notification mail depending on the mode for every policy being watched.
*/
@Configurable
public class PolicyNotificationMail {
private static final String DELETED_BY = "Deleted By : ";
private static Logger policyLogger = FlexLogger.getLogger(PolicyNotificationMail.class);
+ /**
+ * javaMailSenderImpl.
+ *
+ * @return JavaMailSenderImpl object
+ */
@Bean
public JavaMailSenderImpl javaMailSenderImpl() {
JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
/**
* For every policy being watched and when the policy name is one of the Config_, Action_ or Decision_,
- * send the notification
- *
- * @param mode
- * @param policyNotificationDao
- * @param subject
- * @param message
- * @param checkPolicyName
- * @param watchList
+ * send the notification.
+ *
+ * @param mode String for the mode
+ * @param policyNotificationDao CommonClassDao
+ * @param subject String subject
+ * @param message String message
+ * @param checkPolicyName String check policy name
+ * @param watchList List of watch objects
*/
private void composeAndSendMail(String mode, CommonClassDao policyNotificationDao, String subject, String message,
String checkPolicyName, List<Object> watchList) {
for (Object watch : watchList) {
WatchPolicyNotificationTable list = (WatchPolicyNotificationTable) watch;
String watchPolicyName = list.getPolicyName();
- // this conditino check for specific stringin policy name being watched and
+ // this condition check for specific stringin policy name being watched and
// also if the policy being checked is different from the watched ones,
// then there is no need to send mail, hence continue with next policy in the loop
if ((watchPolicyName.contains("Config_") || watchPolicyName.contains("Action_")
PolicyRestController.commonClassDao = commonClassDao;
}
+ /**
+ * policyCreationController.
+ *
+ * @param request Request
+ * @param response Response
+ */
@RequestMapping(value = {"/policycreation/save_policy"}, method = {RequestMethod.POST})
public void policyCreationController(HttpServletRequest request, HttpServletResponse response) {
String userId = UserUtils.getUserSession(request).getOrgUserId();
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
try {
- updateAndSendToPAP(request, response, userId, mapper);
+ updateAndSendToPap(request, response, userId, mapper);
} catch (Exception e) {
policyLogger.error("Exception Occured while saving policy", e);
}
}
- private void updateAndSendToPAP(HttpServletRequest request, HttpServletResponse response, String userId,
+ private void updateAndSendToPap(HttpServletRequest request, HttpServletResponse response, String userId,
ObjectMapper mapper) throws IOException {
JsonNode root = mapper.readTree(request.getReader());
policyLogger.info(
- "****************************************Logging UserID while Create/Update Policy**************************************************");
+ "********************Logging UserID while Create/Update Policy***********************************");
policyLogger.info(USER_ID + userId + "Policy Data Object: "
+ root.get(PolicyController.getPolicydata()).get("policy").toString());
policyLogger.info(
- "***********************************************************************************************************************************");
+ "************************************************************************************************");
PolicyRestAdapter policyData = mapper.readValue(
root.get(PolicyController.getPolicydata()).get("policy").toString(), PolicyRestAdapter.class);
String result;
String body = PolicyUtils.objectToJsonString(policyData);
String uri = request.getRequestURI();
- ResponseEntity<?> responseEntity = sendToPAP(body, uri, HttpMethod.POST);
+ ResponseEntity<?> responseEntity = sendToPap(body, uri, HttpMethod.POST);
if (responseEntity != null && responseEntity.getBody().equals(HttpServletResponse.SC_CONFLICT)) {
result = "PolicyExists";
} else if (responseEntity != null) {
result = responseEntity.getBody().toString();
String policyName = responseEntity.getHeaders().get(POLICY_NAME).get(0);
if (policyData.isEditPolicy() && SUCCESS.equalsIgnoreCase(result)) {
- PolicyNotificationMail email = new PolicyNotificationMail();
- String mode = "EditPolicy";
+ final PolicyNotificationMail email = new PolicyNotificationMail();
+ final String mode = "EditPolicy";
String watchPolicyName = policyName.replace(XML, "");
String version = watchPolicyName.substring(watchPolicyName.lastIndexOf('.') + 1);
watchPolicyName =
PrintWriter out = response.getWriter();
String responseString = mapper.writeValueAsString(result);
- JSONObject j = new JSONObject("{policyData: " + responseString + "}");
- out.write(j.toString());
+ JSONObject json = new JSONObject("{policyData: " + responseString + "}");
+ out.write(json.toString());
}
private void modifyPolicyData(JsonNode root, PolicyRestAdapter policyData) {
}
}
- private ResponseEntity<?> sendToPAP(String body, String requestURI, HttpMethod method) {
+ private ResponseEntity<?> sendToPap(String body, String requestUri, HttpMethod method) {
String papUrl = PolicyController.getPapUrl();
String papID = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID);
String papPass = PeCryptoUtils.decrypt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS));
HttpEntity<?> requestEntity = new HttpEntity<>(body, headers);
ResponseEntity<?> result = null;
HttpClientErrorException exception = null;
- String uri = requestURI;
+ String uri = requestUri;
if (uri.startsWith("/")) {
uri = uri.substring(uri.indexOf('/') + 1);
}
return result;
}
- private String callPAP(HttpServletRequest request, String method, String uriValue) {
- String uri = uriValue;
+ private String callPap(HttpServletRequest request, String method, String uriValue) {
String papUrl = PolicyController.getPapUrl();
String papID = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID);
PeCryptoUtils.initAesKey(XACMLProperties.getProperty(XACMLRestProperties.PROP_AES_KEY));
List<FileItem> items;
FileItem item = null;
File file = null;
+ String uri = uriValue;
if (uri.contains(IMPORT_DICTIONARY)) {
try {
items = new ServletFileUpload(new DiskFileItemFactory()).parseRequest(request);
return doConnect(connection);
}
- checkURI(request, uri, connection, item);
+ checkUri(request, uri, connection, item);
return doConnect(connection);
} catch (Exception e) {
return null;
}
- private void checkURI(HttpServletRequest request, String uri, HttpURLConnection connection, FileItem item)
+ private void checkUri(HttpServletRequest request, String uri, HttpURLConnection connection, FileItem item)
throws IOException {
String boundary;
if (!(uri.endsWith("set_BRMSParamData") || uri.contains(IMPORT_DICTIONARY))) {
return null;
}
+ /**
+ * getDictionaryController.
+ *
+ * @param request Request
+ * @param response Response
+ */
@RequestMapping(value = {"/getDictionary/*"}, method = {RequestMethod.GET})
public void getDictionaryController(HttpServletRequest request, HttpServletResponse response) {
String uri = request.getRequestURI().replace("/getDictionary", "");
String body;
- ResponseEntity<?> responseEntity = sendToPAP(null, uri, HttpMethod.GET);
+ ResponseEntity<?> responseEntity = sendToPap(null, uri, HttpMethod.GET);
if (responseEntity != null) {
body = responseEntity.getBody().toString();
} else {
}
}
+ /**
+ * saveDictionaryController.
+ *
+ * @param request Request
+ * @param response Response
+ * @throws IOException IO Exception
+ */
@RequestMapping(value = {"/saveDictionary/*/*"}, method = {RequestMethod.POST})
public void saveDictionaryController(HttpServletRequest request, HttpServletResponse response) throws IOException {
String userId = "";
}
policyLogger.info(
- "****************************************Logging UserID while Saving Dictionary*****************************************************");
+ "********************Logging UserID while Saving Dictionary**************************************");
policyLogger.info(USER_ID + userId);
policyLogger.info(
- "***********************************************************************************************************************************");
+ "************************************************************************************************");
- String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
+ String body = callPap(request, "POST", uri.replaceFirst("/", "").trim());
if (body != null && !body.isEmpty()) {
response.getWriter().write(body);
} else {
}
}
+ /**
+ * deletetDictionaryController.
+ *
+ * @param request Request
+ * @param response Response
+ * @throws IOException IO Exception
+ */
@RequestMapping(value = {"/deleteDictionary/*/*"}, method = {RequestMethod.POST})
public void deletetDictionaryController(HttpServletRequest request, HttpServletResponse response)
throws IOException {
String userId = UserUtils.getUserSession(request).getOrgUserId();
policyLogger.info(
- "****************************************Logging UserID while Deleting Dictionary*****************************************************");
+ "**********************Logging UserID while Deleting Dictionary*************************************");
policyLogger.info(USER_ID + userId);
policyLogger.info(
- "*************************************************************************************************************************************");
+ "***************************************************************************************************");
- String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
+ String body = callPap(request, "POST", uri.replaceFirst("/", "").trim());
if (body != null && !body.isEmpty()) {
response.getWriter().write(body);
} else {
}
}
+ /**
+ * searchDictionaryController.
+ *
+ * @param request Request
+ * @param response Response
+ * @return ModelAndView object
+ * @throws IOException IO Exception
+ */
@RequestMapping(value = {"/searchDictionary"}, method = {RequestMethod.POST})
public ModelAndView searchDictionaryController(HttpServletRequest request, HttpServletResponse response)
throws IOException {
}
uri = ONAP + uri.substring(uri.indexOf('/'));
try {
- String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
+ String body = callPap(request, "POST", uri.replaceFirst("/", "").trim());
if (body.contains("CouldNotConnectException")) {
List<String> data = new ArrayList<>();
data.add("Elastic Search Server is down");
response.setCharacterEncoding(PolicyController.getCharacterencoding());
response.setContentType(PolicyController.getContenttype());
PrintWriter out = response.getWriter();
- JSONObject j = new JSONObject("{result: " + resultList + "}");
- out.write(j.toString());
+ JSONObject json = new JSONObject("{result: " + resultList + "}");
+ out.write(json.toString());
return null;
}
+ /**
+ * searchPolicy.
+ *
+ * @param request request
+ * @param response response
+ * @return ModelAndView object
+ * @throws IOException IO exception
+ */
@RequestMapping(value = {"/searchPolicy"}, method = {RequestMethod.POST})
public ModelAndView searchPolicy(HttpServletRequest request, HttpServletResponse response) throws IOException {
Object resultList;
uri = uri.substring(uri.indexOf('/') + 1);
}
uri = ONAP + uri.substring(uri.indexOf('/'));
- String body = callPAP(request, "POST", uri.replaceFirst("/", "").trim());
+ String body = callPap(request, "POST", uri.replaceFirst("/", "").trim());
JSONObject json = new JSONObject(body);
try {
request.setCharacterEncoding(UTF_8);
PrintWriter out = response.getWriter();
- JSONObject j = new JSONObject("{result: " + resultList + "}");
- out.write(j.toString());
+ JSONObject json2 = new JSONObject("{result: " + resultList + "}");
+ out.write(json2.toString());
return null;
}
public void deleteElasticData(String fileName) {
String uri = "searchPolicy?action=delete&policyName='" + fileName + "'";
- callPAP(null, "POST", uri.trim());
+ callPap(null, "POST", uri.trim());
}
- public String notifyOtherPAPSToUpdateConfigurations(String mode, String newName, String oldName) {
+ /**
+ * notifyOtherPAPSToUpdateConfigurations.
+ *
+ * @param mode Mode
+ * @param newName New Name
+ * @param oldName Old Name
+ * @return String
+ */
+ public String notifyOtherPapsToUpdateConfigurations(String mode, String newName, String oldName) {
String uri =
"onap/notifyOtherPAPs?action=" + mode + "&newPolicyName=" + newName + "&oldPolicyName=" + oldName + "";
- return callPAP(null, "POST", uri.trim());
+ return callPap(null, "POST", uri.trim());
}
}
private static final Logger LOGGER = FlexLogger.getLogger(PolicyUserInfoController.class);
+ /**
+ * getPolicyUserInfo - fills the HTTP response with user information.
+ *
+ * @param request HttpServletRequest
+ * @param response HttpServletResponse
+ */
@RequestMapping(value = "/get_PolicyUserInfo", method = RequestMethod.GET)
public void getPolicyUserInfo(HttpServletRequest request, HttpServletResponse response) {
JsonMessage msg;
ObjectMapper mapper = new ObjectMapper();
model.put("userid", userId);
msg = new JsonMessage(mapper.writeValueAsString(model));
- JSONObject j = new JSONObject(msg);
- response.getWriter().write(j.toString());
+ JSONObject json = new JSONObject(msg);
+ response.getWriter().write(json.toString());
} catch (Exception e) {
LOGGER.error("Exception Occurred" + e);
}
/**
* validatePolicyRequest Creates a pap policy and then send to pap.
- *
+ *
* @param policyAdapter Input Adapter
* @param policyType Type of Policy
* @return true if validated
* <p>The content is either an InputStream to be copied to the Request OutputStream OR it is an object that is to be
* encoded into JSON and pushed into the Request OutputStream.
*
- * <p>The Request parameters may be encoded in multiple "name=value" sets, or parameters may be
+ * <p>The Request parameters may be encoded in multiple "name=value" sets, or parameters may be
* combined by the caller.
*
* @param method method
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
/**
* This is for downloading existing policy.
- *
+ *
* @param request HttpServletRequest
* @param response HttpServletResponse
* @throws IOException error out
PrintWriter out = response.getWriter();
String successMap = file.substring(file.lastIndexOf("webapps") + 8);
String responseString = mapper.writeValueAsString(successMap);
- JSONObject j = new JSONObject("{data: " + responseString + "}");
- out.write(j.toString());
+ JSONObject json = new JSONObject("{data: " + responseString + "}");
+ out.write(json.toString());
} catch (Exception e) {
logger.error(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Exception Occured while Exporting Policies" + e);
}
/**
* This is to upload a policy and save it to database.
- *
+ *
* @param file String
* @param request HttpServletRequest
* @return JSONObject
/**
* This is to validate all matching required fields.
- *
+ *
* @param policyName String
* @param jsonString String
* @return String
saveVersion(policyEntity, scope, userId); //
// Notify Other paps regarding Export Policy.
PolicyRestController restController = new PolicyRestController();
- restController.notifyOtherPAPSToUpdateConfigurations("exportPolicy", configName, null);
+ restController.notifyOtherPapsToUpdateConfigurations("exportPolicy", configName, null);
}
}
}
package org.onap.policy.admin;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.Test;
import org.mockito.Mockito;
import org.onap.policy.controller.CreateFirewallController;
+import org.onap.policy.controller.PolicyController;
import org.onap.policy.rest.dao.CommonClassDao;
import org.onap.policy.rest.jpa.ActionList;
import org.onap.policy.rest.jpa.AddressGroup;
private List<Object> tagListData;
private List<Object> termListData;
+ /**
+ * Before.
+ *
+ * @throws Exception exception
+ */
@Before
public void setUp() throws Exception {
commonClassDao = mock(CommonClassDao.class);
- HttpSession mockSession = mock(HttpSession.class);
+ final HttpSession mockSession = mock(HttpSession.class);
request = mock(HttpServletRequest.class);
response = new MockHttpServletResponse();
User user = new User();
@Test
public final void testPolicyCreationController() {
+ assertNull(PolicyRestController.getCommonClassDao());
+ PolicyRestController.setCommonClassDao(commonClassDao);
+ assertNotNull(PolicyRestController.getCommonClassDao());
+
PolicyRestController controller = new PolicyRestController();
BufferedReader reader = new BufferedReader(new StringReader(clRequestString));
try {
}
PolicyRestController controller1 = new PolicyRestController();
CreateFirewallController.setCommonClassDao(commonClassDao);
+ assertNotNull(CreateFirewallController.getCommonClassDao());
BufferedReader reader1 = new BufferedReader(new StringReader(fwRequestString));
try {
Mockito.when(request.getReader()).thenReturn(reader1);
}
}
+ @Test
+ public final void testSearchPolicy() throws IOException {
+ PolicyController.setjUnit(true);
+ PolicyController.setPapUrl("http://localhost:8070/pap/");
+ PolicyRestController controller = new PolicyRestController();
+ BufferedReader reader = new BufferedReader(new StringReader("{\"foo\":\"bar\"}"));
+ Mockito.when(request.getReader()).thenReturn(reader);
+ Mockito.when(request.getRequestURI()).thenReturn("/pap/foo/");
+ assertThatExceptionOfType(NullPointerException.class).isThrownBy(() ->
+ controller.searchPolicy(request, response));
+ }
+
+ @Test
+ public final void testSearchDictionaryController() throws IOException {
+ PolicyRestController controller = new PolicyRestController();
+ BufferedReader reader = new BufferedReader(new StringReader("{\"foo\":\"bar\"}"));
+ Mockito.when(request.getReader()).thenReturn(reader);
+ Mockito.when(request.getRequestURI()).thenReturn("/pap/foo/");
+ assertNull(controller.searchDictionaryController(request, response));
+ }
+
@Test
public final void testDeleteElasticData() {
PolicyRestController controller = new PolicyRestController();
fail();
}
}
+
+ @Test
+ public final void testNotifyOtherPaps() {
+ PolicyRestController controller = new PolicyRestController();
+ String strReturn = controller.notifyOtherPapsToUpdateConfigurations("mode", "newName", "oldName");
+ assertNull(strReturn);
+ }
}