2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.policy.pap.xacml.rest.policycontroller;
23 import com.fasterxml.jackson.databind.ObjectMapper;
25 import java.util.Date;
26 import java.util.HashMap;
27 import java.util.LinkedHashMap;
28 import java.util.LinkedList;
29 import java.util.List;
31 import javax.servlet.http.HttpServletRequest;
32 import javax.servlet.http.HttpServletResponse;
33 import org.apache.commons.lang.StringUtils;
34 import org.onap.policy.common.logging.eelf.PolicyLogger;
35 import org.onap.policy.common.logging.flexlogger.FlexLogger;
36 import org.onap.policy.common.logging.flexlogger.Logger;
37 import org.onap.policy.pap.xacml.rest.components.ActionPolicy;
38 import org.onap.policy.pap.xacml.rest.components.ClosedLoopPolicy;
39 import org.onap.policy.pap.xacml.rest.components.ConfigPolicy;
40 import org.onap.policy.pap.xacml.rest.components.CreateBrmsParamPolicy;
41 import org.onap.policy.pap.xacml.rest.components.CreateBrmsRawPolicy;
42 import org.onap.policy.pap.xacml.rest.components.CreateClosedLoopPerformanceMetrics;
43 import org.onap.policy.pap.xacml.rest.components.DecisionPolicy;
44 import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy;
45 import org.onap.policy.pap.xacml.rest.components.MicroServiceConfigPolicy;
46 import org.onap.policy.pap.xacml.rest.components.OptimizationConfigPolicy;
47 import org.onap.policy.pap.xacml.rest.components.Policy;
48 import org.onap.policy.pap.xacml.rest.components.PolicyDBDao;
49 import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction;
50 import org.onap.policy.pap.xacml.rest.elk.client.PolicyElasticSearchController;
51 import org.onap.policy.pap.xacml.rest.util.AbstractPolicyCreation;
52 import org.onap.policy.rest.adapter.PolicyRestAdapter;
53 import org.onap.policy.rest.dao.CommonClassDao;
54 import org.onap.policy.rest.jpa.ActionPolicyDict;
55 import org.onap.policy.rest.jpa.BRMSParamTemplate;
56 import org.onap.policy.rest.jpa.PolicyEditorScopes;
57 import org.onap.policy.rest.jpa.PolicyVersion;
58 import org.onap.policy.rest.jpa.UserInfo;
59 import org.onap.policy.xacml.api.XACMLErrorConstants;
60 import org.springframework.beans.factory.annotation.Autowired;
61 import org.springframework.http.HttpStatus;
62 import org.springframework.http.ResponseEntity;
63 import org.springframework.http.converter.HttpMessageNotReadableException;
64 import org.springframework.web.bind.annotation.ExceptionHandler;
65 import org.springframework.web.bind.annotation.RequestBody;
66 import org.springframework.web.bind.annotation.RequestMapping;
67 import org.springframework.web.bind.annotation.RequestMethod;
68 import org.springframework.web.bind.annotation.ResponseBody;
69 import org.springframework.web.bind.annotation.RestController;
74 public class PolicyCreation extends AbstractPolicyCreation{
76 private static final Logger LOGGER = FlexLogger.getLogger(PolicyCreation.class);
78 private String ruleID = "";
79 private PolicyDBDao policyDBDao;
82 private static CommonClassDao commonClassDao;
84 public static CommonClassDao getCommonClassDao() {
85 return commonClassDao;
88 public static void setCommonClassDao(CommonClassDao commonClassDao) {
89 PolicyCreation.commonClassDao = commonClassDao;
93 public PolicyCreation(CommonClassDao commonClassDao){
94 PolicyCreation.commonClassDao = commonClassDao;
97 public PolicyCreation(){}
99 @RequestMapping(value="/policycreation/save_policy", method = RequestMethod.POST)
101 public ResponseEntity<String> savePolicy(@RequestBody PolicyRestAdapter policyData, HttpServletResponse response){
103 HttpStatus status = HttpStatus.BAD_REQUEST;
104 Map<String, String> successMap = new HashMap<>();
105 Map<String, String> attributeMap = new HashMap<>();
106 PolicyVersion policyVersionDao;
109 Policy newPolicy = null;
110 String policyConfigType = null;
111 String userId = policyData.getUserId();
113 if (policyData.getTtlDate()==null){
114 policyData.setTtlDate("NA");
116 String dateTTL = policyData.getTtlDate();
117 String newDate = convertDate(dateTTL);
118 policyData.setTtlDate(newDate);
121 String policyType = policyData.getPolicyType();
123 String filePrefix = null;
124 if ("Config".equalsIgnoreCase(policyType)) {
125 policyConfigType = policyData.getConfigPolicyType();
126 if ("Firewall Config".equalsIgnoreCase(policyConfigType)) {
127 filePrefix = "Config_FW_";
128 }else if ("ClosedLoop_Fault".equalsIgnoreCase(policyConfigType)) {
129 filePrefix = "Config_Fault_";
130 }else if ("ClosedLoop_PM".equalsIgnoreCase(policyConfigType)) {
131 filePrefix = "Config_PM_";
132 }else if ("Micro Service".equalsIgnoreCase(policyConfigType)) {
133 filePrefix = "Config_MS_";
134 }else if ("Optimization".equalsIgnoreCase(policyConfigType)) {
135 filePrefix = "Config_OOF_";
136 }else if ("BRMS_Raw".equalsIgnoreCase(policyConfigType)) {
137 filePrefix = "Config_BRMS_Raw_";
138 }else if ("BRMS_Param".equalsIgnoreCase(policyConfigType)) {
139 filePrefix = "Config_BRMS_Param_";
141 filePrefix = "Config_";
143 } else if ("Action".equalsIgnoreCase(policyType)) {
144 filePrefix = "Action_";
145 } else if ("Decision".equalsIgnoreCase(policyType)) {
146 filePrefix = "Decision_";
150 int highestVersion = 0;
153 String scopeCheck = policyData.getDomainDir().replace(".", File.separator);
154 PolicyEditorScopes policyEditorScope = (PolicyEditorScopes) commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", scopeCheck);
155 if(policyEditorScope == null){
156 UserInfo userInfo = new UserInfo();
157 userInfo.setUserName("API");
158 userInfo.setUserLoginId("API");
159 PolicyEditorScopes editorScope = new PolicyEditorScopes();
160 editorScope.setScopeName(scopeCheck);
161 editorScope.setUserCreatedBy(userInfo);
162 editorScope.setUserModifiedBy(userInfo);
163 commonClassDao.save(editorScope);
165 //get the highest version of policy from policy version table.
166 String dbCheckPolicyName = policyData.getDomainDir() + File.separator + filePrefix + policyData.getPolicyName();
167 PolicyVersion policyVersion = getPolicyVersionData(dbCheckPolicyName);
168 if(policyVersion == null){
171 highestVersion = policyVersion.getHigherVersion();
174 if(highestVersion != 0 && policyVersion != null){
175 if(policyData.isEditPolicy()){
176 version = highestVersion +1;
182 policyData.setUserId("API");
183 createdBy = policyVersion.getCreatedBy();
184 policyVersionDao = policyVersion;
185 policyVersionDao.setActiveVersion(version);
186 policyVersionDao.setHigherVersion(version);
187 policyVersionDao.setModifiedBy(modifiedBy);
188 policyVersionDao.setModifiedDate(new Date());
190 body = "policyExists";
191 status = HttpStatus.CONFLICT;
192 response.setStatus(HttpServletResponse.SC_CONFLICT);
193 response.addHeader("error", "policyExists");
194 response.addHeader("policyName", policyData.getPolicyName());
195 return new ResponseEntity<>(body, status);
198 // if policy does not exist and the request is updatePolicy return error
199 if(policyData.isEditPolicy()){
200 body = "policyNotAvailableForEdit";
201 status = HttpStatus.NOT_FOUND;
202 response.setStatus(HttpServletResponse.SC_NOT_FOUND);
203 response.addHeader("error", body);
204 response.addHeader("message", policyData.getPolicyName() + " does not exist on the PAP and cannot be updated.");
205 return new ResponseEntity<>(body, status);
211 policyData.setUserId("API");
215 policyData.setUserId("API");
217 policyVersionDao = new PolicyVersion();
218 policyVersionDao.setPolicyName(dbCheckPolicyName);
219 policyVersionDao.setActiveVersion(version);
220 policyVersionDao.setHigherVersion(version);
221 policyVersionDao.setCreatedBy(createdBy);
222 policyVersionDao.setModifiedBy(modifiedBy);
225 policyData.setPolicyID(newPolicyID());
226 policyData.setRuleID(ruleID);
228 String policyFileName = dbCheckPolicyName.replace(File.separator, ".")+ "." + version + ".xml";
229 policyData.setNewFileName(policyFileName);
230 policyData.setPolicyDescription(policyData.getPolicyDescription()+ "@CreatedBy:" +createdBy + "@CreatedBy:" + "@ModifiedBy:" +modifiedBy + "@ModifiedBy:");
231 policyData.setRuleCombiningAlgId("urn:oasis:names:tc:xacml:3.0:rule-combining-algorithm:permit-overrides");
232 if(policyData.getApiflag() == null){
233 //set the Rule Combining Algorithm Id to be sent to PAP-REST via JSON
234 if(policyData.getAttributes() != null && !policyData.getAttributes().isEmpty()){
235 for(Object attribute : policyData.getAttributes()){
236 if(attribute instanceof LinkedHashMap<?, ?>){
237 String key = ((LinkedHashMap<?, ?>) attribute).get("key").toString();
238 String value = ((LinkedHashMap<?, ?>) attribute).get("value").toString();
239 attributeMap.put(key, value);
243 policyData.setDynamicFieldConfigAttributes(attributeMap);
246 policyData.setVersion(String.valueOf(version));
247 policyData.setHighestVersion(version);
249 // Calling Component class per policy type
250 if ("Config".equalsIgnoreCase(policyType)) {
251 if ("Firewall Config".equalsIgnoreCase(policyConfigType)) {
252 newPolicy = new FirewallConfigPolicy(policyData);
253 }else if ("BRMS_Raw".equalsIgnoreCase(policyConfigType)) {
254 policyData.setOnapName("DROOLS");
255 policyData.setConfigName("BRMS_RAW_RULE");
256 newPolicy = new CreateBrmsRawPolicy(policyData);
257 }else if ("BRMS_Param".equalsIgnoreCase(policyConfigType)) {
258 policyData.setOnapName("DROOLS");
259 policyData.setConfigName("BRMS_PARAM_RULE");
260 Map<String, String> drlRuleAndUIParams = new HashMap<>();
261 if(policyData.getApiflag() == null){
262 // If there is any dynamic field create the matches here
263 String key="templateName";
264 String value= policyData.getRuleName();
265 drlRuleAndUIParams.put(key, value);
266 if(policyData.getRuleData().size() > 0){
267 for(Object keyValue: policyData.getRuleData().keySet()){
268 drlRuleAndUIParams.put(keyValue.toString(), policyData.getRuleData().get(keyValue).toString());
271 policyData.setBrmsParamBody(drlRuleAndUIParams);
273 drlRuleAndUIParams=policyData.getBrmsParamBody();
274 String modelName= drlRuleAndUIParams.get("templateName");
275 PolicyLogger.info("Template name from API is: "+modelName);
277 BRMSParamTemplate template = (BRMSParamTemplate) commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", modelName);
278 if(template == null){
279 String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid Template. The template name, "
280 + modelName + " was not found in the dictionary.";
282 status = HttpStatus.BAD_REQUEST;
283 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
284 response.addHeader("error", message);
285 response.addHeader("modelName", modelName);
286 return new ResponseEntity<String>(body, status);
289 newPolicy = new CreateBrmsParamPolicy(policyData);
290 }else if ("Base".equalsIgnoreCase(policyConfigType)) {
291 newPolicy = new ConfigPolicy(policyData);
292 }else if ("ClosedLoop_Fault".equalsIgnoreCase(policyConfigType)) {
293 newPolicy = new ClosedLoopPolicy(policyData);
294 }else if ("ClosedLoop_PM".equalsIgnoreCase(policyConfigType)) {
295 if(policyData.getApiflag() == null){
296 policyData.setServiceType(policyData.getServiceTypePolicyName().get("serviceTypePolicyName").toString());
297 ObjectMapper jsonMapper = new ObjectMapper();
298 String jsonBody = jsonMapper.writeValueAsString(policyData.getJsonBodyData());
299 jsonBody = jsonBody.replaceFirst("\\{", "\\{\"serviceTypePolicyName\": \"serviceTypeFieldValue\",");
300 jsonBody = jsonBody.replace("serviceTypeFieldValue", policyData.getServiceType());
301 policyData.setJsonBody(jsonBody);
303 newPolicy = new CreateClosedLoopPerformanceMetrics(policyData);
304 }else if ("Micro Service".equalsIgnoreCase(policyConfigType)) {
305 newPolicy = new MicroServiceConfigPolicy(policyData);
306 }else if ("Optimization".equalsIgnoreCase(policyConfigType)) {
307 newPolicy = new OptimizationConfigPolicy(policyData);
309 }else if("Action".equalsIgnoreCase(policyType)) {
310 if(policyData.getApiflag() == null){
311 List<String> dynamicRuleAlgorithmLabels = new LinkedList<>();
312 List<String> dynamicRuleAlgorithmCombo = new LinkedList<>();
313 List<String> dynamicRuleAlgorithmField1 = new LinkedList<>();
314 List<String> dynamicRuleAlgorithmField2 = new LinkedList<>();
317 if(!policyData.getRuleAlgorithmschoices().isEmpty()){
318 for(Object attribute : policyData.getRuleAlgorithmschoices()){
319 if(attribute instanceof LinkedHashMap<?, ?>){
320 String label = ((LinkedHashMap<?, ?>) attribute).get("id").toString();
321 String key = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField1").toString();
322 String rule = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmCombo").toString();
323 String value = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField2").toString();
324 dynamicRuleAlgorithmLabels.add(label);
325 dynamicRuleAlgorithmField1.add(key);
326 dynamicRuleAlgorithmCombo.add(rule);
327 dynamicRuleAlgorithmField2.add(value);
332 String actionDictValue = policyData.getActionAttributeValue();
333 ActionPolicyDict jsonData = ((ActionPolicyDict) commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", actionDictValue));
335 String actionBodyString = jsonData.getBody();
336 String actionDictHeader = jsonData.getHeader();
337 String actionDictType = jsonData.getType();
338 String actionDictUrl = jsonData.getUrl();
339 String actionDictMethod = jsonData.getMethod();
340 policyData.setActionDictHeader(actionDictHeader);
341 policyData.setActionDictType(actionDictType);
342 policyData.setActionDictUrl(actionDictUrl);
343 policyData.setActionDictMethod(actionDictMethod);
344 if (actionBodyString != null) {
345 policyData.setActionBody(actionBodyString);
348 policyData.setActionAttribute(actionDictValue);
349 policyData.setDynamicRuleAlgorithmLabels(dynamicRuleAlgorithmLabels);
350 policyData.setDynamicRuleAlgorithmCombo(dynamicRuleAlgorithmCombo);
351 policyData.setDynamicRuleAlgorithmField1(dynamicRuleAlgorithmField1);
352 policyData.setDynamicRuleAlgorithmField2(dynamicRuleAlgorithmField2);
355 String comboDictValue = policyData.getActionAttribute();
356 ActionPolicyDict jsonData = ((ActionPolicyDict) commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", comboDictValue));
358 policyData.setActionBody(jsonData.getBody());
359 policyData.setActionDictHeader(jsonData.getHeader());
360 policyData.setActionDictType(jsonData.getType());
361 policyData.setActionDictUrl(jsonData.getUrl());
362 policyData.setActionDictMethod(jsonData.getMethod());
365 newPolicy = new ActionPolicy(policyData, commonClassDao);
366 } else if ("Decision".equalsIgnoreCase(policyType)) {
367 if(policyData.getApiflag() == null){
368 Map<String, String> settingsMap = new HashMap<>();
369 Map<String, String> treatmentMap = new HashMap<>();
370 List<String> dynamicRuleAlgorithmLabels = new LinkedList<>();
371 List<String> dynamicRuleAlgorithmCombo = new LinkedList<>();
372 List<String> dynamicRuleAlgorithmField1 = new LinkedList<>();
373 List<String> dynamicRuleAlgorithmField2 = new LinkedList<>();
374 List<Object> dynamicVariableList = new LinkedList<>();
375 List<String> dataTypeList = new LinkedList<>();
376 List<String> errorCodeList = new LinkedList<>();
377 List<String> treatmentList = new LinkedList<>();
379 if(!policyData.getSettings().isEmpty()){
380 for(Object settingsData : policyData.getSettings()){
381 if(settingsData instanceof LinkedHashMap<?, ?>){
382 String key = ((LinkedHashMap<?, ?>) settingsData).get("key").toString();
383 String value = ((LinkedHashMap<?, ?>) settingsData).get("value").toString();
384 settingsMap.put(key, value);
388 if(policyData.getRuleAlgorithmschoices()!=null && policyData.getRuleAlgorithmschoices().size() > 0){
389 for(Object attribute : policyData.getRuleAlgorithmschoices()){
390 if(attribute instanceof LinkedHashMap<?, ?>){
391 String label = ((LinkedHashMap<?, ?>) attribute).get("id").toString();
392 String key = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField1").toString();
393 String rule = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmCombo").toString();
394 String value = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField2").toString();
395 dynamicRuleAlgorithmLabels.add(label);
396 dynamicRuleAlgorithmField1.add(key);
397 dynamicRuleAlgorithmCombo.add(rule);
398 dynamicRuleAlgorithmField2.add(value);
402 if (policyData.getRuleProvider() != null
403 && (policyData.getRuleProvider().equals(DecisionPolicy.GUARD_YAML)
404 || policyData.getRuleProvider().equals(DecisionPolicy.GUARD_BL_YAML)
405 || policyData.getRuleProvider().equals(DecisionPolicy.GUARD_MIN_MAX))
406 && policyData.getYamlparams() != null) {
407 attributeMap.put("actor", policyData.getYamlparams().getActor());
408 attributeMap.put("recipe", policyData.getYamlparams().getRecipe());
409 attributeMap.put("clname", policyData.getYamlparams().getClname());
410 attributeMap.put("limit", policyData.getYamlparams().getLimit());
411 attributeMap.put("min", policyData.getYamlparams().getMin());
412 attributeMap.put("max", policyData.getYamlparams().getMax());
413 attributeMap.put("timeWindow", policyData.getYamlparams().getTimeWindow());
414 attributeMap.put("timeUnits", policyData.getYamlparams().getTimeUnits());
415 attributeMap.put("guardActiveStart", policyData.getYamlparams().getGuardActiveStart());
416 attributeMap.put("guardActiveEnd", policyData.getYamlparams().getGuardActiveEnd());
417 if (policyData.getYamlparams().getBlackList() != null) {
418 String blackList = StringUtils.join(policyData.getYamlparams().getBlackList(), ",");
419 attributeMap.put("blackList", blackList);
421 if (DecisionPolicy.GUARD_BL_YAML.equals(policyData.getRuleProvider())
422 && "Use File Upload".equals(policyData.getBlackListEntryType())) {
423 if (policyData.getBlackListEntries() != null
424 && !policyData.getBlackListEntries().isEmpty()) {
425 String blackList = StringUtils.join(policyData.getBlackListEntries(), ",");
426 attributeMap.put("blackList", blackList);
428 if (policyData.getAppendBlackListEntries() != null
429 && !policyData.getAppendBlackListEntries().isEmpty()) {
430 String blackList = StringUtils.join(policyData.getAppendBlackListEntries(), ",");
431 attributeMap.put("appendBlackList", blackList);
434 if (policyData.getYamlparams().getTargets() != null) {
435 String targets = StringUtils.join(policyData.getYamlparams().getTargets(), ",");
436 attributeMap.put("targets", targets);
439 if (policyData.getRuleProvider() != null
440 && policyData.getRuleProvider().equals(DecisionPolicy.RAINY_DAY)) {
441 attributeMap.put("ServiceType", policyData.getRainyday().getServiceType());
442 attributeMap.put("VNFType", policyData.getRainyday().getVnfType());
443 attributeMap.put("BB_ID", policyData.getRainyday().getBbid());
444 attributeMap.put("WorkStep", policyData.getRainyday().getWorkstep());
446 if (policyData.getRainyday().getTreatmentTableChoices() != null
447 && policyData.getRainyday().getTreatmentTableChoices().isEmpty()) {
448 for (Object table : policyData.getRainyday().getTreatmentTableChoices()) {
449 if (table instanceof LinkedHashMap<?, ?>) {
450 String errorcode = ((LinkedHashMap<?, ?>) table).get("errorcode").toString();
451 String treatment = ((LinkedHashMap<?, ?>) table).get("treatment").toString();
452 treatmentMap.put(errorcode, treatment);
458 policyData.setDynamicRuleAlgorithmLabels(dynamicRuleAlgorithmLabels);
459 policyData.setDynamicRuleAlgorithmCombo(dynamicRuleAlgorithmCombo);
460 policyData.setDynamicRuleAlgorithmField1(dynamicRuleAlgorithmField1);
461 policyData.setDynamicRuleAlgorithmField2(dynamicRuleAlgorithmField2);
462 policyData.setDynamicVariableList(dynamicVariableList);
463 policyData.setDynamicSettingsMap(settingsMap);
464 policyData.setDynamicFieldConfigAttributes(attributeMap);
465 policyData.setDataTypeList(dataTypeList);
466 policyData.setRainydayMap(treatmentMap);
467 policyData.setErrorCodeList(errorCodeList);
468 policyData.setTreatmentList(treatmentList);
470 newPolicy = new DecisionPolicy(policyData);
473 if(newPolicy != null){
474 newPolicy.prepareToSave();
477 status = HttpStatus.INTERNAL_SERVER_ERROR;
478 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
479 response.addHeader("error", "error");
480 return new ResponseEntity<>(body, status);
483 PolicyDBDaoTransaction policyDBDaoTransaction = null;
485 policyDBDao = PolicyDBDao.getPolicyDBDaoInstance();
486 policyDBDaoTransaction = policyDBDao.getNewTransaction();
487 policyDBDaoTransaction.createPolicy(newPolicy, policyData.getUserId());
488 successMap = newPolicy.savePolicies();
489 if(successMap.containsKey("success")){
490 policyDBDaoTransaction.commitTransaction();
491 if(policyData.isEditPolicy()){
492 commonClassDao.update(policyVersionDao);
494 commonClassDao.save(policyVersionDao);
497 PolicyElasticSearchController search= new PolicyElasticSearchController();
498 search.updateElk(policyData);
500 LOGGER.error("Error Occured while saving policy to Elastic Database"+e);
503 status = HttpStatus.OK;
504 response.setStatus(HttpServletResponse.SC_OK);
505 response.addHeader("successMapKey", "success");
506 response.addHeader("policyName", policyData.getNewFileName());
508 //get message from the SafetyCheckerResults if present
509 String safetyCheckerResponse = policyData.getClWarning();
510 String existingCLName = policyData.getExistingCLName();
512 //if safetyCheckerResponse is not null add a header to send back with response
513 if(safetyCheckerResponse!=null) {
514 PolicyLogger.info("SafetyCheckerResponse message: " + safetyCheckerResponse);
515 response.addHeader("safetyChecker", safetyCheckerResponse);
516 response.addHeader("newCLName", CLName);
517 response.addHeader("conflictCLName", existingCLName);
519 PolicyLogger.info("SafetyCheckerResponse was empty or null.");
522 }else if (successMap.containsKey("invalidAttribute")) {
523 String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid Action Attribute";
524 LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Could not fine " + policyData.getActionAttribute() + " in the ActionPolicyDict table.");
525 body = "invalidAttribute";
526 status = HttpStatus.BAD_REQUEST;
527 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
528 response.addHeader("invalidAttribute", policyData.getActionAttribute());
529 response.addHeader("error", message);
530 response.addHeader("policyName", policyData.getPolicyName());
531 }else if (successMap.containsKey("fwdberror")) {
532 policyDBDaoTransaction.rollbackTransaction();
534 status = HttpStatus.BAD_REQUEST;
535 String message = XACMLErrorConstants.ERROR_DATA_ISSUE
536 + "Error when inserting Firewall ConfigBody data into the database.";
537 PolicyLogger.error(message);
538 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
539 response.addHeader("error", message);
540 response.addHeader("policyName", policyData.getPolicyName());
541 } else if (successMap.get("error").equals("Validation Failed")) {
542 policyDBDaoTransaction.rollbackTransaction();
543 String message = XACMLErrorConstants.ERROR_DATA_ISSUE
544 + "Error Validating the Policy on the PAP.";
545 PolicyLogger.error(message);
547 status = HttpStatus.BAD_REQUEST;
548 response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
549 response.addHeader("error", message);
550 response.addHeader("policyName", policyData.getPolicyName());
552 policyDBDaoTransaction.rollbackTransaction();
554 status = HttpStatus.INTERNAL_SERVER_ERROR;
555 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
556 response.addHeader("error", "error");
559 LOGGER.error("Exception Occured : ",e);
560 if(policyDBDaoTransaction != null){
561 policyDBDaoTransaction.rollbackTransaction();
566 LOGGER.error("Exception Occured : "+e.getMessage(),e);
568 response.addHeader("error", e.getMessage());
569 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
571 return new ResponseEntity<>(body, status);
574 @ExceptionHandler({ HttpMessageNotReadableException.class })
575 public ResponseEntity<String> messageNotReadableExceptionHandler(HttpServletRequest req, HttpMessageNotReadableException exception) {
576 LOGGER.error("Request not readable: {}", exception);
577 StringBuilder message = new StringBuilder();
578 message.append(exception.getMessage());
579 if (exception.getCause() != null) {
580 message.append(" Reason Caused: "
581 + exception.getCause().getMessage());
583 return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST);
586 public PolicyVersion getPolicyVersionData(String dbCheckPolicyName){
587 PolicyVersion entityItem = (PolicyVersion) commonClassDao.getEntityItem(PolicyVersion.class, "policyName", dbCheckPolicyName);
588 if (entityItem != null) {
589 if(entityItem.getPolicyName().equals(dbCheckPolicyName)){