diff options
Diffstat (limited to 'ONAP-PAP-REST/src/main/java/org')
66 files changed, 28171 insertions, 0 deletions
diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/PAPRestConfig.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/PAPRestConfig.java new file mode 100644 index 000000000..fee4ed2cb --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/PAPRestConfig.java @@ -0,0 +1,145 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest; + +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + +import javax.annotation.PostConstruct; +import javax.sql.DataSource; + +import org.apache.tomcat.dbcp.dbcp2.BasicDataSource; +import org.hibernate.SessionFactory; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.context.annotation.Configuration; +import org.springframework.orm.hibernate4.HibernateTransactionManager; +import org.springframework.orm.hibernate4.LocalSessionFactoryBuilder; +import org.springframework.transaction.annotation.EnableTransactionManagement; +import org.springframework.web.servlet.config.annotation.EnableWebMvc; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter; + +@Configuration +@EnableWebMvc +@EnableTransactionManagement +@ComponentScan(basePackages = { "org.onap.*", "com.*" }) +public class PAPRestConfig extends WebMvcConfigurerAdapter { + private static final Logger LOGGER = FlexLogger.getLogger(PAPRestConfig.class); + + private static String dbDriver = null; + private static String dbUrl = null; + private static String dbUserName = null; + private static String dbPassword = null; + + @PostConstruct + public void init(){ + Properties prop = new Properties(); + InputStream input = null; + try { + input = new FileInputStream("xacml.pap.properties"); + // load a properties file + prop.load(input); + setDbDriver(prop.getProperty("javax.persistence.jdbc.driver")); + setDbUrl(prop.getProperty("javax.persistence.jdbc.url")); + setDbUserName(prop.getProperty("javax.persistence.jdbc.user")); + setDbPassword(prop.getProperty("javax.persistence.jdbc.password")); + }catch(Exception e){ + LOGGER.error("Exception Occured while loading properties file"+e); + }finally{ + if(input != null){ + try { + input.close(); + } catch (IOException e) { + LOGGER.error("Exception Occured while clsoing the stream"+e); + } + } + } + } + + @Bean(name = "dataSource") + public DataSource getDataSource() { + BasicDataSource dataSource = new BasicDataSource(); + dataSource.setDriverClassName(PAPRestConfig.getDbDriver()); + dataSource.setUrl(PAPRestConfig.getDbUrl()); + dataSource.setUsername(PAPRestConfig.getDbUserName()); + dataSource.setPassword(PAPRestConfig.getDbPassword()); + return dataSource; + } + + @Autowired + @Bean(name = "sessionFactory") + public SessionFactory getSessionFactory(DataSource dataSource) { + LocalSessionFactoryBuilder sessionBuilder = new LocalSessionFactoryBuilder(dataSource); + sessionBuilder.scanPackages("org.onap.*", "com.*"); + sessionBuilder.addProperties(getHibernateProperties()); + return sessionBuilder.buildSessionFactory(); + } + + private Properties getHibernateProperties() { + Properties properties = new Properties(); + properties.put("hibernate.show_sql", "true"); + properties.put("hibernate.dialect", "org.hibernate.dialect.MySQLDialect"); + return properties; + } + + @Autowired + @Bean(name = "transactionManager") + public HibernateTransactionManager getTransactionManager(SessionFactory sessionFactory) { + return new HibernateTransactionManager(sessionFactory); + } + + public static String getDbDriver() { + return dbDriver; + } + + public static void setDbDriver(String dbDriver) { + PAPRestConfig.dbDriver = dbDriver; + } + + public static String getDbUrl() { + return dbUrl; + } + + public static void setDbUrl(String dbUrl) { + PAPRestConfig.dbUrl = dbUrl; + } + + public static String getDbUserName() { + return dbUserName; + } + + public static void setDbUserName(String dbUserName) { + PAPRestConfig.dbUserName = dbUserName; + } + + public static String getDbPassword() { + return dbPassword; + } + + public static void setDbPassword(String dbPassword) { + PAPRestConfig.dbPassword = dbPassword; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/WebConfig.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/WebConfig.java new file mode 100644 index 000000000..89ab8bc8a --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/WebConfig.java @@ -0,0 +1,43 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest; + +import javax.servlet.ServletContext; +import javax.servlet.ServletRegistration; + +import org.springframework.web.WebApplicationInitializer; +import org.springframework.web.context.support.AnnotationConfigWebApplicationContext; +import org.springframework.web.servlet.DispatcherServlet; + +public class WebConfig implements WebApplicationInitializer { + + @Override + public void onStartup(ServletContext container) { + AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext(); + ctx.register(PAPRestConfig.class); + ctx.setServletContext(container); + ctx.refresh(); + ServletRegistration.Dynamic dispatcher = container.addServlet("dispatcher", new DispatcherServlet(ctx)); + dispatcher.setLoadOnStartup(1); + dispatcher.addMapping("/onap/*"); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java new file mode 100644 index 000000000..45f803f5a --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/XACMLPapServlet.java @@ -0,0 +1,2617 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.net.ConnectException; +import java.net.HttpURLConnection; +import java.net.InetAddress; +import java.net.MalformedURLException; +import java.net.SocketTimeoutException; +import java.net.URL; +import java.net.URLDecoder; +import java.net.UnknownHostException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Properties; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.CopyOnWriteArrayList; + +import javax.persistence.EntityManagerFactory; +import javax.persistence.Persistence; +import javax.persistence.PersistenceException; +import javax.servlet.Servlet; +import javax.servlet.ServletConfig; +import javax.servlet.ServletException; +import javax.servlet.annotation.WebInitParam; +import javax.servlet.annotation.WebServlet; +import javax.servlet.http.HttpServlet; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.io.IOUtils; +import org.onap.policy.common.ia.IntegrityAudit; +import org.onap.policy.common.im.AdministrativeStateException; +import org.onap.policy.common.im.ForwardProgressException; +import org.onap.policy.common.im.IntegrityMonitor; +import org.onap.policy.common.im.IntegrityMonitorProperties; +import org.onap.policy.common.im.StandbyStatusException; +import org.onap.policy.common.logging.ONAPLoggingContext; +import org.onap.policy.common.logging.ONAPLoggingUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.components.AutoPushPolicy; +import org.onap.policy.pap.xacml.rest.components.PolicyDBDao; +import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction; +import org.onap.policy.pap.xacml.rest.handler.APIRequestHandler; +import org.onap.policy.pap.xacml.rest.handler.PushPolicyHandler; +import org.onap.policy.pap.xacml.rest.handler.SavePolicyHandler; +import org.onap.policy.pap.xacml.restAuth.CheckPDP; +import org.onap.policy.rest.XACMLRest; +import org.onap.policy.rest.XACMLRestProperties; +import org.onap.policy.utils.PolicyUtils; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.api.pap.ONAPPapEngineFactory; +import org.onap.policy.xacml.api.pap.OnapPDP; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; +import org.onap.policy.xacml.api.pap.PAPPolicyEngine; +import org.onap.policy.xacml.std.pap.StdPAPPolicy; +import org.onap.policy.xacml.std.pap.StdPDP; +import org.onap.policy.xacml.std.pap.StdPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPItemSetChangeNotifier.StdItemSetChangeListener; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; +import org.onap.policy.xacml.std.pap.StdPDPStatus; + +import com.att.research.xacml.api.pap.PAPException; +import com.att.research.xacml.api.pap.PDPPolicy; +import com.att.research.xacml.api.pap.PDPStatus; +import com.att.research.xacml.util.FactoryException; +import com.att.research.xacml.util.XACMLProperties; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.base.Splitter; + +/** + * Servlet implementation class XacmlPapServlet + */ +@WebServlet( + description = "Implements the XACML PAP RESTful API.", + urlPatterns = { "/" }, + loadOnStartup=1, + initParams = { + @WebInitParam(name = "XACML_PROPERTIES_NAME", value = "xacml.pap.properties", description = "The location of the properties file holding configuration information.") + }) +public class XACMLPapServlet extends HttpServlet implements StdItemSetChangeListener, Runnable { + private static final long serialVersionUID = 1L; + private static final Logger LOGGER = FlexLogger.getLogger(XACMLPapServlet.class); + // audit (transaction) LOGGER + private static final Logger auditLogger = FlexLogger.getLogger("auditLogger"); + //Persistence Unit for JPA + private static final String PERSISTENCE_UNIT = "XACML-PAP-REST"; + private static final String AUDIT_PAP_PERSISTENCE_UNIT = "auditPapPU"; + // Client Headers. + private static final String ENVIRONMENT_HEADER = "Environment"; + /* + * List of Admin Console URLs. + * Used to send notifications when configuration changes. + * + * The CopyOnWriteArrayList *should* protect from concurrency errors. + * This list is seldom changed but often read, so the costs of this approach make sense. + */ + private static final CopyOnWriteArrayList<String> adminConsoleURLStringList = new CopyOnWriteArrayList<String>(); + + private static String CONFIG_HOME; + private static String ACTION_HOME; + /* + * This PAP instance's own URL. + * Need this when creating URLs to send to the PDPs so they can GET the Policy files from this process. + */ + private static String papURL = null; + // The heartbeat thread. + private static Heartbeat heartbeat = null; + private static Thread heartbeatThread = null; + //The entity manager factory for JPA access + private static EntityManagerFactory emf; + private static PolicyDBDao policyDBDao; + /* + * papEngine - This is our engine workhorse that manages the PDP Groups and Nodes. + */ + private static PAPPolicyEngine papEngine = null; + /* + * These are the parameters needed for DB access from the PAP + */ + private static int papIntegrityAuditPeriodSeconds = -1; + private static String papDbDriver = null; + private static String papDbUrl = null; + private static String papDbUser = null; + private static String papDbPassword = null; + private static Integer papTransWait = null; + private static Integer papTransTimeout = null; + private static Integer papAuditTimeout = null; + private static Boolean papAuditFlag = null; + private static Boolean papFileSystemAudit = null; + private static Boolean autoPushFlag = false; + private static String papResourceName = null; + private static Integer fpMonitorInterval = null; + private static Integer failedCounterThreshold = null; + private static Integer testTransInterval = null; + private static Integer writeFpcInterval = null; + private static String papSiteName=null; + private static String papNodeType=null; + private static String papDependencyGroups = null; + private static String[] papDependencyGroupsFlatArray = null; + private static String environment = null; + private static String pdpFile = null; + + private String storedRequestId = null; + private IntegrityMonitor im; + private IntegrityAudit ia; + + //MicroService Model Properties + private static String msOnapName; + private static String msPolicyName; + /* + * This thread may be invoked upon startup to initiate sending PDP policy/pip configuration when + * this servlet starts. Its configurable by the admin. + */ + private Thread initiateThread = null; + private ONAPLoggingContext baseLoggingContext = null; + private AutoPushPolicy autoPushPolicy; + + /** + * @see HttpServlet#HttpServlet() + */ + public XACMLPapServlet() { + super(); + } + + /** + * @see Servlet#init(ServletConfig) + */ + public void init(ServletConfig config) throws ServletException { + try { + // Logging + baseLoggingContext = new ONAPLoggingContext(); + // fixed data that will be the same in all logging output goes here + try { + String hostname = InetAddress.getLocalHost().getCanonicalHostName(); + baseLoggingContext.setServer(hostname); + } catch (UnknownHostException e) { + LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Unable to get hostname for logging"); + } + // Initialize + XACMLRest.xacmlInit(config); + // Load the properties + XACMLRest.loadXacmlProperties(null, null); + /* + * Retrieve the property values + */ + CONFIG_HOME = getConfigHome(); + ACTION_HOME = getActionHome(); + papDbDriver = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_DRIVER); + if(papDbDriver == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papDbDriver property entry"); + throw new PAPException("papDbDriver is null"); + } + setPapDbDriver(papDbDriver); + papDbUrl = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_URL); + if(papDbUrl == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papDbUrl property entry"); + throw new PAPException("papDbUrl is null"); + } + setPapDbUrl(papDbUrl); + papDbUser = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_USER); + if(papDbUser == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papDbUser property entry"); + throw new PAPException("papDbUser is null"); + } + setPapDbUser(papDbUser); + papDbPassword = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_PASSWORD); + if(papDbPassword == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papDbPassword property entry"); + throw new PAPException("papDbPassword is null"); + } + setPapDbPassword(papDbPassword); + papResourceName = XACMLProperties.getProperty(XACMLRestProperties.PAP_RESOURCE_NAME); + if(papResourceName == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papResourceName property entry"); + throw new PAPException("papResourceName is null"); + } + papSiteName = XACMLProperties.getProperty(XACMLRestProperties.PAP_SITE_NAME); + if(papSiteName == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papSiteName property entry"); + throw new PAPException("papSiteName is null"); + } + papNodeType = XACMLProperties.getProperty(XACMLRestProperties.PAP_NODE_TYPE); + if(papNodeType == null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE,"XACMLPapServlet", " ERROR: Bad papNodeType property entry"); + throw new PAPException("papNodeType is null"); + } + environment = XACMLProperties.getProperty("ENVIRONMENT", "DEVL"); + //Integer will throw an exception of anything is missing or unrecognized + papTransWait = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT)); + papTransTimeout = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)); + papAuditTimeout = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_TIMEOUT)); + //Boolean will default to false if anything is missing or unrecognized + papAuditFlag = Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_RUN_AUDIT_FLAG)); + papFileSystemAudit = Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_FLAG)); + //PAP Auto Push + autoPushFlag = Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PUSH_FLAG)); + // if Auto push then Load with properties. + if(autoPushFlag){ + String file; + try{ + file = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PUSH_FILE); + if(file.endsWith(".properties")){ + autoPushPolicy = new AutoPushPolicy(file); + }else{ + throw new PAPException(); + } + }catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Missing property or not a proper property file check for: " + XACMLRestProperties.PROP_PAP_PUSH_FILE ); + LOGGER.info("Overriding the autoPushFlag to False..."); + autoPushFlag = false; + } + } + papDependencyGroups = XACMLProperties.getProperty(XACMLRestProperties.PAP_DEPENDENCY_GROUPS); + if(papDependencyGroups == null){ + throw new PAPException("papDependencyGroups is null"); + } + try{ + //Now we have flattened the array into a simple comma-separated list + papDependencyGroupsFlatArray = papDependencyGroups.split("[;,]"); + //clean up the entries + for (int i = 0 ; i < papDependencyGroupsFlatArray.length ; i ++){ + papDependencyGroupsFlatArray[i] = papDependencyGroupsFlatArray[i].trim(); + } + try{ + if(XACMLProperties.getProperty(XACMLRestProperties.PAP_INTEGRITY_AUDIT_PERIOD_SECONDS) != null){ + papIntegrityAuditPeriodSeconds = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PAP_INTEGRITY_AUDIT_PERIOD_SECONDS).trim()); + } + }catch(Exception e){ + String msg = "integrity_audit_period_seconds "; + LOGGER.error("\n\nERROR: " + msg + "Bad property entry: " + e.getMessage() + "\n"); + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " ERROR: " + msg +"Bad property entry"); + throw e; + } + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " ERROR: Bad property entry"); + throw e; + } + //Integer will throw an exception of anything is missing or unrecognized + fpMonitorInterval = Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.FP_MONITOR_INTERVAL)); + failedCounterThreshold = Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.FAILED_COUNTER_THRESHOLD)); + testTransInterval = Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.TEST_TRANS_INTERVAL)); + writeFpcInterval = Integer.parseInt(XACMLProperties.getProperty(IntegrityMonitorProperties.WRITE_FPC_INTERVAL)); + LOGGER.debug("\n\n\n**************************************" + + "\n**************************************" + + "\n" + + "\n papDbDriver = " + papDbDriver + + "\n papDbUrl = " + papDbUrl + + "\n papDbUser = " + papDbUser + + "\n papDbPassword = " + papDbPassword + + "\n papTransWait = " + papTransWait + + "\n papTransTimeout = " + papTransTimeout + + "\n papAuditTimeout = " + papAuditTimeout + + "\n papAuditFlag = " + papAuditFlag + + "\n papFileSystemAudit = " + papFileSystemAudit + + "\n autoPushFlag = " + autoPushFlag + + "\n papResourceName = " + papResourceName + + "\n fpMonitorInterval = " + fpMonitorInterval + + "\n failedCounterThreshold = " + failedCounterThreshold + + "\n testTransInterval = " + testTransInterval + + "\n writeFpcInterval = " + writeFpcInterval + + "\n papSiteName = " + papSiteName + + "\n papNodeType = " + papNodeType + + "\n papDependencyGroupsList = " + papDependencyGroups + + "\n papIntegrityAuditPeriodSeconds = " + papIntegrityAuditPeriodSeconds + + "\n\n**************************************" + + "\n**************************************"); + // Pull custom persistence settings + Properties properties; + try { + properties = XACMLProperties.getProperties(); + LOGGER.debug("\n\n\n**************************************" + + "\n**************************************" + + "\n\n" + + "properties = " + properties + + "\n\n**************************************"); + } catch (IOException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " Error loading properties with: " + + "XACMLProperties.getProperties()"); + throw new ServletException(e.getMessage(), e.getCause()); + } + //Micro Service Properties + msOnapName=properties.getProperty("xacml.policy.msOnapName"); + setMsOnapName(msOnapName); + msPolicyName=properties.getProperty("xacml.policy.msPolicyName"); + setMsPolicyName(msPolicyName); + // PDPId File location + XACMLPapServlet.pdpFile = XACMLProperties.getProperty(XACMLRestProperties.PROP_PDP_IDFILE); + if (XACMLPapServlet.pdpFile == null) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " The PDP Id Authentication File Property is not valid: " + + XACMLRestProperties.PROP_PDP_IDFILE); + throw new PAPException("The PDP Id Authentication File Property :"+ XACMLRestProperties.PROP_PDP_IDFILE+ " is not Valid. "); + } + // Create an IntegrityMonitor + im = IntegrityMonitor.getInstance(papResourceName,properties); + // Create an IntegrityAudit + ia = new IntegrityAudit(papResourceName, AUDIT_PAP_PERSISTENCE_UNIT, properties); + ia.startAuditThread(); + // Create the entity manager factory + emf = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT, properties); + if (emf == null) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Error creating entity manager factory with persistence unit: " + + PERSISTENCE_UNIT); + throw new ServletException("Unable to create Entity Manager Factory"); + } + // we are about to call the PDPs and give them their configuration. + // To do that we need to have the URL of this PAP so we can construct the Policy file URLs + XACMLPapServlet.papURL = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_URL); + //Create the policyDBDao + policyDBDao = PolicyDBDao.getPolicyDBDaoInstance(getEmf()); + // Load our PAP engine, first create a factory + ONAPPapEngineFactory factory = ONAPPapEngineFactory.newInstance(XACMLProperties.getProperty(XACMLProperties.PROP_PAP_PAPENGINEFACTORY)); + // The factory knows how to go about creating a PAP Engine + XACMLPapServlet.papEngine = (PAPPolicyEngine) factory.newEngine(); + PolicyDBDaoTransaction addNewGroup = null; + try{ + if(((org.onap.policy.xacml.std.pap.StdEngine)papEngine).wasDefaultGroupJustAdded){ + addNewGroup = policyDBDao.getNewTransaction(); + OnapPDPGroup group = papEngine.getDefaultGroup(); + addNewGroup.createGroup(group.getId(), group.getName(), group.getDescription(), "automaticallyAdded"); + addNewGroup.commitTransaction(); + addNewGroup = policyDBDao.getNewTransaction(); + addNewGroup.changeDefaultGroup(group, "automaticallyAdded"); + addNewGroup.commitTransaction(); + } + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " Error creating new default group in the database"); + if(addNewGroup != null){ + addNewGroup.rollbackTransaction(); + } + } + policyDBDao.setPapEngine((PAPPolicyEngine) XACMLPapServlet.papEngine); + //boolean performFileToDatabaseAudit = false; + if (Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_RUN_AUDIT_FLAG))){ + //get an AuditTransaction to lock out all other transactions + PolicyDBDaoTransaction auditTrans = policyDBDao.getNewAuditTransaction(); + policyDBDao.auditLocalDatabase(XACMLPapServlet.papEngine); + //release the transaction lock + auditTrans.close(); + } + + // Sanity check for URL. + if (XACMLPapServlet.papURL == null) { + throw new PAPException("The property " + XACMLRestProperties.PROP_PAP_URL + " is not valid: " + XACMLPapServlet.papURL); + } + // Configurable - have the PAP servlet initiate sending the latest PDP policy/pip configuration + // to all its known PDP nodes. + if (Boolean.parseBoolean(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INITIATE_PDP_CONFIG))) { + this.initiateThread = new Thread(this); + this.initiateThread.start(); + } + // After startup, the PAP does Heartbeat's to each of the PDPs periodically + XACMLPapServlet.heartbeat = new Heartbeat((PAPPolicyEngine) XACMLPapServlet.papEngine); + XACMLPapServlet.heartbeatThread = new Thread(XACMLPapServlet.heartbeat); + XACMLPapServlet.heartbeatThread.start(); + + } catch (FactoryException | PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Failed to create engine"); + throw new ServletException (XACMLErrorConstants.ERROR_SYSTEM_ERROR + "PAP not initialized; error: "+e); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Failed to create engine - unexpected error"); + throw new ServletException (XACMLErrorConstants.ERROR_SYSTEM_ERROR + "PAP not initialized; unexpected error: "+e); + } + } + + /** + * Thread used only during PAP startup to initiate change messages to all known PDPs. + * This must be on a separate thread so that any GET requests from the PDPs during this update can be serviced. + */ + @Override + public void run() { + // send the current configuration to all the PDPs that we know about + changed(); + } + + /** + * @see Servlet#destroy() + * + * Depending on how this servlet is run, we may or may not care about cleaning up the resources. + * For now we assume that we do care. + */ + public void destroy() { + // Make sure our threads are destroyed + if (XACMLPapServlet.heartbeatThread != null) { + // stop the heartbeat + try { + if (XACMLPapServlet.heartbeat != null) { + XACMLPapServlet.heartbeat.terminate(); + } + XACMLPapServlet.heartbeatThread.interrupt(); + XACMLPapServlet.heartbeatThread.join(); + } catch (InterruptedException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Error stopping heartbeat"); + } + } + if (this.initiateThread != null) { + try { + this.initiateThread.interrupt(); + this.initiateThread.join(); + } catch (InterruptedException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Error stopping thread"); + } + } + } + + /** + * Called by: + * - PDP nodes to register themselves with the PAP, and + * - Admin Console to make changes in the PDP Groups. + * + * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) + */ + protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext); + loggingContext.transactionStarted(); + loggingContext.setServiceName("PAP.post"); + if ((loggingContext.getRequestID() == null) || (loggingContext.getRequestID() == "")){ + UUID requestID = UUID.randomUUID(); + loggingContext.setRequestID(requestID.toString()); + PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doPost) so we generated one"); + } else { + PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doPost)"); + } + PolicyDBDaoTransaction pdpTransaction = null; + try { + im.startTransaction(); + } catch (AdministrativeStateException ae){ + String message = "POST interface called for PAP " + papResourceName + " but it has an Administrative" + + " state of " + im.getStateManager().getAdminState() + + "\n Exception Message: " + ae.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (StandbyStatusException se) { + String message = "POST interface called for PAP " + papResourceName + " but it has a Standby Status" + + " of " + im.getStateManager().getStandbyStatus() + + "\n Exception Message: " + se.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + } + try { + XACMLRest.dumpRequest(request); + // since getParameter reads the content string, explicitly get the content before doing that. + // Simply getting the inputStream seems to protect it against being consumed by getParameter. + request.getInputStream(); + String groupId = request.getParameter("groupId"); + String apiflag = request.getParameter("apiflag"); + if(groupId != null) { + // Is this from the Admin Console or API? + if(apiflag!=null && apiflag.equalsIgnoreCase("api")) { + // this is from the API so we need to check the client credentials before processing the request + if(!authorizeRequest(request)){ + String message = "PEP not Authorized for making this Request!!"; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + im.endTransaction(); + return; + } + } + doACPost(request, response, groupId, loggingContext); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + // Request is from a PDP asking for its config. + loggingContext.setServiceName("PDP:PAP.register"); + // Get the PDP's ID + String id = this.getPDPID(request); + String jmxport = this.getPDPJMX(request); + LOGGER.info("Request(doPost) from PDP coming up: " + id); + // Get the PDP Object + OnapPDP pdp = XACMLPapServlet.papEngine.getPDP(id); + // Is it known? + if (pdp == null) { + LOGGER.info("Unknown PDP: " + id); + // Check PDP ID + if(CheckPDP.validateID(id)){ + pdpTransaction = policyDBDao.getNewTransaction(); + try { + pdpTransaction.addPdpToGroup(id, XACMLPapServlet.papEngine.getDefaultGroup().getId(), id, "Registered on first startup", Integer.parseInt(jmxport), "PDP autoregister"); + XACMLPapServlet.papEngine.newPDP(id, XACMLPapServlet.papEngine.getDefaultGroup(), id, "Registered on first startup", Integer.parseInt(jmxport)); + } catch (NullPointerException | PAPException | IllegalArgumentException | IllegalStateException | PersistenceException e) { + pdpTransaction.rollbackTransaction(); + String message = "Failed to create new PDP for id: " + id; + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage()); + im.endTransaction(); + return; + } + // get the PDP we just created + pdp = XACMLPapServlet.papEngine.getPDP(id); + if (pdp == null) { + if(pdpTransaction != null){ + pdpTransaction.rollbackTransaction(); + } + String message = "Failed to create new PDP for id: " + id; + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + im.endTransaction(); + return; + } + } else { + String message = "PDP is Unauthorized to Connect to PAP: "+ id; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "PDP not Authorized to connect to this PAP. Please contact the PAP Admin for registration."); + PolicyLogger.audit("Transaction Failed - See Error.log"); + im.endTransaction(); + return; + } + try{ + pdpTransaction.commitTransaction(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", "Could not commit transaction to put pdp in the database"); + } + } + if (jmxport != null && jmxport != ""){ + ((StdPDP) pdp).setJmxPort(Integer.valueOf(jmxport)); + } + // Get the PDP's Group + OnapPDPGroup group = XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp); + if (group == null) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " PDP not associated with any group, even the default"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_UNAUTHORIZED, "PDP not associated with any group, even the default"); + im.endTransaction(); + return; + } + // Determine what group the PDP node is in and get + // its policy/pip properties. + Properties policies = group.getPolicyProperties(); + Properties pipconfig = group.getPipConfigProperties(); + // Get the current policy/pip configuration that the PDP has + Properties pdpProperties = new Properties(); + pdpProperties.load(request.getInputStream()); + LOGGER.info("PDP Current Properties: " + pdpProperties.toString()); + LOGGER.info("Policies: " + (policies != null ? policies.toString() : "null")); + LOGGER.info("Pip config: " + (pipconfig != null ? pipconfig.toString() : "null")); + // Validate the node's properties + boolean isCurrent = this.isPDPCurrent(policies, pipconfig, pdpProperties); + // Send back current configuration + if (isCurrent == false) { + // Tell the PDP we are sending back the current policies/pip config + LOGGER.info("PDP configuration NOT current."); + if (policies != null) { + // Put URL's into the properties in case the PDP needs to + // retrieve them. + this.populatePolicyURL(request.getRequestURL(), policies); + // Copy the properties to the output stream + policies.store(response.getOutputStream(), ""); + } + if (pipconfig != null) { + // Copy the properties to the output stream + pipconfig.store(response.getOutputStream(), ""); + } + // We are good - and we are sending them information + response.setStatus(HttpServletResponse.SC_OK); + setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH); + } else { + // Tell them they are good + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE); + } + // tell the AC that something changed + notifyAC(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + } catch (PAPException e) { + if(pdpTransaction != null){ + pdpTransaction.rollbackTransaction(); + } + LOGGER.debug(XACMLErrorConstants.ERROR_PROCESS_FLOW + "POST exception: " + e, e); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + im.endTransaction(); + return; + } + //Catch anything that fell through + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended"); + im.endTransaction(); + } + + /** + * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response) + */ + protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext); + loggingContext.transactionStarted(); + loggingContext.setServiceName("PAP.get"); + if ((loggingContext.getRequestID() == null) || (loggingContext.getRequestID() == "")){ + UUID requestID = UUID.randomUUID(); + loggingContext.setRequestID(requestID.toString()); + PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doGet) so we generated one"); + } else { + PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doGet)"); + } + try { + XACMLRest.dumpRequest(request); + String pathInfo = request.getRequestURI(); + LOGGER.info("path info: " + pathInfo); + if (pathInfo != null){ + //DO NOT do a im.startTransaction for the test request + if (pathInfo.equals("/pap/test")) { + testService(loggingContext, response); + return; + } + } + //This im.startTransaction() covers all other Get transactions + try { + im.startTransaction(); + } catch (AdministrativeStateException ae){ + String message = "GET interface called for PAP " + papResourceName + " but it has an Administrative" + + " state of " + im.getStateManager().getAdminState() + + "\n Exception Message: " + ae.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (StandbyStatusException se) { + String message = "GET interface called for PAP " + papResourceName + " but it has a Standby Status" + + " of " + im.getStateManager().getStandbyStatus() + + "\n Exception Message: " + se.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + } + // Request from the API to get the gitPath + String apiflag = request.getParameter("apiflag"); + if (apiflag!=null) { + if(authorizeRequest(request)){ + APIRequestHandler apiRequestHandler = new APIRequestHandler(); + apiRequestHandler.doGet(request,response, apiflag); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } else { + String message = "PEP not Authorized for making this Request!! \n Contact Administrator for this Scope. "; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + im.endTransaction(); + return; + } + } + // Is this from the Admin Console? + String groupId = request.getParameter("groupId"); + if (groupId != null) { + // this is from the Admin Console, so handle separately + doACGet(request, response, groupId, loggingContext); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + // Get the PDP's ID + String id = this.getPDPID(request); + LOGGER.info("doGet from: " + id); + // Get the PDP Object + OnapPDP pdp = XACMLPapServlet.papEngine.getPDP(id); + // Is it known? + if (pdp == null) { + // Check if request came from localhost + if (request.getRemoteHost().equals("localhost") || + request.getRemoteHost().equals("127.0.0.1") || + request.getRemoteHost().equals(request.getLocalAddr())) { + // Return status information - basically all the groups + loggingContext.setServiceName("PAP.getGroups"); + Set<OnapPDPGroup> groups = papEngine.getOnapPDPGroups(); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), groups); + response.setHeader("content-type", "application/json"); + response.setStatus(HttpServletResponse.SC_OK); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + String message = "Unknown PDP: " + id + " from " + request.getRemoteHost() + " us: " + request.getLocalAddr(); + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_UNAUTHORIZED, message); + im.endTransaction(); + return; + } + loggingContext.setServiceName("PAP.getPolicy"); + // Get the PDP's Group + OnapPDPGroup group = XACMLPapServlet.papEngine.getPDPGroup((OnapPDP) pdp); + if (group == null) { + String message = "No group associated with pdp " + pdp.getId(); + LOGGER.warn(XACMLErrorConstants.ERROR_PERMISSIONS + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_UNAUTHORIZED, message); + im.endTransaction(); + return; + } + // Which policy do they want? + String policyId = request.getParameter("id"); + if (policyId == null) { + String message = "Did not specify an id for the policy"; + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + im.endTransaction(); + return; + } + PDPPolicy policy = group.getPolicy(policyId); + if (policy == null) { + String message = "Unknown policy: " + policyId; + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + im.endTransaction(); + return; + } + LOGGER.warn("PolicyDebugging: Policy Validity: " + policy.isValid() + "\n " + + "Policy Name : " + policy.getName() + "\n Policy URI: " + policy.getLocation().toString()); + try (InputStream is = new FileInputStream(((StdPDPGroup)group).getDirectory().toString()+File.separator+policyId); OutputStream os = response.getOutputStream()) { + // Send the policy back + IOUtils.copy(is, os); + response.setStatus(HttpServletResponse.SC_OK); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + } catch (IOException e) { + String message = "Failed to open policy id " + policyId; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + } + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN, e, "XACMLPapServlet", " GET exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + im.endTransaction(); + return; + } + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended"); + im.endTransaction(); + } + + /** + * @see HttpServlet#doPut(HttpServletRequest request, HttpServletResponse response) + */ + protected void doPut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext); + storedRequestId = loggingContext.getRequestID(); + loggingContext.transactionStarted(); + loggingContext.setServiceName("PAP.put"); + if ((loggingContext.getRequestID() == null) || (loggingContext.getRequestID() == "")){ + UUID requestID = UUID.randomUUID(); + loggingContext.setRequestID(requestID.toString()); + PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doPut) so we generated one"); + } else { + PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doPut)"); + } + try { + im.startTransaction(); + } catch (AdministrativeStateException ae){ + String message = "PUT interface called for PAP " + papResourceName + " but it has an Administrative" + + " state of " + im.getStateManager().getAdminState() + + "\n Exception Message: " + ae.getMessage(); + LOGGER.info(message +ae); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (StandbyStatusException se) { + String message = "PUT interface called for PAP " + papResourceName + " but it has a Standby Status" + + " of " + im.getStateManager().getStandbyStatus() + + "\n Exception Message: " + se.getMessage(); + LOGGER.info(message +se); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + } + XACMLRest.dumpRequest(request); + //need to check if request is from the API or Admin console + String apiflag = request.getParameter("apiflag"); + //This would occur if a PolicyDBDao notification was received + String policyDBDaoRequestUrl = request.getParameter("policydbdaourl"); + if(policyDBDaoRequestUrl != null){ + String policyDBDaoRequestEntityId = request.getParameter("entityid"); + //String policyDBDaoRequestEntityType = request.getParameter("entitytype"); + String policyDBDaoRequestEntityType = request.getParameter("entitytype"); + String policyDBDaoRequestExtraData = request.getParameter("extradata"); + if(policyDBDaoRequestEntityId == null || policyDBDaoRequestEntityType == null){ + response.sendError(400, "entityid or entitytype not supplied"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + policyDBDao.handleIncomingHttpNotification(policyDBDaoRequestUrl,policyDBDaoRequestEntityId,policyDBDaoRequestEntityType,policyDBDaoRequestExtraData,this); + response.setStatus(200); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + /* + * Request for ImportService + */ + String importService = request.getParameter("importService"); + if (importService != null) { + if(authorizeRequest(request)){ + APIRequestHandler apiRequestHandler = new APIRequestHandler(); + apiRequestHandler.doPut(request, response, importService); + im.endTransaction(); + return; + } else { + String message = "PEP not Authorized for making this Request!! \n Contact Administrator for this Scope. "; + LOGGER.error(XACMLErrorConstants.ERROR_PERMISSIONS + message ); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + return; + } + } + //This would occur if we received a notification of a policy rename from AC + String oldPolicyName = request.getParameter("oldPolicyName"); + String newPolicyName = request.getParameter("newPolicyName"); + if(oldPolicyName != null && newPolicyName != null){ + if(LOGGER.isDebugEnabled()){ + LOGGER.debug("\nXACMLPapServlet.doPut() - before decoding" + + "\npolicyToCreateUpdate = " + " "); + } + //decode it + try{ + oldPolicyName = URLDecoder.decode(oldPolicyName, "UTF-8"); + newPolicyName = URLDecoder.decode(newPolicyName, "UTF-8"); + if(LOGGER.isDebugEnabled()){ + LOGGER.debug("\nXACMLPapServlet.doPut() - after decoding" + + "\npolicyToCreateUpdate = " + " "); + } + } catch(UnsupportedEncodingException e){ + PolicyLogger.error("\nXACMLPapServlet.doPut() - Unsupported URL encoding of policyToCreateUpdate (UTF-8)" + + "\npolicyToCreateUpdate = " + " "); + response.sendError(500,"policyToCreateUpdate encoding not supported" + + "\nfailure with the following exception: " + e); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See error.log"); + im.endTransaction(); + return; + } + //send it to PolicyDBDao + PolicyDBDaoTransaction renameTransaction = policyDBDao.getNewTransaction(); + try{ + renameTransaction.renamePolicy(oldPolicyName,newPolicyName, "XACMLPapServlet.doPut"); + }catch(Exception e){ + renameTransaction.rollbackTransaction(); + response.sendError(500,"createUpdateTransaction.createPolicy(policyToCreateUpdate, XACMLPapServlet.doPut) " + + "\nfailure with the following exception: " + e); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See error.log"); + im.endTransaction(); + return; + } + renameTransaction.commitTransaction(); + response.setStatus(HttpServletResponse.SC_OK); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + // + // See if this is Admin Console registering itself with us + // + String acURLString = request.getParameter("adminConsoleURL"); + if (acURLString != null) { + loggingContext.setServiceName("AC:PAP.register"); + // remember this Admin Console for future updates + if ( ! adminConsoleURLStringList.contains(acURLString)) { + adminConsoleURLStringList.add(acURLString); + } + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Admin Console registering with URL: " + acURLString); + } + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + /* + * This is to update the PDP Group with the policy/policies being pushed + * Part of a 2 step process to push policies to the PDP that can now be done + * From both the Admin Console and the PolicyEngine API + */ + String groupId = request.getParameter("groupId"); + if (groupId != null) { + if(apiflag!=null){ + if(!authorizeRequest(request)){ + String message = "PEP not Authorized for making this Request!! \n Contact Administrator for this Scope. "; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + return; + } + if(apiflag.equalsIgnoreCase("addPolicyToGroup")){ + updateGroupsFromAPI(request, response, groupId, loggingContext); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + } + // this is from the Admin Console, so handle separately + doACPut(request, response, groupId, loggingContext); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + // + // Request is for policy validation and creation + // + if (apiflag != null && apiflag.equalsIgnoreCase("admin")){ + // this request is from the Admin Console + SavePolicyHandler savePolicyHandler = SavePolicyHandler.getInstance(); + savePolicyHandler.doPolicyAPIPut(request, response); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } else if (apiflag != null && apiflag.equalsIgnoreCase("api")) { + // this request is from the Policy Creation API + if(authorizeRequest(request)){ + APIRequestHandler apiRequestHandler = new APIRequestHandler(); + apiRequestHandler.doPut(request, response, request.getHeader("ClientScope")); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } else { + String message = "PEP not Authorized for making this Request!!"; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + im.endTransaction(); + return; + } + } + // We do not expect anything from anywhere else. + // This method is here in case we ever need to support other operations. + LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Request does not have groupId or apiflag"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Request does not have groupId or apiflag"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See error.log"); + im.endTransaction(); + } + + /** + * @see HttpServlet#doDelete(HttpServletRequest request, HttpServletResponse response) + */ + protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + ONAPLoggingContext loggingContext = ONAPLoggingUtils.getLoggingContextForRequest(request, baseLoggingContext); + loggingContext.transactionStarted(); + loggingContext.setServiceName("PAP.delete"); + if ((loggingContext.getRequestID() == null) || (loggingContext.getRequestID() == "")){ + UUID requestID = UUID.randomUUID(); + loggingContext.setRequestID(requestID.toString()); + PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (doDelete) so we generated one"); + } else { + PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (doDelete)"); + } + try { + im.startTransaction(); + } catch (AdministrativeStateException ae){ + String message = "DELETE interface called for PAP " + papResourceName + " but it has an Administrative" + + " state of " + im.getStateManager().getAdminState() + + "\n Exception Message: " + ae.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (StandbyStatusException se) { + String message = "PUT interface called for PAP " + papResourceName + " but it has a Standby Status" + + " of " + im.getStateManager().getStandbyStatus() + + "\n Exception Message: " + se.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + } + XACMLRest.dumpRequest(request); + String groupId = request.getParameter("groupId"); + String apiflag = request.getParameter("apiflag"); + if (groupId != null) { + // Is this from the Admin Console or API? + if(apiflag!=null) { + if(!authorizeRequest(request)){ + String message = "PEP not Authorized for making this Request!! \n Contact Administrator for this Scope. "; + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_FORBIDDEN, message); + return; + } + APIRequestHandler apiRequestHandler = new APIRequestHandler(); + try { + apiRequestHandler.doDelete(request, response, loggingContext, apiflag); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + if(apiRequestHandler.getNewGroup()!=null){ + groupChanged(apiRequestHandler.getNewGroup()); + } + return; + } + // this is from the Admin Console, so handle separately + doACDelete(request, response, groupId, loggingContext); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended Successfully"); + im.endTransaction(); + return; + } + //Catch anything that fell through + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Request does not have groupId"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Request does not have groupId"); + im.endTransaction(); + } + + private boolean isPDPCurrent(Properties policies, Properties pipconfig, Properties pdpProperties) { + String localRootPolicies = policies.getProperty(XACMLProperties.PROP_ROOTPOLICIES); + String localReferencedPolicies = policies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES); + if (localRootPolicies == null || localReferencedPolicies == null) { + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + "Missing property on PAP server: RootPolicies="+localRootPolicies+" ReferencedPolicies="+localReferencedPolicies); + return false; + } + // Compare the policies and pipconfig properties to the pdpProperties + try { + // the policy properties includes only xacml.rootPolicies and + // xacml.referencedPolicies without any .url entries + Properties pdpPolicies = XACMLProperties.getPolicyProperties(pdpProperties, false); + Properties pdpPipConfig = XACMLProperties.getPipProperties(pdpProperties); + if (localRootPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_ROOTPOLICIES)) && + localReferencedPolicies.equals(pdpPolicies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES)) && + pdpPipConfig.equals(pipconfig)) { + // The PDP is current + return true; + } + } catch (Exception e) { + // we get here if the PDP did not include either xacml.rootPolicies or xacml.pip.engines, + // or if there are policies that do not have a corresponding ".url" property. + // Either of these cases means that the PDP is not up-to-date, so just drop-through to return false. + PolicyLogger.error(MessageCodes.ERROR_SCHEMA_INVALID, e, "XACMLPapServlet", " PDP Error"); + } + return false; + } + + private void populatePolicyURL(StringBuffer urlPath, Properties policies) { + String lists[] = new String[2]; + lists[0] = policies.getProperty(XACMLProperties.PROP_ROOTPOLICIES); + lists[1] = policies.getProperty(XACMLProperties.PROP_REFERENCEDPOLICIES); + for (String list : lists) { + if (list != null && list.isEmpty() == false) { + for (String id : Splitter.on(',').trimResults().omitEmptyStrings().split(list)) { + String url = urlPath + "?id=" + id; + LOGGER.info("Policy URL for " + id + ": " + url); + policies.setProperty(id + ".url", url); + } + } + } + } + + protected String getPDPID(HttpServletRequest request) { + String pdpURL = request.getHeader(XACMLRestProperties.PROP_PDP_HTTP_HEADER_ID); + if (pdpURL == null || pdpURL.isEmpty()) { + // Should send back its port for identification + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + "PDP did not send custom header"); + pdpURL = ""; + } + return pdpURL; + } + + protected String getPDPJMX(HttpServletRequest request) { + String pdpJMMX = request.getHeader(XACMLRestProperties.PROP_PDP_HTTP_HEADER_JMX_PORT); + if (pdpJMMX == null || pdpJMMX.isEmpty()) { + // Should send back its port for identification + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + "PDP did not send custom header for JMX Port so the value of 0 is assigned"); + return null; + } + return pdpJMMX; + } + + /** + * Requests from the PolicyEngine API to update the PDP Group with pushed policy + * + * @param request + * @param response + * @param groupId + * @param loggingContext + * @throws ServletException + * @throws IOException + */ + public void updateGroupsFromAPI(HttpServletRequest request, HttpServletResponse response, String groupId, ONAPLoggingContext loggingContext) throws IOException { + PolicyDBDaoTransaction acPutTransaction = policyDBDao.getNewTransaction(); + try { + // for PUT operations the group may or may not need to exist before the operation can be done + StdPDPGroup group = (StdPDPGroup) papEngine.getGroup(groupId); + // get the request input stream content into a String + String json = null; + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + PolicyLogger.info("JSON request from PolicyEngine API: " + json); + // convert Object sent as JSON into local object + StdPDPPolicy policy = PolicyUtils.jsonStringToObject(json, StdPDPPolicy.class); + Set<PDPPolicy> policies = new HashSet<>(); + if(policy!=null){ + policies.add(policy); + } + //Get the current policies from the Group and Add the new one + Set<PDPPolicy> currentPoliciesInGroup = new HashSet<>(); + currentPoliciesInGroup = group.getPolicies(); + //If the selected policy is in the group we must remove it because the name is default + Iterator<PDPPolicy> policyIterator = policies.iterator(); + LOGGER.debug("policyIterator....." + policies); + while (policyIterator.hasNext()) { + PDPPolicy selPolicy = policyIterator.next(); + for (PDPPolicy existingPolicy : currentPoliciesInGroup) { + if (existingPolicy.getId().equals(selPolicy.getId())) { + group.removePolicyFromGroup(existingPolicy); + LOGGER.debug("Removing policy: " + existingPolicy); + break; + } + } + } + //Update the PDP Group after removing old version of policy + Set<PDPPolicy> updatedPoliciesInGroup = new HashSet<>(); + updatedPoliciesInGroup = group.getPolicies(); + //need to remove the policy with default name from group + for (PDPPolicy updatedPolicy : currentPoliciesInGroup) { + if (updatedPolicy.getName().equalsIgnoreCase("default")) { + group.removePolicyFromGroup(updatedPolicy); + break; + } + } + if(updatedPoliciesInGroup!=null){ + policies.addAll(updatedPoliciesInGroup); + } + group.setPolicies(policies); + // Assume that this is an update of an existing PDP Group + loggingContext.setServiceName("PolicyEngineAPI:PAP.updateGroup"); + try{ + acPutTransaction.updateGroup(group, "XACMLPapServlet.doACPut"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Error while updating group in the database: " + +"group="+group.getId()); + throw new PAPException(e.getMessage()); + } + papEngine.updateGroup(group); + String policyId = "empty"; + if(policy!=null){ + policyId = policy.getId(); + } + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + response.addHeader("operation", "push"); + response.addHeader("policyId", policyId); + response.addHeader("groupId", groupId); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Group '" + group.getId() + "' updated"); + } + acPutTransaction.commitTransaction(); + notifyAC(); + // Group changed, which might include changing the policies + groupChanged(group); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + + if (policy != null && ((policy.getId().contains("Config_MS_")) || (policy.getId().contains("BRMS_Param")))) { + PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance(); + if (pushPolicyHandler.preSafetyCheck(policy, CONFIG_HOME)) { + LOGGER.debug("Precheck Successful."); + } + } + + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } catch (PAPException e) { + acPutTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " API PUT exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + String message = XACMLErrorConstants.ERROR_PROCESS_FLOW + "Exception in request to update group from API - See Error.log on on the PAP."; + response.sendError(500, e.getMessage()); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error","addGroupError"); + response.addHeader("message", message); + return; + } + } + + /** + * Requests from the Admin Console for operations not on single specific objects + * + * @param request + * @param response + * @param groupId + * @param loggingContext + * @throws ServletException + * @throws IOException + */ + private void doACPost(HttpServletRequest request, HttpServletResponse response, String groupId, ONAPLoggingContext loggingContext) throws ServletException, IOException { + PolicyDBDaoTransaction doACPostTransaction = null; + try { + String groupName = request.getParameter("groupName"); + String groupDescription = request.getParameter("groupDescription"); + String apiflag = request.getParameter("apiflag"); + if (groupName != null && groupDescription != null) { + // Args: group=<groupId> groupName=<name> groupDescription=<description> <= create a new group + loggingContext.setServiceName("AC:PAP.createGroup"); + String unescapedName = URLDecoder.decode(groupName, "UTF-8"); + String unescapedDescription = URLDecoder.decode(groupDescription, "UTF-8"); + PolicyDBDaoTransaction newGroupTransaction = policyDBDao.getNewTransaction(); + try { + newGroupTransaction.createGroup(PolicyDBDao.createNewPDPGroupId(unescapedName), unescapedName, unescapedDescription,"XACMLPapServlet.doACPost"); + papEngine.newGroup(unescapedName, unescapedDescription); + newGroupTransaction.commitTransaction(); + } catch (Exception e) { + newGroupTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Unable to create new group"); + loggingContext.transactionEnded(); + + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, "Unable to create new group '" + groupId + "'"); + return; + } + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("New Group '" + groupId + "' created"); + } + // tell the Admin Consoles there is a change + notifyAC(); + // new group by definition has no PDPs, so no need to notify them of changes + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + // for all remaining POST operations the group must exist before the operation can be done + OnapPDPGroup group = papEngine.getGroup(groupId); + if (group == null) { + String message = "Unknown groupId '" + groupId + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + if (apiflag!=null){ + response.addHeader("error", "unknownGroupId"); + response.addHeader("operation", "push"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + } else { + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + } + return; + } + // determine the operation needed based on the parameters in the request + if (request.getParameter("policyId") != null) { + // Args: group=<groupId> policy=<policyId> <= copy file + // copy a policy from the request contents into a file in the group's directory on this machine + if(apiflag!=null){ + loggingContext.setServiceName("PolicyEngineAPI:PAP.postPolicy"); + } else { + loggingContext.setServiceName("AC:PAP.postPolicy"); + } + String policyId = request.getParameter("policyId"); + PolicyDBDaoTransaction addPolicyToGroupTransaction = policyDBDao.getNewTransaction(); + try { + InputStream is = null; + File temp= null; + if (apiflag != null){ + // get the request content into a String if the request is from API + String json = null; + // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file) + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + LOGGER.info("JSON request from API: " + json); + // convert Object sent as JSON into local object + ObjectMapper mapper = new ObjectMapper(); + Object objectFromJSON = mapper.readValue(json, StdPAPPolicy.class); + StdPAPPolicy policy = (StdPAPPolicy) objectFromJSON; + temp = new File(policy.getLocation()); + is = new FileInputStream(temp); + } else { + is = request.getInputStream(); + } + addPolicyToGroupTransaction.addPolicyToGroup(group.getId(), policyId,"XACMLPapServlet.doACPost"); + if (apiflag != null){ + ((StdPDPGroup) group).copyPolicyToFile(policyId,"API", is); + } else { + String name = null; + if (policyId.endsWith(".xml")) { + name = policyId.replace(".xml", ""); + name = name.substring(0, name.lastIndexOf(".")); + } + ((StdPDPGroup) group).copyPolicyToFile(policyId, name, is); + } + if(is!=null && temp!=null){ + is.close(); + temp.delete(); + } + addPolicyToGroupTransaction.commitTransaction(); + } catch (Exception e) { + addPolicyToGroupTransaction.rollbackTransaction(); + String message = "Policy '" + policyId + "' not copied to group '" + groupId +"': " + e; + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + if (apiflag!=null){ + response.addHeader("error", "policyCopyError"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + } else { + response.sendError(500, message); + } + return; + } + // policy file copied ok and the Group was updated on the PDP + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + response.addHeader("operation", "push"); + response.addHeader("policyId", policyId); + response.addHeader("groupId", groupId); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("policy '" + policyId + "' copied to directory for group '" + groupId + "'"); + } + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else if (request.getParameter("default") != null) { + // Args: group=<groupId> default=true <= make default + // change the current default group to be the one identified in the request. + loggingContext.setServiceName("AC:PAP.setDefaultGroup"); + // This is a POST operation rather than a PUT "update group" because of the side-effect that the current default group is also changed. + // It should never be the case that multiple groups are currently marked as the default, but protect against that anyway. + PolicyDBDaoTransaction setDefaultGroupTransaction = policyDBDao.getNewTransaction(); + try { + setDefaultGroupTransaction.changeDefaultGroup(group, "XACMLPapServlet.doACPost"); + papEngine.SetDefaultGroup(group); + setDefaultGroupTransaction.commitTransaction(); + } catch (Exception e) { + setDefaultGroupTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Unable to set group"); + loggingContext.transactionEnded(); + + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, "Unable to set group '" + groupId + "' to default"); + return; + } + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Group '" + groupId + "' set to be default"); + } + // Notify the Admin Consoles that something changed + // For now the AC cannot handle anything more detailed than the whole set of PDPGroups, so just notify on that + //TODO - Future: FIGURE OUT WHAT LEVEL TO NOTIFY: 2 groups or entire set - currently notify AC to update whole configuration of all groups + notifyAC(); + // This does not affect any PDPs in the existing groups, so no need to notify them of this change + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else if (request.getParameter("pdpId") != null) { + doACPostTransaction = policyDBDao.getNewTransaction(); + // Args: group=<groupId> pdpId=<pdpId> <= move PDP to group + loggingContext.setServiceName("AC:PAP.movePDP"); + String pdpId = request.getParameter("pdpId"); + OnapPDP pdp = papEngine.getPDP(pdpId); + OnapPDPGroup originalGroup = papEngine.getPDPGroup((OnapPDP) pdp); + try{ + doACPostTransaction.movePdp(pdp, group, "XACMLPapServlet.doACPost"); + }catch(Exception e){ + doACPostTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", + " Error while moving pdp in the database: " + +"pdp="+pdp.getId()+",to group="+group.getId()); + throw new PAPException(e.getMessage()); + } + papEngine.movePDP((OnapPDP) pdp, group); + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("PDP '" + pdp.getId() +"' moved to group '" + group.getId() + "' set to be default"); + } + // update the status of both the original group and the new one + ((StdPDPGroup)originalGroup).resetStatus(); + ((StdPDPGroup)group).resetStatus(); + // Notify the Admin Consoles that something changed + // For now the AC cannot handle anything more detailed than the whole set of PDPGroups, so just notify on that + notifyAC(); + // Need to notify the PDP that it's config may have changed + pdpChanged(pdp); + doACPostTransaction.commitTransaction(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC POST exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + return; + } + } + + /** + * Requests from the Admin Console to GET info about the Groups and PDPs + * + * @param request + * @param response + * @param groupId + * @param loggingContext + * @throws ServletException + * @throws IOException + */ + private void doACGet(HttpServletRequest request, HttpServletResponse response, String groupId, ONAPLoggingContext loggingContext) throws ServletException, IOException { + try { + String parameterDefault = request.getParameter("default"); + String pdpId = request.getParameter("pdpId"); + String pdpGroup = request.getParameter("getPDPGroup"); + if ("".equals(groupId)) { + // request IS from AC but does not identify a group by name + if (parameterDefault != null) { + // Request is for the Default group (whatever its id) + loggingContext.setServiceName("AC:PAP.getDefaultGroup"); + OnapPDPGroup group = papEngine.getDefaultGroup(); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), group); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("GET Default group req from '" + request.getRequestURL() + "'"); + } + response.setStatus(HttpServletResponse.SC_OK); + response.setHeader("content-type", "application/json"); + response.getOutputStream().close(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else if (pdpId != null) { + // Request is related to a PDP + if (pdpGroup == null) { + // Request is for the (unspecified) group containing a given PDP + loggingContext.setServiceName("AC:PAP.getPDP"); + OnapPDP pdp = papEngine.getPDP(pdpId); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), pdp); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("GET pdp '" + pdpId + "' req from '" + request.getRequestURL() + "'"); + } + response.setStatus(HttpServletResponse.SC_OK); + response.setHeader("content-type", "application/json"); + response.getOutputStream().close(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else { + // Request is for the group containing a given PDP + loggingContext.setServiceName("AC:PAP.getGroupForPDP"); + OnapPDP pdp = papEngine.getPDP(pdpId); + OnapPDPGroup group = papEngine.getPDPGroup((OnapPDP) pdp); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), group); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("GET PDP '" + pdpId + "' Group req from '" + request.getRequestURL() + "'"); + } + response.setStatus(HttpServletResponse.SC_OK); + response.setHeader("content-type", "application/json"); + response.getOutputStream().close(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + } else { + // request is for top-level properties about all groups + loggingContext.setServiceName("AC:PAP.getAllGroups"); + Set<OnapPDPGroup> groups = papEngine.getOnapPDPGroups(); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), groups); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("GET All groups req"); + } + response.setStatus(HttpServletResponse.SC_OK); + response.setHeader("content-type", "application/json"); + response.getOutputStream().close(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + } + // for all other GET operations the group must exist before the operation can be done + OnapPDPGroup group = papEngine.getGroup(groupId); + if (group == null) { + String message = "Unknown groupId '" + groupId + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + return; + } + // Figure out which request this is based on the parameters + String policyId = request.getParameter("policyId"); + if (policyId != null) { + // retrieve a policy + loggingContext.setServiceName("AC:PAP.getPolicy"); + // convert response object to JSON and include in the response + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " GET Policy not implemented"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "GET Policy not implemented"); + } else { + // No other parameters, so return the identified Group + loggingContext.setServiceName("AC:PAP.getGroup"); + // convert response object to JSON and include in the response + ObjectMapper mapper = new ObjectMapper(); + mapper.writeValue(response.getOutputStream(), group); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("GET group '" + group.getId() + "' req from '" + request.getRequestURL() + "'"); + } + response.setStatus(HttpServletResponse.SC_OK); + response.setHeader("content-type", "application/json"); + response.getOutputStream().close(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + // Currently there are no other GET calls from the AC. + // The AC uses the "GET All Groups" operation to fill its local cache and uses that cache for all other GETs without calling the PAP. + // Other GETs that could be called: + // Specific Group (groupId=<groupId>) + // A Policy (groupId=<groupId> policyId=<policyId>) + // A PDP (groupId=<groupId> pdpId=<pdpId>) + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " UNIMPLEMENTED "); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED"); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC Get exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + return; + } + } + + /** + * Requests from the Admin Console to create new items or update existing ones + * + * @param request + * @param response + * @param groupId + * @param loggingContext + * @throws ServletException + * @throws IOException + */ + private void doACPut(HttpServletRequest request, HttpServletResponse response, String groupId, ONAPLoggingContext loggingContext) throws ServletException, IOException { + PolicyDBDaoTransaction acPutTransaction = policyDBDao.getNewTransaction(); + try { + // for PUT operations the group may or may not need to exist before the operation can be done + OnapPDPGroup group = papEngine.getGroup(groupId); + // determine the operation needed based on the parameters in the request + // for remaining operations the group must exist before the operation can be done + if (group == null) { + String message = "Unknown groupId '" + groupId + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + return; + } + if (request.getParameter("policy") != null) { + // group=<groupId> policy=<policyId> contents=policy file <= Create new policy file in group dir, or replace it if it already exists (do not touch properties) + loggingContext.setServiceName("AC:PAP.putPolicy"); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " PARTIALLY IMPLEMENTED!!! ACTUAL CHANGES SHOULD BE MADE BY PAP SERVLET!!! "); + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else if (request.getParameter("pdpId") != null) { + // ARGS: group=<groupId> pdpId=<pdpId/URL> <= create a new PDP or Update an Existing one + String pdpId = request.getParameter("pdpId"); + if (papEngine.getPDP(pdpId) == null) { + loggingContext.setServiceName("AC:PAP.createPDP"); + } else { + loggingContext.setServiceName("AC:PAP.updatePDP"); + } + // get the request content into a String + String json = null; + // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file) + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + LOGGER.info("JSON request from AC: " + json); + // convert Object sent as JSON into local object + ObjectMapper mapper = new ObjectMapper(); + Object objectFromJSON = mapper.readValue(json, StdPDP.class); + if (pdpId == null || + objectFromJSON == null || + ! (objectFromJSON instanceof StdPDP) || + ((StdPDP)objectFromJSON).getId() == null || + ! ((StdPDP)objectFromJSON).getId().equals(pdpId)) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " PDP new/update had bad input. pdpId=" + pdpId + " objectFromJSON="+objectFromJSON); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, "Bad input, pdpid="+pdpId+" object="+objectFromJSON); + } + StdPDP pdp = (StdPDP) objectFromJSON; + if(pdp != null){ + if (papEngine.getPDP(pdpId) == null) { + // this is a request to create a new PDP object + try{ + acPutTransaction.addPdpToGroup(pdp.getId(), group.getId(), pdp.getName(), + pdp.getDescription(), pdp.getJmxPort(),"XACMLPapServlet.doACPut"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Error while adding pdp to group in the database: " + +"pdp="+ (pdp.getId()) +",to group="+group.getId()); + throw new PAPException(e.getMessage()); + } + papEngine.newPDP(pdp.getId(), group, pdp.getName(), pdp.getDescription(), pdp.getJmxPort()); + } else { + try{ + acPutTransaction.updatePdp(pdp, "XACMLPapServlet.doACPut"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Error while updating pdp in the database: " + +"pdp="+ pdp.getId()); + throw new PAPException(e.getMessage()); + } + // this is a request to update the pdp + papEngine.updatePDP(pdp); + } + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("PDP '" + pdpId + "' created/updated"); + } + // adjust the group's state including the new PDP + ((StdPDPGroup)group).resetStatus(); + // tell the Admin Consoles there is a change + notifyAC(); + // this might affect the PDP, so notify it of the change + pdpChanged(pdp); + acPutTransaction.commitTransaction(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + }else{ + try{ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, "XACMLPapServlet", " Error while adding pdp to group in the database: " + +"pdp=null" + ",to group="+group.getId()); + throw new PAPException("PDP is null"); + } catch(Exception e){ + throw new PAPException("PDP is null" + e.getMessage() +e); + } + } + } else if (request.getParameter("pipId") != null) { + // group=<groupId> pipId=<pipEngineId> contents=pip properties <= add a PIP to pip config, or replace it if it already exists (lenient operation) + loggingContext.setServiceName("AC:PAP.putPIP"); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED"); + return; + } else { + // Assume that this is an update of an existing PDP Group + // ARGS: group=<groupId> <= Update an Existing Group + loggingContext.setServiceName("AC:PAP.updateGroup"); + // get the request content into a String + String json = null; + // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file) + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + LOGGER.info("JSON request from AC: " + json); + // convert Object sent as JSON into local object + ObjectMapper mapper = new ObjectMapper(); + Object objectFromJSON = mapper.readValue(json, StdPDPGroup.class); + if (objectFromJSON == null || ! (objectFromJSON instanceof StdPDPGroup) || + ! ((StdPDPGroup)objectFromJSON).getId().equals(group.getId())) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Group update had bad input. id=" + group.getId() + " objectFromJSON="+objectFromJSON); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, "Bad input, id="+group.getId() +" object="+objectFromJSON); + } + // The Path on the PAP side is not carried on the RESTful interface with the AC + // (because it is local to the PAP) + // so we need to fill that in before submitting the group for update + if(objectFromJSON != null){ + ((StdPDPGroup)objectFromJSON).setDirectory(((StdPDPGroup)group).getDirectory()); + } + try{ + acPutTransaction.updateGroup((StdPDPGroup)objectFromJSON, "XACMLPapServlet.doACPut"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " Error while updating group in the database: " + +"group="+group.getId()); + throw new PAPException(e.getMessage()); + } + + PushPolicyHandler pushPolicyHandler = PushPolicyHandler.getInstance(); + OnapPDPGroup updatedGroup = (StdPDPGroup)objectFromJSON; + if (pushPolicyHandler.preSafetyCheck(updatedGroup, CONFIG_HOME)) { + LOGGER.debug("Precheck Successful."); + } + + papEngine.updateGroup((StdPDPGroup)objectFromJSON); + + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Group '" + group.getId() + "' updated"); + } + acPutTransaction.commitTransaction(); + // tell the Admin Consoles there is a change + notifyAC(); + // Group changed, which might include changing the policies + groupChanged(group); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + } catch (PAPException e) { + acPutTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC PUT exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + return; + } + } + + /** + * Requests from the Admin Console to delete/remove items + * + * @param request + * @param response + * @param groupId + * @param loggingContext + * @throws ServletException + * @throws IOException + */ + private void doACDelete(HttpServletRequest request, HttpServletResponse response, String groupId, ONAPLoggingContext loggingContext) throws ServletException, IOException { + //This code is to allow deletes to propagate to the database since delete is not implemented + String isDeleteNotify = request.getParameter("isDeleteNotify"); + if(isDeleteNotify != null){ + String policyToDelete = request.getParameter("policyToDelete"); + try{ + policyToDelete = URLDecoder.decode(policyToDelete,"UTF-8"); + } catch(UnsupportedEncodingException e){ + PolicyLogger.error("Unsupported URL encoding of policyToDelete (UTF-8"); + response.sendError(500,"policyToDelete encoding not supported"); + return; + } + PolicyDBDaoTransaction deleteTransaction = policyDBDao.getNewTransaction(); + try{ + deleteTransaction.deletePolicy(policyToDelete); + } catch(Exception e){ + deleteTransaction.rollbackTransaction(); + response.sendError(500,"deleteTransaction.deleteTransaction(policyToDelete) " + + "\nfailure with the following exception: " + e); + return; + } + deleteTransaction.commitTransaction(); + response.setStatus(HttpServletResponse.SC_OK); + return; + } + PolicyDBDaoTransaction removePdpOrGroupTransaction = policyDBDao.getNewTransaction(); + try { + // for all DELETE operations the group must exist before the operation can be done + loggingContext.setServiceName("AC:PAP.delete"); + OnapPDPGroup group = papEngine.getGroup(groupId); + if (group == null) { + String message = "Unknown groupId '" + groupId + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, "Unknown groupId '" + groupId +"'"); + return; + } + // determine the operation needed based on the parameters in the request + if (request.getParameter("policy") != null) { + // group=<groupId> policy=<policyId> [delete=<true|false>] <= delete policy file from group + loggingContext.setServiceName("AC:PAP.deletePolicy"); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED"); + return; + } else if (request.getParameter("pdpId") != null) { + // ARGS: group=<groupId> pdpId=<pdpId> <= delete PDP + String pdpId = request.getParameter("pdpId"); + OnapPDP pdp = papEngine.getPDP(pdpId); + try{ + removePdpOrGroupTransaction.removePdpFromGroup(pdp.getId(),"XACMLPapServlet.doACDelete"); + } catch(Exception e){ + throw new PAPException(); + } + papEngine.removePDP((OnapPDP) pdp); + // adjust the status of the group, which may have changed when we removed this PDP + ((StdPDPGroup)group).resetStatus(); + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + notifyAC(); + // update the PDP and tell it that it has NO Policies (which prevents it from serving PEP Requests) + pdpChanged(pdp); + removePdpOrGroupTransaction.commitTransaction(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } else if (request.getParameter("pipId") != null) { + // group=<groupId> pipId=<pipEngineId> <= delete PIP config for given engine + loggingContext.setServiceName("AC:PAP.deletePIPConfig"); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " UNIMPLEMENTED"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_BAD_REQUEST, "UNIMPLEMENTED"); + return; + } else { + // ARGS: group=<groupId> movePDPsToGroupId=<movePDPsToGroupId> <= delete a group and move all its PDPs to the given group + String moveToGroupId = request.getParameter("movePDPsToGroupId"); + OnapPDPGroup moveToGroup = null; + if (moveToGroupId != null) { + moveToGroup = papEngine.getGroup(moveToGroupId); + } + // get list of PDPs in the group being deleted so we can notify them that they got changed + Set<OnapPDP> movedPDPs = new HashSet<>(); + movedPDPs.addAll(group.getOnapPdps()); + // do the move/remove + try{ + removePdpOrGroupTransaction.deleteGroup(group, moveToGroup,"XACMLPapServlet.doACDelete"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN, e, "XACMLPapServlet", " Failed to delete PDP Group. Exception"); + throw new PAPException(e.getMessage()); + } + papEngine.removeGroup(group, moveToGroup); + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + notifyAC(); + // notify any PDPs in the removed set that their config may have changed + for (OnapPDP pdp : movedPDPs) { + pdpChanged(pdp); + } + removePdpOrGroupTransaction.commitTransaction(); + loggingContext.transactionEnded(); + auditLogger.info("Success"); + PolicyLogger.audit("Transaction Ended Successfully"); + return; + } + } catch (PAPException e) { + removePdpOrGroupTransaction.rollbackTransaction(); + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " AC DELETE exception"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(500, e.getMessage()); + return; + } + } + + /** + * Heartbeat thread - periodically check on PDPs' status + * + * Heartbeat with all known PDPs. + * + * Implementation note: + * + * The PDPs are contacted Sequentially, not in Parallel. + * + * If we did this in parallel using multiple threads we would simultaneously use + * - 1 thread and + * - 1 connection + * for EACH PDP. + * This could become a resource problem since we already use multiple threads and connections for updating the PDPs + * when user changes occur. + * Using separate threads can also make it tricky dealing with timeouts on PDPs that are non-responsive. + * + * The Sequential operation does a heartbeat request to each PDP one at a time. + * This has the flaw that any PDPs that do not respond will hold up the entire heartbeat sequence until they timeout. + * If there are a lot of non-responsive PDPs and the timeout is large-ish (the default is 20 seconds) + * it could take a long time to cycle through all of the PDPs. + * That means that this may not notice a PDP being down in a predictable time. + */ + private class Heartbeat implements Runnable { + private PAPPolicyEngine papEngine; + private Set<OnapPDP> pdps = new HashSet<>(); + private int heartbeatInterval; + private int heartbeatTimeout; + + public volatile boolean isRunning = false; + + public synchronized boolean isRunning() { + return this.isRunning; + } + + public synchronized void terminate() { + this.isRunning = false; + } + + public Heartbeat(PAPPolicyEngine papEngine2) { + papEngine = papEngine2; + this.heartbeatInterval = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_INTERVAL, "10000")); + this.heartbeatTimeout = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_HEARTBEAT_TIMEOUT, "10000")); + } + + @Override + public void run() { + // Set ourselves as running + synchronized(this) { + this.isRunning = true; + } + HashMap<String, URL> idToURLMap = new HashMap<>(); + try { + while (this.isRunning()) { + // Wait the given time + Thread.sleep(heartbeatInterval); + // get the list of PDPs (may have changed since last time) + pdps.clear(); + synchronized(papEngine) { + try { + for (OnapPDPGroup g : papEngine.getOnapPDPGroups()) { + for (OnapPDP p : g.getOnapPdps()) { + pdps.add(p); + } + } + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", "Heartbeat unable to read PDPs from PAPEngine"); + } + } + // Check for shutdown + if (this.isRunning() == false) { + LOGGER.info("isRunning is false, getting out of loop."); + break; + } + // try to get the summary status from each PDP + boolean changeSeen = false; + for (OnapPDP pdp : pdps) { + // Check for shutdown + if (this.isRunning() == false) { + LOGGER.info("isRunning is false, getting out of loop."); + break; + } + // the id of the PDP is its url (though we add a query parameter) + URL pdpURL = idToURLMap.get(pdp.getId()); + if (pdpURL == null) { + // haven't seen this PDP before + String fullURLString = null; + try { + // Check PDP ID + if(CheckPDP.validateID(pdp.getId())){ + fullURLString = pdp.getId() + "?type=hb"; + pdpURL = new URL(fullURLString); + idToURLMap.put(pdp.getId(), pdpURL); + } + } catch (MalformedURLException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " PDP id '" + fullURLString + "' is not a valid URL"); + continue; + } + } + // Do a GET with type HeartBeat + String newStatus = ""; + HttpURLConnection connection = null; + try { + // Open up the connection + if(pdpURL != null){ + connection = (HttpURLConnection)pdpURL.openConnection(); + // Setup our method and headers + connection.setRequestMethod("GET"); + connection.setConnectTimeout(heartbeatTimeout); + // Authentication + String encoding = CheckPDP.getEncoding(pdp.getId()); + if(encoding !=null){ + connection.setRequestProperty("Authorization", "Basic " + encoding); + } + // Do the connect + connection.connect(); + if (connection.getResponseCode() == 204) { + newStatus = connection.getHeaderField(XACMLRestProperties.PROP_PDP_HTTP_HEADER_HB); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Heartbeat '" + pdp.getId() + "' status='" + newStatus + "'"); + } + } else { + // anything else is an unexpected result + newStatus = PDPStatus.Status.UNKNOWN.toString(); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " Heartbeat connect response code " + connection.getResponseCode() + ": " + pdp.getId()); + } + } + } catch (UnknownHostException e) { + newStatus = PDPStatus.Status.NO_SUCH_HOST.toString(); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Heartbeat '" + pdp.getId() + "' NO_SUCH_HOST"); + } catch (SocketTimeoutException e) { + newStatus = PDPStatus.Status.CANNOT_CONNECT.toString(); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Heartbeat '" + pdp.getId() + "' connection timeout"); + } catch (ConnectException e) { + newStatus = PDPStatus.Status.CANNOT_CONNECT.toString(); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Heartbeat '" + pdp.getId() + "' cannot connect"); + } catch (Exception e) { + newStatus = PDPStatus.Status.UNKNOWN.toString(); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", "Heartbeat '" + pdp.getId() + "' connect exception"); + } finally { + // cleanup the connection + if(connection != null) + connection.disconnect(); + } + if ( ! pdp.getStatus().getStatus().toString().equals(newStatus)) { + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("previous status='" + pdp.getStatus().getStatus()+"' new Status='" + newStatus + "'"); + } + try { + setPDPSummaryStatus(pdp, newStatus); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", "Unable to set state for PDP '" + pdp.getId()); + } + changeSeen = true; + } + } + // Check for shutdown + if (this.isRunning() == false) { + LOGGER.info("isRunning is false, getting out of loop."); + break; + } + // if any of the PDPs changed state, tell the ACs to update + if (changeSeen) { + notifyAC(); + } + } + } catch (InterruptedException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " Heartbeat interrupted. Shutting down"); + this.terminate(); + } + } + } + + /* + * HELPER to change Group status when PDP status is changed + * (Must NOT be called from a method that is synchronized on the papEngine or it may deadlock) + */ + private void setPDPSummaryStatus(OnapPDP pdp, PDPStatus.Status newStatus) throws PAPException { + setPDPSummaryStatus(pdp, newStatus.toString()); + } + + private void setPDPSummaryStatus(OnapPDP pdp, String newStatus) throws PAPException { + synchronized(papEngine) { + StdPDPStatus status = new StdPDPStatus(); + status.setStatus(PDPStatus.Status.valueOf(newStatus)); + ((StdPDP)pdp).setStatus(status); + // now adjust the group + StdPDPGroup group = (StdPDPGroup)papEngine.getPDPGroup((OnapPDP) pdp); + // if the PDP was just deleted it may transiently exist but not be in a group + if (group != null) { + group.resetStatus(); + } + } + } + + /* + * Callback methods telling this servlet to notify PDPs of changes made by the PAP StdEngine + * in the PDP group directories + */ + @Override + public void changed() { + // all PDPs in all groups need to be updated/sync'd + Set<OnapPDPGroup> groups; + try { + groups = papEngine.getOnapPDPGroups(); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " getPDPGroups failed"); + throw new RuntimeException(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Unable to get Groups: " + e); + } + for (OnapPDPGroup group : groups) { + groupChanged(group); + } + } + + @Override + public void groupChanged(OnapPDPGroup group) { + // all PDPs within one group need to be updated/sync'd + for (OnapPDP pdp : group.getOnapPdps()) { + pdpChanged(pdp); + } + } + + @Override + public void pdpChanged(OnapPDP pdp) { + // kick off a thread to do an event notification for each PDP. + // This needs to be on a separate thread so that PDPs that do not respond (down, non-existent, etc) + // do not block the PSP response to the AC, which would freeze the GUI until all PDPs sequentially respond or time-out. + Thread t = new Thread(new UpdatePDPThread(pdp, storedRequestId)); + if(CheckPDP.validateID(pdp.getId())){ + t.start(); + } + } + + private class UpdatePDPThread implements Runnable { + private OnapPDP pdp; + private String requestId; + + public UpdatePDPThread(OnapPDP pdp, String storedRequestId) { + this.pdp = pdp; + requestId = storedRequestId; + } + + public void run() { + // send the current configuration to one PDP + HttpURLConnection connection = null; + // get a new logging context for the thread + ONAPLoggingContext loggingContext = new ONAPLoggingContext(baseLoggingContext); + try { + loggingContext.setServiceName("PAP:PDP.putConfig"); + // If a requestId was provided, use it, otherwise generate one; post to loggingContext to be used later when calling PDP + if ((requestId == null) || (requestId == "")) { + UUID requestID = UUID.randomUUID(); + loggingContext.setRequestID(requestID.toString()); + PolicyLogger.info("requestID not provided in call to XACMLPapSrvlet (UpdatePDPThread) so we generated one: " + loggingContext.getRequestID()); + } else { + loggingContext.setRequestID(requestId); + PolicyLogger.info("requestID was provided in call to XACMLPapSrvlet (UpdatePDPThread): " + loggingContext.getRequestID()); + } + loggingContext.transactionStarted(); + // the Id of the PDP is its URL + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("creating url for id '" + pdp.getId() + "'"); + } + //TODO - currently always send both policies and pips. Do we care enough to add code to allow sending just one or the other? + //TODO (need to change "cache=", implying getting some input saying which to change) + URL url = new URL(pdp.getId() + "?cache=all"); + // Open up the connection + connection = (HttpURLConnection)url.openConnection(); + // Setup our method and headers + connection.setRequestMethod("PUT"); + // Authentication + String encoding = CheckPDP.getEncoding(pdp.getId()); + if(encoding !=null){ + connection.setRequestProperty("Authorization", "Basic " + encoding); + } + connection.setRequestProperty("Content-Type", "text/x-java-properties"); + connection.setRequestProperty("X-ECOMP-RequestID", loggingContext.getRequestID()); + storedRequestId = null; + connection.setInstanceFollowRedirects(true); + connection.setDoOutput(true); + try (OutputStream os = connection.getOutputStream()) { + OnapPDPGroup group = papEngine.getPDPGroup((OnapPDP) pdp); + // if the PDP was just deleted, there is no group, but we want to send an update anyway + if (group == null) { + // create blank properties files + Properties policyProperties = new Properties(); + policyProperties.put(XACMLProperties.PROP_ROOTPOLICIES, ""); + policyProperties.put(XACMLProperties.PROP_REFERENCEDPOLICIES, ""); + policyProperties.store(os, ""); + Properties pipProps = new Properties(); + pipProps.setProperty(XACMLProperties.PROP_PIP_ENGINES, ""); + pipProps.store(os, ""); + } else { + // send properties from the current group + group.getPolicyProperties().store(os, ""); + Properties policyLocations = new Properties(); + for (PDPPolicy policy : group.getPolicies()) { + policyLocations.put(policy.getId() + ".url", XACMLPapServlet.papURL + "?id=" + policy.getId()); + } + policyLocations.store(os, ""); + group.getPipConfigProperties().store(os, ""); + } + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Failed to send property file to " + pdp.getId()); + // Since this is a server-side error, it probably does not reflect a problem on the client, + // so do not change the PDP status. + return; + } + // Do the connect + connection.connect(); + if (connection.getResponseCode() == 204) { + LOGGER.info("Success. We are configured correctly."); + loggingContext.transactionEnded(); + auditLogger.info("Success. PDP is configured correctly."); + PolicyLogger.audit("Transaction Success. PDP is configured correctly."); + setPDPSummaryStatus(pdp, PDPStatus.Status.UP_TO_DATE); + } else if (connection.getResponseCode() == 200) { + LOGGER.info("Success. PDP needs to update its configuration."); + loggingContext.transactionEnded(); + auditLogger.info("Success. PDP needs to update its configuration."); + PolicyLogger.audit("Transaction Success. PDP is configured correctly."); + setPDPSummaryStatus(pdp, PDPStatus.Status.OUT_OF_SYNCH); + } else { + LOGGER.warn("Failed: " + connection.getResponseCode() + " message: " + connection.getResponseMessage()); + loggingContext.transactionEnded(); + auditLogger.warn("Failed: " + connection.getResponseCode() + " message: " + connection.getResponseMessage()); + PolicyLogger.audit("Transaction Failed: " + connection.getResponseCode() + " message: " + connection.getResponseMessage()); + setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN); + } + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Unable to sync config with PDP '" + pdp.getId() + "'"); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed: Unable to sync config with PDP '" + pdp.getId() + "': " + e); + try { + setPDPSummaryStatus(pdp, PDPStatus.Status.UNKNOWN); + } catch (PAPException e1) { + PolicyLogger.audit("Transaction Failed: Unable to set status of PDP " + pdp.getId() + " to UNKNOWN: " + e); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Unable to set status of PDP '" + pdp.getId() + "' to UNKNOWN"); + } + } finally { + // cleanup the connection + if(connection != null){ + connection.disconnect(); + } + // tell the AC to update it's status info + notifyAC(); + } + } + } + + /* + * RESTful Interface from PAP to ACs notifying them of changes + */ + private void notifyAC() { + // kick off a thread to do one event notification for all registered ACs + // This needs to be on a separate thread so that ACs can make calls back to PAP to get the updated Group data + // as part of processing this message on their end. + Thread t = new Thread(new NotifyACThread()); + t.start(); + } + + private class NotifyACThread implements Runnable { + public void run() { + List<String> disconnectedACs = new ArrayList<>(); + // There should be no Concurrent exception here because the list is a CopyOnWriteArrayList. + // The "for each" loop uses the collection's iterator under the covers, so it should be correct. + for (String acURL : adminConsoleURLStringList) { + HttpURLConnection connection = null; + try { + acURL += "?PAPNotification=true"; + //TODO - Currently we just tell AC that "Something changed" without being specific. Do we want to tell it which group/pdp changed? + //TODO - If so, put correct parameters into the Query string here + acURL += "&objectType=all" + "&action=update"; + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("creating url for id '" + acURL + "'"); + } + //TODO - currently always send both policies and pips. Do we care enough to add code to allow sending just one or the other? + //TODO (need to change "cache=", implying getting some input saying which to change) + URL url = new URL(acURL ); + // Open up the connection + connection = (HttpURLConnection)url.openConnection(); + // Setup our method and headers + connection.setRequestMethod("PUT"); + connection.setRequestProperty("Content-Type", "text/x-java-properties"); + // Adding this in. It seems the HttpUrlConnection class does NOT + // properly forward our headers for POST re-direction. It does so + // for a GET re-direction. + // So we need to handle this ourselves. + //TODO - is this needed for a PUT? seems better to leave in for now? + connection.setInstanceFollowRedirects(false); + // Do not include any data in the PUT because this is just a + // notification to the AC. + // The AC will use GETs back to the PAP to get what it needs + // to fill in the screens. + // Do the connect + connection.connect(); + if (connection.getResponseCode() == 204) { + LOGGER.info("Success. We updated correctly."); + } else { + LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Failed: " + connection.getResponseCode() + " message: " + connection.getResponseMessage()); + } + + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "XACMLPapServlet", " Unable to sync config AC '" + acURL + "'"); + disconnectedACs.add(acURL); + } finally { + // cleanup the connection + if(connection != null) + connection.disconnect(); + } + } + // remove any ACs that are no longer connected + if (disconnectedACs.size() > 0) { + adminConsoleURLStringList.removeAll(disconnectedACs); + } + } + } + + private void testService(ONAPLoggingContext loggingContext, HttpServletResponse response) throws IOException{ + LOGGER.info("Test request received"); + try { + im.evaluateSanity(); + //If we make it this far, all is well + String message = "GET:/pap/test called and PAP " + papResourceName + " is OK"; + LOGGER.info(message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.setStatus(HttpServletResponse.SC_OK); + return; + }catch (ForwardProgressException fpe){ + //No forward progress is being made + String message = "GET:/pap/test called and PAP " + papResourceName + " is not making forward progress." + + " Exception Message: " + fpe.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (AdministrativeStateException ase){ + //Administrative State is locked + String message = "GET:/pap/test called and PAP " + papResourceName + " Administrative State is LOCKED " + + " Exception Message: " + ase.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (StandbyStatusException sse){ + //Administrative State is locked + String message = "GET:/pap/test called and PAP " + papResourceName + " Standby Status is NOT PROVIDING SERVICE " + + " Exception Message: " + sse.getMessage(); + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + }catch (Exception e) { + //A subsystem is not making progress, is locked, standby or is not responding + String eMsg = e.getMessage(); + if(eMsg == null){ + eMsg = "No Exception Message"; + } + String message = "GET:/pap/test called and PAP " + papResourceName + " has had a subsystem failure." + + " Exception Message: " + eMsg; + LOGGER.info(message); + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + //Get the specific list of subsystems that failed + String ssFailureList = null; + for(String failedSS : papDependencyGroupsFlatArray){ + if(eMsg.contains(failedSS)){ + if(ssFailureList == null){ + ssFailureList = failedSS; + }else{ + ssFailureList = ssFailureList.concat(","+failedSS); + } + } + } + if(ssFailureList == null){ + ssFailureList = "UnknownSubSystem"; + } + response.addHeader("X-ONAP-SubsystemFailure", ssFailureList); + response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, message); + return; + } + } + + /* + * Authorizing the PEP Requests. + */ + private boolean authorizeRequest(HttpServletRequest request) { + String clientCredentials = request.getHeader(ENVIRONMENT_HEADER); + // Check if the Client is Authorized. + if(clientCredentials!=null && clientCredentials.equalsIgnoreCase(environment)){ + return true; + }else{ + return false; + } + } + + private static void loadWebapps() throws PAPException{ + if(ACTION_HOME == null || CONFIG_HOME == null){ + Path webappsPath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS)); + //Sanity Check + if (webappsPath == null) { + PolicyLogger.error("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS); + throw new PAPException("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS); + } + Path webappsPathConfig = Paths.get(webappsPath.toString()+File.separator+"Config"); + Path webappsPathAction = Paths.get(webappsPath.toString()+File.separator+"Action"); + if (Files.notExists(webappsPathConfig)) { + try { + Files.createDirectories(webappsPathConfig); + } catch (IOException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Failed to create config directory: " + + webappsPathConfig.toAbsolutePath().toString()); + } + } + if (Files.notExists(webappsPathAction)) { + try { + Files.createDirectories(webappsPathAction); + } catch (IOException e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Failed to create config directory: " + + webappsPathAction.toAbsolutePath().toString(), e); + } + } + ACTION_HOME = webappsPathAction.toString(); + CONFIG_HOME = webappsPathConfig.toString(); + } + } + + public static String getConfigHome(){ + try { + loadWebapps(); + } catch (PAPException e) { + return null; + } + return CONFIG_HOME; + } + + public static String getActionHome(){ + try { + loadWebapps(); + } catch (PAPException e) { + return null; + } + return ACTION_HOME; + } + + public static EntityManagerFactory getEmf() { + return emf; + } + + public IntegrityAudit getIa() { + return ia; + } + + public static String getPDPFile(){ + return XACMLPapServlet.pdpFile; + } + + public static String getPersistenceUnit(){ + return PERSISTENCE_UNIT; + } + + public static PAPPolicyEngine getPAPEngine(){ + return papEngine; + } + + public static PolicyDBDaoTransaction getDbDaoTransaction(){ + return policyDBDao.getNewTransaction(); + } + public static String getPapDbDriver() { + return papDbDriver; + } + + public static void setPapDbDriver(String papDbDriver) { + XACMLPapServlet.papDbDriver = papDbDriver; + } + + public static String getPapDbUrl() { + return papDbUrl; + } + + public static void setPapDbUrl(String papDbUrl) { + XACMLPapServlet.papDbUrl = papDbUrl; + } + + public static String getPapDbUser() { + return papDbUser; + } + + public static void setPapDbUser(String papDbUser) { + XACMLPapServlet.papDbUser = papDbUser; + } + + public static String getPapDbPassword() { + return papDbPassword; + } + + public static void setPapDbPassword(String papDbPassword) { + XACMLPapServlet.papDbPassword = papDbPassword; + } + + public static String getMsOnapName() { + return msOnapName; + } + + public static void setMsOnapName(String msOnapName) { + XACMLPapServlet.msOnapName = msOnapName; + } + + public static String getMsPolicyName() { + return msPolicyName; + } + + public static void setMsPolicyName(String msPolicyName) { + XACMLPapServlet.msPolicyName = msPolicyName; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/GridData.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/GridData.java new file mode 100644 index 000000000..1ed4bf3b5 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/GridData.java @@ -0,0 +1,62 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.adapters; + +import java.util.ArrayList; + +public class GridData { + private ArrayList<Object> attributes; + private ArrayList<Object> alAttributes; + private ArrayList<Object> transportProtocols; + private ArrayList<Object> appProtocols; + + public ArrayList<Object> getAttributes() { + return attributes; + } + + public void setAttributes(ArrayList<Object> attributes) { + this.attributes = attributes; + } + + public ArrayList<Object> getAlAttributes() { + return alAttributes; + } + + public void setAlAttributes(ArrayList<Object> alAttributes) { + this.alAttributes = alAttributes; + } + + public ArrayList<Object> getAppProtocols() { + return appProtocols; + } + + public void setAppProtocols(ArrayList<Object> appProtocols) { + this.appProtocols = appProtocols; + } + + public ArrayList<Object> getTransportProtocols() { + return transportProtocols; + } + + public void setTransportProtocols(ArrayList<Object> transportProtocols) { + this.transportProtocols = transportProtocols; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/package-info.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/package-info.java new file mode 100644 index 000000000..b51d08076 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/adapters/package-info.java @@ -0,0 +1,21 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.adapters; diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ActionPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ActionPolicy.java new file mode 100644 index 000000000..4aec72bed --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ActionPolicy.java @@ -0,0 +1,529 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ApplyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ConditionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObligationExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.util.JPAUtils; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.ActionPolicyDict; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.FunctionDefinition; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; + +public class ActionPolicy extends Policy { + + /** + * ActionPolicy Fields + */ + private static final Logger LOGGER = FlexLogger.getLogger(ActionPolicy.class); + + public static final String JSON_CONFIG = "JSON"; + + public static final String PDP_ACTION = "PDP"; + public static final String PEP_ACTION = "PEP"; + public static final String TYPE_ACTION = "REST"; + + public static final String GET_METHOD = "GET"; + public static final String PUT_METHOD = "PUT"; + public static final String POST_METHOD = "POST"; + + public static final String PERFORMER_ATTRIBUTEID = "performer"; + public static final String TYPE_ATTRIBUTEID = "type"; + public static final String METHOD_ATTRIBUTEID = "method"; + public static final String HEADERS_ATTRIBUTEID = "headers"; + public static final String URL_ATTRIBUTEID = "url"; + public static final String BODY_ATTRIBUTEID = "body"; + + private static boolean isAttribute = false; + + + List<String> dynamicLabelRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldFunctionRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldOneRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldTwoRuleAlgorithms = new LinkedList<>(); + + protected Map<String, String> dropDownMap = new HashMap<>(); + + + public ActionPolicy() { + super(); + } + + public ActionPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!ActionPolicy.isAttribute) { + successMap.put("invalidAttribute", "Action Attrbute was not in the database."); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject() ); + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Action")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + + policyName = policyAdapter.getNewFileName(); + + if (policyAdapter.getData() != null) { + // Action body is optional so checking value provided or not + String comboDictValue = policyAdapter.getActionAttribute(); + String actionBody = getActionPolicyDict(comboDictValue).getBody(); + if(!(actionBody==null || "".equals(actionBody))){ + saveActionBody(policyName, actionBody); + } else { + if(!isAttribute){ + LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Could not find " + comboDictValue + " in the ActionPolicyDict table."); + return false; + } + } + + PolicyType actionPolicy = (PolicyType) policyAdapter.getData(); + actionPolicy.setDescription(policyAdapter.getPolicyDescription()); + actionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOf = new AllOfType(); + + Map<String, String> dynamicFieldComponentAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + + // If there is any dynamic field attributes create the matches here + for (String keyField : dynamicFieldComponentAttributes.keySet()) { + String key = keyField; + String value = dynamicFieldComponentAttributes.get(key); + MatchType dynamicMatch = createDynamicMatch(key, value); + allOf.getMatch().add(dynamicMatch); + } + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + target.getAnyOf().add(anyOf); + + // Adding the target to the policy element + actionPolicy.setTarget(target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + rule.setTarget(new TargetType()); + + dynamicLabelRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmLabels(); + dynamicFieldFunctionRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmCombo(); + dynamicFieldOneRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField1(); + dynamicFieldTwoRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField2(); + //dropDownMap = policyAdapter.getDropDownMap(); + dropDownMap = createDropDownMap(); + + // Rule attributes are optional and dynamic so check and add them to condition. + if (dynamicLabelRuleAlgorithms != null && dynamicLabelRuleAlgorithms.size() > 0) { + boolean isCompound = false; + ConditionType condition = new ConditionType(); + int index = dynamicFieldOneRuleAlgorithms.size() - 1; + + for (String labelAttr : dynamicLabelRuleAlgorithms) { + // if the rule algorithm as a label means it is a compound + if (dynamicFieldOneRuleAlgorithms.get(index).toString().equals(labelAttr)) { + ApplyType actionApply = new ApplyType(); + + String selectedFunction = (String) dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value1 = (String) dynamicFieldOneRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(selectedFunction)); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value1))); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value2))); + condition.setExpression(new ObjectFactory().createApply(actionApply)); + isCompound = true; + } + } + // if rule algorithm not a compound + if (!isCompound) { + condition.setExpression(new ObjectFactory().createApply(getInnerActionApply(dynamicLabelRuleAlgorithms.get(index).toString()))); + } + rule.setCondition(condition); + } + // set the obligations to rule + rule.setObligationExpressions(getObligationExpressions()); + actionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(actionPolicy); + } else { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + + setPreparedToSave(true); + return true; + } + + // Saving the json Configurations file if exists at server location for action policy. + private void saveActionBody(String policyName, String actionBodyData) { + try { + if(policyName.endsWith(".xml")){ + policyName = policyName.replace(".xml", ""); + } + File file = new File(ACTION_HOME+ File.separator + policyName + ".json"); + FileWriter fw = new FileWriter(file.getAbsoluteFile()); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(actionBodyData); + bw.close(); + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Action Body is succesfully saved at " + file.getAbsolutePath()); + } + } catch (IOException e) { + LOGGER.error("Exception Occured"+e); + } + } + + // Data required for obligation part is setting here. + private ObligationExpressionsType getObligationExpressions() { + ObligationExpressionsType obligations = new ObligationExpressionsType(); + + ObligationExpressionType obligation = new ObligationExpressionType(); + String comboDictValue = policyAdapter.getActionAttribute(); + obligation.setObligationId(comboDictValue); + obligation.setFulfillOn(EffectType.PERMIT); + + // Add Action Assignment: + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId(PERFORMER_ATTRIBUTEID); + assignment1.setCategory(CATEGORY_RECIPIENT_SUBJECT); + + AttributeValueType actionNameAttributeValue = new AttributeValueType(); + actionNameAttributeValue.setDataType(STRING_DATATYPE); + actionNameAttributeValue.getContent().add(performer.get(policyAdapter.getActionPerformer())); + + assignment1.setExpression(new ObjectFactory().createAttributeValue(actionNameAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignment1); + + // Add Type Assignment: + AttributeAssignmentExpressionType assignmentType = new AttributeAssignmentExpressionType(); + assignmentType.setAttributeId(TYPE_ATTRIBUTEID); + assignmentType.setCategory(CATEGORY_RESOURCE); + + AttributeValueType typeAttributeValue = new AttributeValueType(); + typeAttributeValue.setDataType(STRING_DATATYPE); + String actionDictType = getActionPolicyDict(comboDictValue).getType(); + typeAttributeValue.getContent().add(actionDictType); + + assignmentType.setExpression(new ObjectFactory().createAttributeValue(typeAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentType); + + // Add Rest_URL Assignment: + AttributeAssignmentExpressionType assignmentURL = new AttributeAssignmentExpressionType(); + assignmentURL.setAttributeId(URL_ATTRIBUTEID); + assignmentURL.setCategory(CATEGORY_RESOURCE); + + AttributeValueType actionURLAttributeValue = new AttributeValueType(); + actionURLAttributeValue.setDataType(URI_DATATYPE); + String actionDictUrl = getActionPolicyDict(comboDictValue).getUrl(); + actionURLAttributeValue.getContent().add(actionDictUrl); + + assignmentURL.setExpression(new ObjectFactory().createAttributeValue(actionURLAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentURL); + + // Add Method Assignment: + AttributeAssignmentExpressionType assignmentMethod = new AttributeAssignmentExpressionType(); + assignmentMethod.setAttributeId(METHOD_ATTRIBUTEID); + assignmentMethod.setCategory(CATEGORY_RESOURCE); + + AttributeValueType methodAttributeValue = new AttributeValueType(); + methodAttributeValue.setDataType(STRING_DATATYPE); + String actionDictMethod = getActionPolicyDict(comboDictValue).getMethod(); + methodAttributeValue.getContent().add(actionDictMethod); + + assignmentMethod.setExpression(new ObjectFactory().createAttributeValue(methodAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentMethod); + + // Add JSON_URL Assignment: + String actionBody = getActionPolicyDict(comboDictValue).getBody(); + if (actionBody != null) { + AttributeAssignmentExpressionType assignmentJsonURL = new AttributeAssignmentExpressionType(); + assignmentJsonURL.setAttributeId(BODY_ATTRIBUTEID); + assignmentJsonURL.setCategory(CATEGORY_RESOURCE); + + AttributeValueType jsonURLAttributeValue = new AttributeValueType(); + jsonURLAttributeValue.setDataType(URI_DATATYPE); + jsonURLAttributeValue.getContent().add(CONFIG_URL + "/Action/" + policyName + ".json"); + + assignmentJsonURL.setExpression(new ObjectFactory().createAttributeValue(jsonURLAttributeValue)); + obligation.getAttributeAssignmentExpression().add(assignmentJsonURL); + } + + if(getActionPolicyDict(comboDictValue).getHeader() != null){ + String headerVal = getActionPolicyDict(comboDictValue).getHeader(); + if(headerVal != null && !headerVal.equals("")){ + // parse it on : to get number of headers + String[] result = headerVal.split(":"); + for (String eachString : result){ + // parse each value on = + String[] textFieldVals = eachString.split("="); + obligation.getAttributeAssignmentExpression().add(addDynamicHeaders(textFieldVals[0], textFieldVals[1])); + } + } + + } + + obligations.getObligationExpression().add(obligation); + return obligations; + } + + + // if compound setting the inner apply here + protected ApplyType getInnerActionApply(String value1Label) { + ApplyType actionApply = new ApplyType(); + int index = 0; + // check the index for the label. + for (String labelAttr : dynamicLabelRuleAlgorithms) { + if (labelAttr.equals(value1Label)) { + String value1 = dynamicFieldOneRuleAlgorithms.get(index).toString(); + // check if the row contains label again + for (String labelValue : dynamicLabelRuleAlgorithms) { + if (labelValue.equals(value1)) { + return getCompoundApply(index); + } + } + + // Getting the values from the form. + String functionKey = dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(functionKey)); + // if two text field are rule attributes. + if ((value1.contains(RULE_VARIABLE)) && (value2.contains(RULE_VARIABLE))) { + ApplyType innerActionApply1 = new ApplyType(); + ApplyType innerActionApply2 = new ApplyType(); + AttributeDesignatorType attributeDesignator1 = new AttributeDesignatorType(); + AttributeDesignatorType attributeDesignator2 = new AttributeDesignatorType(); + // If selected function is Integer function set integer functionID + if (functionKey.toLowerCase().contains("integer")) { + innerActionApply1.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + innerActionApply2.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + attributeDesignator1.setDataType(INTEGER_DATATYPE); + attributeDesignator2.setDataType(INTEGER_DATATYPE); + } else { + // If selected function is not a Integer function + // set String functionID + innerActionApply1.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + innerActionApply2.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + attributeDesignator1.setDataType(STRING_DATATYPE); + attributeDesignator2.setDataType(STRING_DATATYPE); + } + attributeDesignator1.setCategory(CATEGORY_RESOURCE); + attributeDesignator2.setCategory(CATEGORY_RESOURCE); + + // Here set actual field values + attributeDesignator1.setAttributeId(value1.contains("resource:") ? value1.substring(9): value1.substring(8)); + attributeDesignator2.setAttributeId(value1.contains("resource:") ? value1.substring(9): value1.substring(8)); + + innerActionApply1.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator1)); + innerActionApply2.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator2)); + + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply1)); + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply2)); + + } else {// if either of one text field is rule attribute. + ApplyType innerActionApply = new ApplyType(); + AttributeDesignatorType attributeDesignator = new AttributeDesignatorType(); + AttributeValueType actionConditionAttributeValue = new AttributeValueType(); + + if (functionKey.toLowerCase().contains("integer")) { + innerActionApply.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + actionConditionAttributeValue.setDataType(INTEGER_DATATYPE); + attributeDesignator.setDataType(INTEGER_DATATYPE); + } else { + innerActionApply.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + actionConditionAttributeValue.setDataType(STRING_DATATYPE); + attributeDesignator.setDataType(STRING_DATATYPE); + } + + String attributeId = null; + String attributeValue = null; + + // Find which textField has rule attribute and set it as + attributeId = value1; + attributeValue = value2; + + if (attributeId != null) { + attributeDesignator.setCategory(CATEGORY_RESOURCE); + attributeDesignator.setAttributeId(attributeId); + } + actionConditionAttributeValue.getContent().add(attributeValue); + innerActionApply.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator)); + // Decide the order of element based the values. + if (attributeId.equals(value1)) { + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply)); + actionApply.getExpression().add(new ObjectFactory().createAttributeValue(actionConditionAttributeValue)); + } else { + actionApply.getExpression().add(new ObjectFactory().createAttributeValue(actionConditionAttributeValue)); + actionApply.getExpression().add(new ObjectFactory().createApply(innerActionApply)); + } + } + } + index++; + } + return actionApply; + } + + // if the rule algorithm is multiple compound one setting the apply + protected ApplyType getCompoundApply(int index) { + ApplyType actionApply = new ApplyType(); + String selectedFunction = dynamicFieldFunctionRuleAlgorithms.get(index).toString(); + String value1 = dynamicFieldOneRuleAlgorithms.get(index).toString(); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index).toString(); + actionApply.setFunctionId(dropDownMap.get(selectedFunction)); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value1))); + actionApply.getExpression().add(new ObjectFactory().createApply(getInnerActionApply(value2))); + return actionApply; + } + + // Adding the dynamic headers if any + private AttributeAssignmentExpressionType addDynamicHeaders(String header, String value) { + AttributeAssignmentExpressionType assignmentHeaders = new AttributeAssignmentExpressionType(); + assignmentHeaders.setAttributeId("headers:" + header); + assignmentHeaders.setCategory(CATEGORY_RESOURCE); + + AttributeValueType headersAttributeValue = new AttributeValueType(); + headersAttributeValue.setDataType(STRING_DATATYPE); + headersAttributeValue.getContent().add(value); + + assignmentHeaders.setExpression(new ObjectFactory().createAttributeValue(headersAttributeValue)); + return assignmentHeaders; + } + + private Map<String,String> createDropDownMap(){ + JPAUtils jpaUtils = null; + Map<String, String> dropDownMap = new HashMap<>(); + try { + jpaUtils = JPAUtils.getJPAUtilsInstance(XACMLPapServlet.getEmf()); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + if(jpaUtils != null){ + Map<Datatype, List<FunctionDefinition>> functionMap = jpaUtils.getFunctionDatatypeMap(); + + for (Datatype id : functionMap.keySet()) { + List<FunctionDefinition> functionDefinitions = (List<FunctionDefinition>) functionMap + .get(id); + for (FunctionDefinition functionDef : functionDefinitions) { + dropDownMap.put(functionDef.getShortname(),functionDef.getXacmlid()); + } + } + } + return dropDownMap; + } + + private ActionPolicyDict getActionPolicyDict(String attributeName){ + ActionPolicyDict retObj = new ActionPolicyDict(); + EntityManager em = XACMLPapServlet.getEmf().createEntityManager(); + Query getActionPolicyDicts = em.createNamedQuery("ActionPolicyDict.findAll"); + List<?> actionPolicyDicts = getActionPolicyDicts.getResultList(); + + for (Object id : actionPolicyDicts) { + ActionPolicyDict actionPolicy = (ActionPolicyDict) id; + if(attributeName.equals(actionPolicy.getAttributeName())){ + isAttribute = true; + retObj = actionPolicy; + break; + } + } + em.close(); + return retObj; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/AutoPushPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/AutoPushPolicy.java new file mode 100644 index 000000000..f9dbc287b --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/AutoPushPolicy.java @@ -0,0 +1,100 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.File; +import java.io.FileInputStream; +import java.nio.file.Paths; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Properties; +import java.util.Set; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.xacml.std.pap.StdPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; + +import com.att.research.xacml.api.pap.PDPPolicy; +/** + * Auto Push Policy based on the property file properties. + * + * @version 0.1 + */ +public class AutoPushPolicy { + + private static final Logger LOGGER = FlexLogger.getLogger(AutoPushPolicy.class); + + private String filePath = null; + private Properties properties; + private Long newModified; + private Long oldModified; + private File propFile; + + + /** + * Constructor Pass in the property file path. + */ + public AutoPushPolicy(String file){ + filePath = file; + properties = new Properties(); + propFile = Paths.get(filePath).toFile(); + readFile(); + } + + private void readFile(){ + try { + properties.load(new FileInputStream(propFile)); + oldModified = propFile.lastModified(); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "AutoPushPolicy", "Error while loading in the auto push properties file."); + } + } + + private StdPDPGroup addToGroup(String policyId, String policyName, String policyToCreateUpdate, StdPDPGroup pdpGroup) throws Exception{ + // Add to group. Send Notification. + StdPDPPolicy policy = new StdPDPPolicy(policyId, true, policyName, null); + //Get the current policies from the Group and Add the new one + Set<PDPPolicy> currentPoliciesInGroup = pdpGroup.getPolicies(); + Set<PDPPolicy> policies = new HashSet<>(); + policies.add(policy); + pdpGroup.copyPolicyToFile(policyId, new FileInputStream(Paths.get(policyToCreateUpdate).toFile())); + //If the selected policy is in the group we must remove it because the name is default + Iterator<PDPPolicy> policyIterator = policies.iterator(); + while (policyIterator.hasNext()) { + PDPPolicy selPolicy = policyIterator.next(); + for (PDPPolicy existingPolicy : currentPoliciesInGroup) { + if (existingPolicy.getId().equals(selPolicy.getId())) { + pdpGroup.removePolicyFromGroup(existingPolicy); + LOGGER.debug("Removing policy: " + existingPolicy); + break; + } + } + } + if(currentPoliciesInGroup!=null){ + policies.addAll(currentPoliciesInGroup); + } + pdpGroup.setPolicies(policies); + return pdpGroup; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ClosedLoopPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ClosedLoopPolicy.java new file mode 100644 index 000000000..3355fab85 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ClosedLoopPolicy.java @@ -0,0 +1,412 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.adapter.PolicyRestAdapter; + +import com.att.research.xacml.std.IdentifierImpl; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +public class ClosedLoopPolicy extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(ClosedLoopPolicy.class); + + public ClosedLoopPolicy() { + super(); + } + + public ClosedLoopPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + //save configuration of the policy based on the policyname + private void saveConfigurations(String policyName, String jsonBody) { + try { + String body = jsonBody; + try { + try{ + //Remove the trapMaxAge in Verification Signature + body = body.replace(",\"trapMaxAge\":null", ""); + }catch(Exception e){ + LOGGER.debug("No Trap Max Age in JSON body"); + } + this.policyAdapter.setJsonBody(body); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + + if(policyName.endsWith(".xml")){ + policyName = policyName.replace(".xml", ""); + } + PrintWriter out = new PrintWriter(CONFIG_HOME + File.separator+ policyName +".json"); + out.println(body); + out.close(); + + } catch (Exception e) { + LOGGER.error("Exception Occured while writing Configuration Data"+e); + } + } + + //Utility to read json data from the existing file to a string + static String readFile(String path, Charset encoding) throws IOException { + + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); + + } + + //create the configuration file based on the policy name on adding the extension as .json + private String getConfigFile(String filename) { + filename = FilenameUtils.removeExtension(filename); + if (filename.endsWith(".xml")) { + filename = filename.substring(0, filename.length() - 4); + } + filename = filename + ".json"; + return filename; + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + policyName = policyAdapter.getNewFileName(); + if (policyAdapter.getData() != null) { + // Save the Configurations file with the policy name with extention based on selection. + String jsonBody = policyAdapter.getJsonBody(); + saveConfigurations(policyName, jsonBody); + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + PolicyType faultPolicy = (PolicyType) policyAdapter.getData(); + + faultPolicy.setDescription(policyAdapter.getPolicyDescription()); + + faultPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + AllOfType allOf = new AllOfType(); + // Adding the matches to AllOfType element + // Match for Onap + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + // Match for riskType + allOf.getMatch().add( + createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add( + createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add( + createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add( + createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + // Adding the target to the policy element + faultPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "CreateClosedLoopPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType closedMatch = new MatchType(); + AttributeValueType closedAttributeValue = new AttributeValueType(); + closedAttributeValue.setDataType(STRING_DATATYPE); + closedAttributeValue.getContent().add("Config"); + closedMatch.setAttributeValue(closedAttributeValue); + AttributeDesignatorType closedAttributeDesignator = new AttributeDesignatorType(); + URI closedURI = null; + try { + closedURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "CreateClosedLoopPolicy", "Exception creating closed URI"); + } + closedAttributeDesignator.setCategory(CATEGORY_RESOURCE); + closedAttributeDesignator.setDataType(STRING_DATATYPE); + closedAttributeDesignator.setAttributeId(new IdentifierImpl(closedURI).stringValue()); + closedMatch.setAttributeDesignator(closedAttributeDesignator); + closedMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(closedMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + faultPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(faultPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, String fileName) { + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("faultID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment1); + // For Config file Url if configurations are provided. + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + String content = CONFIG_URL +"/Config/" + getConfigFile(policyName); + System.out.println("URL value :" + content); + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory().createAttributeValue(AttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment2); + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory().createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue4)); + + advice.getAttributeAssignmentExpression().add(assignment4); + + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue5)); + + advice.getAttributeAssignmentExpression().add(assignment5); + + //Risk Attributes + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("RiskType"); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getRiskType()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + + advice.getAttributeAssignmentExpression().add(assignment6); + + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId("RiskLevel"); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(policyAdapter.getRiskLevel()); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + + advice.getAttributeAssignmentExpression().add(assignment7); + + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("guard"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getGuard()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("TTLDate"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getTtlDate()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ConfigPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ConfigPolicy.java new file mode 100644 index 000000000..1b29c0369 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/ConfigPolicy.java @@ -0,0 +1,564 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.StringReader; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; + +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParser; +import javax.xml.parsers.SAXParserFactory; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.xml.sax.ErrorHandler; +import org.xml.sax.InputSource; +import org.xml.sax.SAXException; +import org.xml.sax.SAXParseException; +import org.xml.sax.XMLReader; + +import com.att.research.xacml.std.IdentifierImpl; + +public class ConfigPolicy extends Policy { + + /** + * Config Fields + */ + private static final Logger LOGGER = FlexLogger.getLogger(ConfigPolicy.class); + + public static final String JSON_CONFIG = "JSON"; + public static final String XML_CONFIG = "XML"; + public static final String PROPERTIES_CONFIG = "PROPERTIES"; + public static final String OTHER_CONFIG = "OTHER"; + + private String configBodyData; + + public ConfigPolicy() { + super(); + } + + public ConfigPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + // Saving the Configurations file at server location for config policy. + protected void saveConfigurations(String policyName) { + try { + String fileName = getConfigFile(policyName); + FileWriter fw = new FileWriter(CONFIG_HOME + File.separator + fileName); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(configBodyData); + bw.close(); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Configuration is succesfully saved"); + } + } catch (IOException e) { + LOGGER.error("Exception Occured while writing Configuration Data"+e); + } + } + + + // Here we are adding the extension for the configurations file based on the + // config type selection for saving. + private String getConfigFile(String filename) { + filename = FilenameUtils.removeExtension(filename); + if (filename.endsWith(".xml")) { + filename = filename.substring(0, filename.length() - 4); + } + String id = policyAdapter.getConfigType(); + + if (id != null) { + if (id.equalsIgnoreCase(JSON_CONFIG)) { + filename = filename + ".json"; + } + if (id.equalsIgnoreCase(XML_CONFIG)) { + filename = filename + ".xml"; + } + if (id.equalsIgnoreCase(PROPERTIES_CONFIG)) { + filename = filename + ".properties"; + } + if (id.equalsIgnoreCase(OTHER_CONFIG)) { + filename = filename + ".txt"; + } + } + return filename; + } + + + // Validations for Config form + /* + * FORM VALIDATION WILL BE DONE BY THE PAP-ADMIN before creating JSON object... + * BODY VALIDATION WILL BE DONE BY THE PAP-REST after receiving and deserializing the JSON object + */ + public boolean validateConfigForm() { + + isValidForm = true; + + /* + * Validate Text Area Body + */ + configBodyData = policyAdapter.getConfigBodyData(); + String id = policyAdapter.getConfigType(); + if (id != null) { + if (id.equals(JSON_CONFIG)) { + if (!isJSONValid(configBodyData)) { + isValidForm = false; + } + } else if (id.equals(XML_CONFIG)) { + if (!isXMLValid(configBodyData)) { + isValidForm = false; + } + } else if (id.equals(PROPERTIES_CONFIG)) { + if (!isPropValid(configBodyData)||configBodyData.equals("")) { + isValidForm = false; + } + } else if (id.equals(OTHER_CONFIG)) { + if (configBodyData.equals("")) { + isValidForm = false; + } + } + } + return isValidForm; + + } + + // Validation for XML. + private boolean isXMLValid(String data) { + + SAXParserFactory factory = SAXParserFactory.newInstance(); + factory.setValidating(false); + factory.setNamespaceAware(true); + try { + SAXParser parser = factory.newSAXParser(); + XMLReader reader = parser.getXMLReader(); + reader.setErrorHandler(new XMLErrorHandler()); + reader.parse(new InputSource(new StringReader(data))); + } catch (ParserConfigurationException e) { + return false; + } catch (SAXException e) { + return false; + } catch (IOException e) { + return false; + } + return true; + + } + + // Validation for Properties file. + public boolean isPropValid(String prop) { + + Scanner scanner = new Scanner(prop); + while (scanner.hasNextLine()) { + String line = scanner.nextLine(); + line.replaceAll("\\s+", ""); + if (line.startsWith("#")) { + continue; + } else { + if (line.contains("=")) { + String[] parts = line.split("="); + if (parts.length < 2) { + scanner.close(); + return false; + } + } else { + scanner.close(); + return false; + } + } + } + scanner.close(); + return true; + + } + + public class XMLErrorHandler implements ErrorHandler { + + public void warning(SAXParseException e) throws SAXException { + System.out.println(e.getMessage()); + } + + public void error(SAXParseException e) throws SAXException { + System.out.println(e.getMessage()); + } + + public void fatalError(SAXParseException e) throws SAXException { + System.out.println(e.getMessage()); + } + + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + + policyName = policyAdapter.getNewFileName(); + configBodyData = policyAdapter.getConfigBodyData(); + saveConfigurations(policyName); + + if (policyAdapter.getData() != null) { + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + AllOfType allOfOne = new AllOfType(); + + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + AllOfType allOf = new AllOfType(); + + // Adding the matches to AllOfType element Match for Onap + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + // Match for riskType + allOf.getMatch().add(createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add(createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add(createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add(createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + // Match for ConfigName + allOf.getMatch().add(createMatch("ConfigName", policyAdapter.getConfigName())); + + Map<String, String> dynamicFieldConfigAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + + // If there is any dynamic field create the matches here + for (String keyField : dynamicFieldConfigAttributes.keySet()) { + String key = keyField; + String value = dynamicFieldConfigAttributes.get(key); + MatchType dynamicMatch = createDynamicMatch(key, value); + allOf.getMatch().add(dynamicMatch); + } + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try{ + accessURI = new URI(ACTION_ID); + }catch(URISyntaxException e){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "ConfigPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + configAttributeValue.getContent().add("Config"); + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try{ + configURI = new URI(RESOURCE_ID); + }catch(URISyntaxException e){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "ConfigPolicy", "Exception creating Config URI"); + } + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl(configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, String fileName) { + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("configID"); + advice.setAppliesTo(EffectType.PERMIT); + + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment1); + + // For Config file Url if configurations are provided. + if (policyAdapter.getConfigType() != null) { + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + String content = "$URL" + "/Config/" + getConfigFile(policyName); + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory().createAttributeValue(AttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment2); + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory().createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue4)); + + advice.getAttributeAssignmentExpression().add(assignment4); + + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue5)); + + advice.getAttributeAssignmentExpression().add(assignment5); + + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" + CONFIGID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getConfigName()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + + advice.getAttributeAssignmentExpression().add(assignment6); + + Map<String, String> dynamicFieldConfigAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + for (String keyField : dynamicFieldConfigAttributes.keySet()) { + String key = keyField; + String value = dynamicFieldConfigAttributes.get(key); + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId("matching:" + key); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(value); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + + advice.getAttributeAssignmentExpression().add(assignment7); + } + } + + //Risk Attributes + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("RiskType"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getRiskType()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("RiskLevel"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getRiskLevel()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("guard"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getGuard()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + + AttributeAssignmentExpressionType assignment11 = new AttributeAssignmentExpressionType(); + assignment11.setAttributeId("TTLDate"); + assignment11.setCategory(CATEGORY_RESOURCE); + assignment11.setIssuer(""); + + AttributeValueType configNameAttributeValue11 = new AttributeValueType(); + configNameAttributeValue11.setDataType(STRING_DATATYPE); + configNameAttributeValue11.getContent().add(policyAdapter.getTtlDate()); + assignment11.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue11)); + + advice.getAttributeAssignmentExpression().add(assignment11); + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBRMSRuleTemplate.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBRMSRuleTemplate.java new file mode 100644 index 000000000..7c0d2683c --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBRMSRuleTemplate.java @@ -0,0 +1,73 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.components; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.BRMSParamTemplate; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.utils.PolicyUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +public class CreateBRMSRuleTemplate { + private static final Logger LOGGER = FlexLogger.getLogger(CreateBRMSRuleTemplate.class); + private static CommonClassDao commonClassDao; + + @Autowired + public CreateBRMSRuleTemplate(CommonClassDao commonClassDao){ + CreateBRMSRuleTemplate.commonClassDao = commonClassDao; + } + + public CreateBRMSRuleTemplate() {} + + public Map<String, String> addRule(String rule, String ruleName, String description, String userID) { + Map<String,String> responseMap = new HashMap<>(); + if(rule!=null && !PolicyUtils.brmsRawValidate(rule).contains("[ERR")){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(ruleName, "ruleName", BRMSParamTemplate.class); + if(duplicateData!=null && !duplicateData.isEmpty()){ + LOGGER.error("Import new service failed. Service already exists"); + responseMap.put("DBError", "EXISTS"); + return responseMap; + }else{ + BRMSParamTemplate brmsParamTemplate = new BRMSParamTemplate(); + brmsParamTemplate.setDescription(description); + brmsParamTemplate.setRuleName(ruleName); + brmsParamTemplate.setRule(rule); + UserInfo userCreatedBy = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", userID); + brmsParamTemplate.setUserCreatedBy(userCreatedBy); + commonClassDao.save(brmsParamTemplate); + LOGGER.info("Template created with " + ruleName + " by " + userID); + } + responseMap.put("success", "success"); + }else{ + LOGGER.debug("Error during validating the rule for creating record for BRMS Param Template"); + responseMap.put("error", "VALIDATION"); + } + return responseMap; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsParamPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsParamPolicy.java new file mode 100644 index 000000000..047342ad0 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsParamPolicy.java @@ -0,0 +1,692 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.controller.BRMSDictionaryController; +import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.BRMSParamTemplate; + +import com.att.research.xacml.std.IdentifierImpl; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +public class CreateBrmsParamPolicy extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(CreateBrmsParamPolicy.class); + + public CreateBrmsParamPolicy() { + super(); + } + + public CreateBrmsParamPolicy(PolicyRestAdapter policyAdapter) { + this.policyAdapter = policyAdapter; + this.policyAdapter.setConfigType(policyAdapter.getConfigType()); + + } + + public String expandConfigBody(String ruleContents, Map<String, String> brmsParamBody) { + + Map<String,String> copyMap=new HashMap<>(); + copyMap.putAll(brmsParamBody); + copyMap.put("policyName", policyName.substring(0, policyName.replace(".xml", "").lastIndexOf("."))); + copyMap.put("policyScope", policyAdapter.getDomainDir()); + copyMap.put("policyVersion",policyAdapter.getHighestVersion().toString()); + copyMap.put("unique", ("p"+policyName+UUID.randomUUID().toString()).replaceAll("[^A-Za-z0-9]", "")); + + //Finding all the keys in the Map data-structure. + Iterator<String> iterator = copyMap.keySet().iterator(); + Pattern p; + Matcher m; + while(iterator.hasNext()) { + //Converting the first character of the key into a lower case. + String input= iterator.next(); + String output = Character.toLowerCase(input.charAt(0)) + + (input.length() > 1 ? input.substring(1) : ""); + //Searching for a pattern in the String using the key. + p=Pattern.compile("\\$\\{"+output+"\\}"); + m=p.matcher(ruleContents); + //Replacing the value with the inputs provided by the user in the editor. + String finalInput = copyMap.get(input); + if(finalInput.contains("$")){ + finalInput = finalInput.replace("$", "\\$"); + } + ruleContents=m.replaceAll(finalInput); + } + return ruleContents; + } + + + + // Utility to read json data from the existing file to a string + static String readFile(String path, Charset encoding) throws IOException { + + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); + + } + + // Saving the Configurations file at server location for config policy. + protected void saveConfigurations(String policyName, String ruleBody) { + try { + if (policyName.endsWith(".xml")) { + policyName = policyName.substring(0, + policyName.lastIndexOf(".xml")); + } + PrintWriter out = new PrintWriter(CONFIG_HOME + File.separator + policyName + ".txt"); + String expandedBody=expandConfigBody(ruleBody,policyAdapter.getBrmsParamBody()); + out.println(expandedBody); + policyAdapter.setJsonBody(expandedBody); + policyAdapter.setConfigBodyData(expandedBody); + out.close(); + + + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "CreateBrmsParamPolicy", "Exception saving configuration file"); + } + } + + + // Here we are adding the extension for the configurations file based on the + // config type selection for saving. + private String getConfigFile(String filename) { + filename = FilenameUtils.removeExtension(filename); + if (filename.endsWith(".txt")) { + filename = filename.substring(0, filename.length() - 3); + } + + filename = filename + ".txt"; + return filename; + } + + // Validations for Config form + public boolean validateConfigForm() { + + // Validating mandatory Fields. + isValidForm = true; + return isValidForm; + + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if (!isPreparedToSave()) { + prepareToSave(); + } + // Until here we prepared the data and here calling the method to create + // xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + if(successMap == null){ + successMap = new HashMap<>(); + PolicyLogger.error("Failed to Update the Database Dictionary Tables."); + successMap.put("error", "DB UPDATE"); + } + return successMap; + } + + private String getValueFromDictionary(String templateName){ + String ruleTemplate = null; + CommonClassDaoImpl dbConnection = new CommonClassDaoImpl(); + String queryString="from BRMSParamTemplate where param_template_name= '"+templateName+"'"; + List<Object> result = dbConnection.getDataByQuery(queryString); + if(!result.isEmpty()){ + BRMSParamTemplate template = (BRMSParamTemplate) result.get(0); + ruleTemplate = template.getRule(); + } + return ruleTemplate; + } + + protected Map<String, String> findType(String rule) { + Map<String, String> mapFieldType= new HashMap<>(); + if(rule!=null){ + try { + String params = ""; + Boolean flag = false; + Boolean comment = false; + String lines[] = rule.split("\n"); + for(String line : lines){ + if (line.isEmpty() || line.startsWith("//")) { + continue; + } + if (line.startsWith("/*")) { + comment = true; + continue; + } + if (line.contains("//")) { + if(!(line.contains("http://") || line.contains("https://"))){ + line = line.split("\\/\\/")[0]; + } + } + if (line.contains("/*")) { + comment = true; + if (line.contains("*/")) { + try { + comment = false; + line = line.split("\\/\\*")[0] + + line.split("\\*\\/")[1].replace("*/", ""); + } catch (Exception e) { + line = line.split("\\/\\*")[0]; + } + } else { + line = line.split("\\/\\*")[0]; + } + } + if (line.contains("*/")) { + comment = false; + try { + line = line.split("\\*\\/")[1].replace("*/", ""); + } catch (Exception e) { + line = ""; + } + } + if (comment) { + continue; + } + if (flag) { + params = params + line; + } + if (line.contains("declare Params")) { + params = params + line; + flag = true; + } + if (line.contains("end") && flag) { + break; + } + } + params = params.replace("declare Params", "").replace("end", "") + .replaceAll("\\s+", ""); + String[] components = params.split(":"); + String caption = ""; + for (int i = 0; i < components.length; i++) { + String type = ""; + if (i == 0) { + caption = components[i]; + } + if(caption.equals("")){ + break; + } + String nextComponent = ""; + try { + nextComponent = components[i + 1]; + } catch (Exception e) { + nextComponent = components[i]; + } + //If the type is of type String then we add the UI Item and type to the map. + if (nextComponent.startsWith("String")) { + type = "String"; + mapFieldType.put(caption, type); + caption = nextComponent.replace("String", ""); + } else if (nextComponent.startsWith("int")) { + type = "int"; + mapFieldType.put(caption, type); + caption = nextComponent.replace("int", ""); + } + } + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CreateBrmsParamPolicy", "Exception parsing file in findType"); + } + } + return mapFieldType; + } + + // This is the method for preparing the policy for saving. We have broken it + // out + // separately because the fully configured policy is used for multiple + // things + @Override + public boolean prepareToSave() throws Exception { + + if (isPreparedToSave()) { + // we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in + // marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + + policyName = policyAdapter.getNewFileName(); + + if (policyAdapter.getData() != null) { + Map<String,String> ruleAndUIValue= policyAdapter.getBrmsParamBody(); + String tempateValue= ruleAndUIValue.get("templateName"); + String valueFromDictionary= getValueFromDictionary(tempateValue); + + //Get the type of the UI Fields. + Map<String,String> typeOfUIField=findType(valueFromDictionary); + String generatedRule=null; + String body = ""; + + try { + + try { + body = "/* Autogenerated Code Please Don't change/remove this comment section. This is for the UI purpose. \n\t " + + "<$%BRMSParamTemplate=" + tempateValue + "%$> \n */ \n"; + body = body + valueFromDictionary + "\n"; + generatedRule = "rule \"" +policyName.substring(0, policyName.replace(".xml", "").lastIndexOf(".")) +".Params\" \n\tsalience 1000 \n\twhen\n\tthen\n\t\tParams params = new Params();"; + + //We first read the map data structure(ruleAndUIValue) received from the PAP-ADMIN + //We ignore if the key is "templateName as we are interested only in the UI fields and its value. + //We have one more map data structure(typeOfUIField) created by parsing the Drools rule. + //From the type of the UI field(String/int) we structure whether to put the "" or not. + for (Map.Entry<String, String> entry : ruleAndUIValue.entrySet()) { + if(entry.getKey()!="templateName") + { + for(Map.Entry<String, String> fieldType:typeOfUIField.entrySet()) + { + if(fieldType.getKey().equalsIgnoreCase(entry.getKey())) + { + String key = entry.getKey().substring(0, 1).toUpperCase() + entry.getKey().substring(1); + if(fieldType.getValue()=="String") + { + //Type is String + generatedRule = generatedRule + "\n\t\tparams.set" + + key + "(\"" + + entry.getValue() + "\");"; + } + else{ + generatedRule = generatedRule + "\n\t\tparams.set" + + key + "(" + + entry.getValue() + ");"; + } + } + } + } + } + + generatedRule = generatedRule + + "\n\t\tinsert(params);\nend"; + LOGGER.info("New rule generated with :" + generatedRule); + body = body + generatedRule; + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "CreateBrmsParamPolicy", "Exception saving policy"); + } + } + catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "CreateBrmsParamPolicy", "Exception saving policy"); + } + + saveConfigurations(policyName,body); + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, + fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + + + AllOfType allOf = new AllOfType(); + + // Match for ONAPName + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + allOf.getMatch().add(createMatch("ConfigName", policyAdapter.getConfigName())); + // Match for riskType + allOf.getMatch().add(createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add(createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add(createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add(createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateBrmsParamPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl( + accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + + configAttributeValue.getContent().add("Config"); + + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try { + configURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateBrmsParamPolicy", "Exception creating Config URI"); + } + + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl(configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy + .getCombinerParametersOrRuleCombinerParametersOrVariableDefinition() + .add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, + String fileName) { + + //Policy Config ID Assignment + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("BRMSPARAMID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment1); + + // For Config file Url if configurations are provided. + // URL ID Assignment + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + + String content = CONFIG_URL + "/Config/"+ getConfigFile(policyName); + + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory() + .createAttributeValue(AttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment2); + + // Policy Name Assignment + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, + fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, + fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory() + .createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + // Version Number Assignment + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue4)); + advice.getAttributeAssignmentExpression().add(assignment4); + + // Onap Name Assignment + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue5)); + advice.getAttributeAssignmentExpression().add(assignment5); + + + //Config Name Assignment + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" +CONFIGID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getConfigName()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + advice.getAttributeAssignmentExpression().add(assignment6); + // Adding Controller Information. + if(policyAdapter.getBrmsController()!=null){ + BRMSDictionaryController brmsDicitonaryController = new BRMSDictionaryController(); + advice.getAttributeAssignmentExpression().add( + createResponseAttributes("controller:"+ policyAdapter.getBrmsController(), + brmsDicitonaryController.getControllerDataByID(policyAdapter.getBrmsController()).getController())); + } + + // Adding Dependencies. + if(policyAdapter.getBrmsDependency()!=null){ + BRMSDictionaryController brmsDicitonaryController = new BRMSDictionaryController(); + ArrayList<String> dependencies = new ArrayList<>(); + StringBuilder key = new StringBuilder(); + for(String dependencyName: policyAdapter.getBrmsDependency()){ + dependencies.add(brmsDicitonaryController.getDependencyDataByID(dependencyName).getDependency()); + key.append(dependencyName + ","); + } + advice.getAttributeAssignmentExpression().add( + createResponseAttributes("dependencies:"+key.toString(), dependencies.toString())); + } + + // Dynamic Field Config Attributes. + Map<String, String> dynamicFieldConfigAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + for (String keyField : dynamicFieldConfigAttributes.keySet()) { + advice.getAttributeAssignmentExpression().add(createResponseAttributes("key:"+keyField, dynamicFieldConfigAttributes.get(keyField))); + } + + //Risk Attributes + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("RiskType"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getRiskType()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("RiskLevel"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getRiskLevel()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("guard"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getGuard()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + + AttributeAssignmentExpressionType assignment11 = new AttributeAssignmentExpressionType(); + assignment11.setAttributeId("TTLDate"); + assignment11.setCategory(CATEGORY_RESOURCE); + assignment11.setIssuer(""); + + AttributeValueType configNameAttributeValue11 = new AttributeValueType(); + configNameAttributeValue11.setDataType(STRING_DATATYPE); + configNameAttributeValue11.getContent().add(policyAdapter.getTtlDate()); + assignment11.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue11)); + + advice.getAttributeAssignmentExpression().add(assignment11); + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getData(); + } + + private AttributeAssignmentExpressionType createResponseAttributes(String key, String value){ + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId(key); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(value); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + return assignment7; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsRawPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsRawPolicy.java new file mode 100644 index 000000000..4bcb05788 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateBrmsRawPolicy.java @@ -0,0 +1,489 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + + +import java.io.File; +import java.io.IOException; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.controller.BRMSDictionaryController; +import org.onap.policy.rest.adapter.PolicyRestAdapter; + +import com.att.research.xacml.std.IdentifierImpl; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + + +public class CreateBrmsRawPolicy extends Policy { + + public CreateBrmsRawPolicy() { + super(); + } + + public CreateBrmsRawPolicy(PolicyRestAdapter policyAdapter) { + this.policyAdapter = policyAdapter; + this.policyAdapter.setConfigType(policyAdapter.getConfigType()); + + } + + // Saving the Configurations file at server location for CreateBrmsRawPolicy policy. + protected void saveConfigurations(String policyName, String jsonBody) { + try { + if (policyName.endsWith(".xml")) { + policyName = policyName.substring(0, + policyName.lastIndexOf(".xml")); + } + PrintWriter out = new PrintWriter(CONFIG_HOME + File.separator + policyName + ".txt"); + out.println(jsonBody); + out.close(); + + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "CreateBrmsRawPolicy", "Exception saving configurations file"); + } + } + + // Utility to read json data from the existing file to a string + static String readFile(String path, Charset encoding) throws IOException { + + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); + + } + + // Here we are adding the extension for the configurations file based on the + // config type selection for saving. + private String getConfigFile(String filename) { + filename = FilenameUtils.removeExtension(filename); + if (filename.endsWith(".txt")) { + filename = filename.substring(0, filename.length() - 3); + } + + filename = filename + ".txt"; + return filename; + } + + // Validations for Config form + public boolean validateConfigForm() { + + // Validating mandatory Fields. + isValidForm = true; + return isValidForm; + + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if (!isPreparedToSave()) { + prepareToSave(); + } + // Until here we prepared the data and here calling the method to create + // xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + + successMap = createPolicy(newPolicyPath, getCorrectPolicyDataObject()); + if (successMap == null) { + successMap = new HashMap<>(); + PolicyLogger.error("Failed to Update the Database Dictionary Tables."); + successMap.put("error", "DB UPDATE"); + } + + return successMap; + } + + // This is the method for preparing the policy for saving. We have broken it + // out + // separately because the fully configured policy is used for multiple + // things + @Override + public boolean prepareToSave() throws Exception { + + if (isPreparedToSave()) { + // we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in + // marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + + policyName = policyAdapter.getNewFileName(); + + if (policyAdapter.getData() != null) { + //String jsonBody = policyAdapter.getJsonBody(); + String configBody=policyAdapter.getConfigBodyData(); + saveConfigurations(policyName, configBody); + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, + fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + + + AllOfType allOf = new AllOfType(); + + // Match for ONAPName + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + allOf.getMatch().add(createMatch("ConfigName", policyAdapter.getConfigName())); + // Match for riskType + allOf.getMatch().add(createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add(createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add(createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add(createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateBrmsRawPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl( + accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + + configAttributeValue.getContent().add("Config"); + + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try { + configURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateBrmsRawPolicy", "Exception creating Config URI"); + } + + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl( + configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy + .getCombinerParametersOrRuleCombinerParametersOrVariableDefinition() + .add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, + String fileName) { + + // Policy Config ID Assignment + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("BRMSRAWID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment1); + + // For Config file Url if configurations are provided. + // URL ID Assignment + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + + String content = CONFIG_URL + "/Config/" + getConfigFile(policyName); + + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory() + .createAttributeValue(AttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment2); + + // Policy Name Assignment + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + System.out.println(fileName); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, + fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, + fileName.length()); + } + System.out.println(name); + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory() + .createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + // Version Number Assignment + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue4)); + advice.getAttributeAssignmentExpression().add(assignment4); + + // Onap Name Assignment + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory() + .createAttributeValue(configNameAttributeValue5)); + advice.getAttributeAssignmentExpression().add(assignment5); + + + //Config Name Assignment + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" + CONFIGID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getConfigName()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + advice.getAttributeAssignmentExpression().add(assignment6); + + // Adding Controller Information. + if(policyAdapter.getBrmsController()!=null){ + BRMSDictionaryController brmsDicitonaryController = new BRMSDictionaryController(); + advice.getAttributeAssignmentExpression().add( + createResponseAttributes("controller:"+ policyAdapter.getBrmsController(), + brmsDicitonaryController.getControllerDataByID(policyAdapter.getBrmsController()).getController())); + } + + // Adding Dependencies. + if(policyAdapter.getBrmsDependency()!=null){ + BRMSDictionaryController brmsDicitonaryController = new BRMSDictionaryController(); + ArrayList<String> dependencies = new ArrayList<>(); + StringBuilder key = new StringBuilder(); + for(String dependencyName: policyAdapter.getBrmsDependency()){ + dependencies.add(brmsDicitonaryController.getDependencyDataByID(dependencyName).getDependency()); + key.append(dependencyName + ","); + } + advice.getAttributeAssignmentExpression().add( + createResponseAttributes("dependencies:"+key.toString(), dependencies.toString())); + } + + // Dynamic Field Config Attributes. + Map<String, String> dynamicFieldConfigAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + for (String keyField : dynamicFieldConfigAttributes.keySet()) { + advice.getAttributeAssignmentExpression().add(createResponseAttributes("key:"+keyField, dynamicFieldConfigAttributes.get(keyField))); + } + + //Risk Attributes + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("RiskType"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getRiskType()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("RiskLevel"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getRiskLevel()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("guard"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getGuard()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + + AttributeAssignmentExpressionType assignment11 = new AttributeAssignmentExpressionType(); + assignment11.setAttributeId("TTLDate"); + assignment11.setCategory(CATEGORY_RESOURCE); + assignment11.setIssuer(""); + + AttributeValueType configNameAttributeValue11 = new AttributeValueType(); + configNameAttributeValue11.setDataType(STRING_DATATYPE); + configNameAttributeValue11.getContent().add(policyAdapter.getTtlDate()); + assignment11.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue11)); + + advice.getAttributeAssignmentExpression().add(assignment11); + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getData(); + } + + private AttributeAssignmentExpressionType createResponseAttributes(String key, String value){ + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId(key); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(value); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + return assignment7; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateClosedLoopPerformanceMetrics.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateClosedLoopPerformanceMetrics.java new file mode 100644 index 000000000..ada704465 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateClosedLoopPerformanceMetrics.java @@ -0,0 +1,412 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + + +import java.io.File; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.adapter.PolicyRestAdapter; + +import com.att.research.xacml.std.IdentifierImpl; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +public class CreateClosedLoopPerformanceMetrics extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(CreateClosedLoopPerformanceMetrics.class); + + public CreateClosedLoopPerformanceMetrics() { + super(); + } + + public CreateClosedLoopPerformanceMetrics(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + //save configuration of the policy based on the policyname + private void saveConfigurations(String policyName, String jsonBody) { + try { + String body = null; + try { + body = jsonBody; + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + if(policyName.endsWith(".xml")){ + policyName = policyName.substring(0, policyName.lastIndexOf(".xml")); + } + PrintWriter out = new PrintWriter(CONFIG_HOME + File.separator + "."+ policyName +".json"); + out.println(body); + policyAdapter.setJsonBody(body); + policyAdapter.setConfigBodyData(body); + out.close(); + + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + } + + //getting the policy name and setting to configuration on adding .json + private String getConfigFile(String filename) { + filename = FilenameUtils.removeExtension(filename); + if (filename.endsWith(".xml")) { + filename = filename.substring(0, filename.length() - 4); + } + filename = filename +".json"; + return filename; + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + policyName = policyAdapter.getNewFileName(); + if (policyAdapter.getData() != null) { + // Save the Configurations file with the policy name with extention based on selection. + String jsonBody = policyAdapter.getJsonBody(); + saveConfigurations(policyName, jsonBody); + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + AllOfType allOf = new AllOfType(); + + // Adding the matches to AllOfType element Match for Onap + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + // Match for riskType + allOf.getMatch().add( + createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add( + createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add( + createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add( + createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + // Match for ServiceType + allOf.getMatch().add(createMatch("ServiceType", policyAdapter.getServiceType())); + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateClosedLoopPerformanceMetrics", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + configAttributeValue.getContent().add("Config"); + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try { + configURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "CreateClosedLoopPerformanceMetrics", "Exception creating Config URI"); + } + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl(configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + @SuppressWarnings("static-access") + private AdviceExpressionsType getAdviceExpressions(int version, String fileName) { + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("PMID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment1); + // For Config file Url if configurations are provided. + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + String content = CONFIG_URL +"/Config/"+ getConfigFile(policyName); + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory().createAttributeValue(AttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment2); + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory().createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue4)); + + advice.getAttributeAssignmentExpression().add(assignment4); + + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + this.ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue5)); + + advice.getAttributeAssignmentExpression().add(assignment5); + + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" + this.CLOSEDLOOPID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getServiceType()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + + advice.getAttributeAssignmentExpression().add(assignment6); + + //Risk Attributes + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId("RiskType"); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(policyAdapter.getRiskType()); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + + advice.getAttributeAssignmentExpression().add(assignment7); + + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("RiskLevel"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getRiskLevel()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("guard"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getGuard()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("TTLDate"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getTtlDate()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateNewMicroServiceModel.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateNewMicroServiceModel.java new file mode 100644 index 000000000..fd9e49c7e --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/CreateNewMicroServiceModel.java @@ -0,0 +1,248 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.zip.ZipEntry; +import java.util.zip.ZipFile; + +import org.apache.commons.io.FileUtils; +import org.apache.commons.lang.StringUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl; +import org.onap.policy.rest.jpa.MicroServiceModels; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.rest.util.MSAttributeObject; +import org.onap.policy.rest.util.MSModelUtils; +import org.onap.policy.rest.util.MSModelUtils.MODEL_TYPE; + +public class CreateNewMicroServiceModel { + private static final Logger logger = FlexLogger.getLogger(CreateNewMicroServiceModel.class); + private MicroServiceModels newModel = null; + private HashMap<String,MSAttributeObject > classMap = new HashMap<>(); + + + MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName()); + + public CreateNewMicroServiceModel(String fileName, String serviceName, String string, String version) { + super(); + } + + public CreateNewMicroServiceModel(String importFile, String modelName, String description, String version, String randomID) { + + this.newModel = new MicroServiceModels(); + this.newModel.setVersion(version); + this.newModel.setModelName(modelName); + UserInfo userInfo = new UserInfo(); + userInfo.setUserLoginId("API"); + this.newModel.setUserCreatedBy(userInfo); + String cleanUpFile = null; + + HashMap<String, MSAttributeObject> tempMap = new HashMap<>(); + //Need to delete the file + if (importFile.contains(".zip")){ + extractFolder(randomID + ".zip"); + File directory = new File("ExtractDir" + File.separator + randomID); + List<File> fileList = listModelFiles(directory.toString()); + //get all the files from a director + for (File file : fileList){ + if (file.isFile()){ + tempMap = utils.processEpackage(file.getAbsolutePath(), MODEL_TYPE.XMI); + classMap.putAll(tempMap); + } + } + cleanUpFile = "ExtractDir" + File.separator + randomID + ".zip"; + try { + FileUtils.deleteDirectory(new File("ExtractDir" + File.separator + randomID)); + FileUtils.deleteDirectory(new File(randomID)); + File deleteFile = new File(cleanUpFile); + FileUtils.forceDelete(deleteFile); + } catch (IOException e) { + logger.error("Failed to unzip model file " + randomID); + } + }else { + tempMap = utils.processEpackage("ExtractDir" + File.separator + randomID+".xmi", MODEL_TYPE.XMI); + classMap.putAll(tempMap); + cleanUpFile = "ExtractDir" + File.separator + randomID+".xmi"; + File deleteFile = new File(cleanUpFile); + deleteFile.delete(); + } + } + + private List<File> listModelFiles(String directoryName) { + File directory = new File(directoryName); + List<File> resultList = new ArrayList<>(); + File[] fList = directory.listFiles(); + for (File file : fList) { + if (file.isFile()) { + resultList.add(file); + } else if (file.isDirectory()) { + resultList.addAll(listModelFiles(file.getAbsolutePath())); + } + } + return resultList; + } + + @SuppressWarnings("rawtypes") + private void extractFolder(String zipFile) { + int BUFFER = 2048; + File file = new File(zipFile); + + ZipFile zip = null; + try { + zip = new ZipFile("ExtractDir" + File.separator +file); + String newPath = zipFile.substring(0, zipFile.length() - 4); + new File(newPath).mkdir(); + Enumeration zipFileEntries = zip.entries(); + + // Process each entry + while (zipFileEntries.hasMoreElements()){ + // grab a zip file entry + ZipEntry entry = (ZipEntry) zipFileEntries.nextElement(); + String currentEntry = entry.getName(); + File destFile = new File("ExtractDir" + File.separator + newPath + File.separator + currentEntry); + File destinationParent = destFile.getParentFile(); + + destinationParent.mkdirs(); + + if (!entry.isDirectory()){ + BufferedInputStream is = new BufferedInputStream(zip + .getInputStream(entry)); + int currentByte; + + byte data[] = new byte[BUFFER]; + + FileOutputStream fos = new FileOutputStream(destFile); + BufferedOutputStream dest = new BufferedOutputStream(fos, + BUFFER); + + while ((currentByte = is.read(data, 0, BUFFER)) != -1) { + dest.write(data, 0, currentByte); + } + dest.flush(); + dest.close(); + is.close(); + } + + if (currentEntry.endsWith(".zip")){ + extractFolder(destFile.getAbsolutePath()); + } + } + } catch (IOException e) { + logger.error("Failed to unzip model file " + zipFile + e); + }finally{ + if(zip != null){ + try { + zip.close(); + } catch (Exception e) { + logger.error("Exception Occured while closing the zip file"+e); + } + } + } + } + + public Map<String, String> addValuesToNewModel() { + + Map<String, String> successMap = new HashMap<>(); + MSAttributeObject mainClass = null; + ArrayList<String> dependency = null; + String subAttribute = null; + + if (!classMap.containsKey(this.newModel.getModelName())){ + logger.error("Model Provided does not contain the service name provided in request. Unable to import new model"); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "AddValuesToNewModel", "Unable to pull out required values, file missing service name provided in request"); + successMap.put("error", "MISSING"); + return successMap; + } + mainClass = classMap.get(this.newModel.getModelName()); + String dependTemp = StringUtils.replaceEach(mainClass.getDependency(), new String[]{"[", "]", " "}, new String[]{"", "", ""}); + this.newModel.setDependency(dependTemp); + if (!this.newModel.getDependency().equals("")){ + dependency = new ArrayList<String>(Arrays.asList(dependTemp.split(","))); + dependency = utils.getFullDependencyList(dependency, classMap); + if (!dependency.isEmpty()){ + for (String element : dependency){ + MSAttributeObject temp = new MSAttributeObject(); + if (classMap.containsKey(element)){ + temp = classMap.get(element); + mainClass.addAllRefAttribute(temp.getRefAttribute()); + mainClass.addAllAttribute(temp.getAttribute()); + } + } + } + } + subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName()); + + this.newModel.setSub_attributes(subAttribute); + this.newModel.setAttributes(mainClass.getAttribute().toString().replace("{", "").replace("}", "")); + this.newModel.setRef_attributes(mainClass.getRefAttribute().toString().replace("{", "").replace("}", "")); + this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", "")); + this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", "")); + successMap.put("success", "success"); + return successMap; + + } + + public Map<String, String> saveImportService(){ + String modelName = this.newModel.getModelName(); + String imported_by = "API"; + String version = this.newModel.getVersion(); + Map<String, String> successMap = new HashMap<>(); + CommonClassDaoImpl dbConnection = new CommonClassDaoImpl(); + List<Object> result = dbConnection.getDataById(MicroServiceModels.class, "modelName:version", modelName+":"+version); + if(result.isEmpty()){ + MicroServiceModels model = new MicroServiceModels(); + model.setModelName(modelName); + model.setVersion(version); + model.setAttributes(this.newModel.getAttributes()); + model.setAnnotation(this.newModel.getAnnotation()); + model.setDependency(this.newModel.getDependency()); + model.setDescription(this.newModel.getDescription()); + model.setEnumValues(this.newModel.getEnumValues()); + model.setRef_attributes(this.newModel.getRef_attributes()); + model.setSub_attributes(this.newModel.getSub_attributes()); + UserInfo userInfo = new UserInfo(); + userInfo.setUserLoginId(imported_by); + userInfo.setUserName(imported_by); + model.setUserCreatedBy(userInfo); + dbConnection.save(model); + successMap.put("success", "success"); + }else{ + successMap.put("DBError", "EXISTS"); + logger.error("Import new service failed. Service already exists"); + } + return successMap; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java new file mode 100644 index 000000000..fe9c581e9 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/DecisionPolicy.java @@ -0,0 +1,793 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.controlloop.policy.builder.BuilderException; +import org.onap.policy.controlloop.policy.builder.Results; +import org.onap.policy.controlloop.policy.guard.Constraint; +import org.onap.policy.controlloop.policy.guard.ControlLoopGuard; +import org.onap.policy.controlloop.policy.guard.Guard; +import org.onap.policy.controlloop.policy.guard.GuardPolicy; +import org.onap.policy.controlloop.policy.guard.MatchParameters; +import org.onap.policy.controlloop.policy.guard.builder.ControlLoopGuardBuilder; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.util.JPAUtils; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.DecisionSettings; +import org.onap.policy.rest.jpa.FunctionDefinition; +import org.onap.policy.utils.PolicyUtils; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.std.pip.engines.aaf.AAFEngine; +import org.onap.policy.xacml.util.XACMLPolicyScanner; + +import com.att.research.xacml.std.IdentifierImpl; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ApplyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ConditionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableDefinitionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.VariableReferenceType; + +public class DecisionPolicy extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(DecisionPolicy.class); + + public static final String FUNCTION_NOT = "urn:oasis:names:tc:xacml:1.0:function:not"; + private static final String AAFPROVIDER = "AAF"; + public static final String GUARD_YAML = "GUARD_YAML"; + public static final String GUARD_BL_YAML = "GUARD_BL_YAML"; + public static final String RAINY_DAY = "Rainy_Day"; + private static final String XACML_GUARD_TEMPLATE = "Decision_GuardPolicyTemplate.xml"; + private static final String XACML_BLGUARD_TEMPLATE = "Decision_GuardBLPolicyTemplate.xml"; + + private static final String ONAPNAME = "ONAPName"; + private static final String POLICY_NAME = "PolicyName"; + private static final String DESCRIPTION = "description"; + + + List<String> dynamicLabelRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldComboRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldOneRuleAlgorithms = new LinkedList<>(); + List<String> dynamicFieldTwoRuleAlgorithms = new LinkedList<>(); + List<String> dataTypeList = new LinkedList<>(); + + protected Map<String, String> dropDownMap = new HashMap<>(); + + + public DecisionPolicy() { + super(); + } + + public DecisionPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if ("Decision".equals(policyAdapter.getPolicyType())) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + policyName = policyAdapter.getNewFileName(); + + if(policyAdapter.getRuleProvider().equals(GUARD_YAML) || policyAdapter.getRuleProvider().equals(GUARD_BL_YAML)){ + Map<String, String> yamlParams = new HashMap<>(); + yamlParams.put(DESCRIPTION, (policyAdapter.getPolicyDescription()!=null)? policyAdapter.getPolicyDescription(): "YAML Guard Policy"); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf('\\') + 1, fileName.length()); + if ((name == null) || ("".equals(name))) { + name = fileName.substring(fileName.lastIndexOf('/') + 1, fileName.length()); + } + yamlParams.put(POLICY_NAME, name); + yamlParams.put(ONAPNAME, policyAdapter.getOnapName()); + Map<String, String> params = policyAdapter.getDynamicFieldConfigAttributes(); + yamlParams.putAll(params); + // Call YAML to XACML + PolicyType decisionPolicy = getGuardPolicy(yamlParams, policyAdapter.getRuleProvider()); + decisionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + decisionPolicy.setVersion(Integer.toString(version)); + policyAdapter.setPolicyData(decisionPolicy); + policyAdapter.setData(decisionPolicy); + }else if (policyAdapter.getData() != null) { + PolicyType decisionPolicy = (PolicyType) policyAdapter.getData(); + + decisionPolicy.setDescription(policyAdapter.getPolicyDescription()); + + decisionPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf('\\') + 1, fileName.length()); + if ((name == null) || ("".equals(name))) { + name = fileName.substring(fileName.lastIndexOf('/') + 1, fileName.length()); + } + allOfOne.getMatch().add(createMatch(POLICY_NAME, name)); + + AllOfType allOf = new AllOfType(); + + // Match for Onap + allOf.getMatch().add(createMatch(ONAPNAME, (policyAdapter.getOnapName()))); + + Map<String, String> dynamicFieldComponentAttributes = policyAdapter.getDynamicFieldConfigAttributes(); + if(policyAdapter.getRuleProvider()!=null && policyAdapter.getRuleProvider().equals(AAFPROVIDER)){ + dynamicFieldComponentAttributes = new HashMap<>(); + } + + // If there is any dynamic field attributes create the matches here + for (String keyField : dynamicFieldComponentAttributes.keySet()) { + String key = keyField; + String value = dynamicFieldComponentAttributes.get(key); + MatchType dynamicMatch = createDynamicMatch(key, value); + allOf.getMatch().add(dynamicMatch); + } + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + target.getAnyOf().add(anyOf); + decisionPolicy.setTarget(target); + + Map<String, String> dynamicFieldDecisionSettings = policyAdapter.getDynamicSettingsMap(); + if(policyAdapter.getRuleProvider()!=null && policyAdapter.getRuleProvider().equals(AAFPROVIDER)){ + dynamicFieldDecisionSettings = new HashMap<>(); + } + + // settings are dynamic so check how many rows are added and add all + for (String keyField : dynamicFieldDecisionSettings.keySet()) { + String key = keyField; + String value = dynamicFieldDecisionSettings.get(key); + String dataType = getDataType(key); + VariableDefinitionType dynamicVariable = createDynamicVariable(key, value, dataType); + decisionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(dynamicVariable); + } + Map<String, String> dynamicFieldTreatmentAttributes = policyAdapter.getRainydayMap(); + + if(policyAdapter.getRuleProvider().equals(RAINY_DAY)){ + for(String keyField : dynamicFieldTreatmentAttributes.keySet()) { + String errorcode = keyField; + String treatment = dynamicFieldTreatmentAttributes.get(errorcode); + createRainydayRule(decisionPolicy, errorcode, treatment, true); + } + } else { + createRule(decisionPolicy, true); + createRule(decisionPolicy, false); + } + + } + setPreparedToSave(true); + return true; + } + + public PolicyType getGuardPolicy(Map<String, String> yamlParams, String ruleProvider) throws BuilderException{ + try { + ControlLoopGuardBuilder builder = ControlLoopGuardBuilder.Factory.buildControlLoopGuard(new Guard()); + MatchParameters matchParameters = new MatchParameters(yamlParams.get("actor"), yamlParams.get("recipe")); + matchParameters.setControlLoopName(yamlParams.get("clname")); + if(yamlParams.containsKey("targets")){ + String targetString = yamlParams.get("targets"); + List<String> targets = null; + if(targetString!=null && !targetString.isEmpty()){ + if (targetString.contains(",")){ + targets = Arrays.asList(targetString.split(",")); + } + else{ + targets = new ArrayList<>(); + targets.add(targetString); + } + } + matchParameters.setTargets(targets); + } + GuardPolicy policy1 = new GuardPolicy((policyAdapter.getUuid()!=null? policyAdapter.getUuid(): UUID.randomUUID().toString()) ,yamlParams.get(POLICY_NAME), yamlParams.get(DESCRIPTION), matchParameters); + builder = builder.addGuardPolicy(policy1); + Map<String, String> activeTimeRange = new HashMap<>(); + activeTimeRange.put("start", yamlParams.get("guardActiveStart")); + activeTimeRange.put("end", yamlParams.get("guardActiveEnd")); + String blackListString = yamlParams.get("blackList"); + List<String> blackList = null; + if(blackListString!=null){ + if (blackListString.contains(",")){ + blackList = Arrays.asList(blackListString.split(",")); + } + else{ + blackList = new ArrayList<>(); + blackList.add(blackListString); + } + } + File templateFile; + Path xacmlTemplatePath; + ClassLoader classLoader = getClass().getClassLoader(); + Constraint cons = new Constraint(); + switch (ruleProvider){ + case GUARD_BL_YAML: + templateFile = new File(classLoader.getResource(XACML_BLGUARD_TEMPLATE).getFile()); + xacmlTemplatePath = templateFile.toPath(); + cons.setActive_time_range(activeTimeRange); + cons.setBlacklist(blackList); + break; + default: + templateFile = new File(classLoader.getResource(XACML_GUARD_TEMPLATE).getFile()); + xacmlTemplatePath = templateFile.toPath(); + Map<String,String> timeWindow = new HashMap<>(); + if(!PolicyUtils.isInteger(yamlParams.get("timeWindow"))){ + throw new BuilderException("time window is not in Integer format."); + } + String timeUnits = yamlParams.get("timeUnits"); + if(timeUnits==null || !(timeUnits.equalsIgnoreCase("minute") || timeUnits.equalsIgnoreCase("hour") || timeUnits.equalsIgnoreCase("day") + || timeUnits.equalsIgnoreCase("week") || timeUnits.equalsIgnoreCase("month")||timeUnits.equalsIgnoreCase("year"))){ + throw new BuilderException("time Units is not in proper format."); + } + timeWindow.put("value", yamlParams.get("timeWindow")); + timeWindow.put("units", yamlParams.get("timeUnits")); + cons = new Constraint(Integer.parseInt(yamlParams.get("limit")),timeWindow,activeTimeRange); + break; + } + builder = builder.addLimitConstraint(policy1.getId(), cons); + // Build the specification + Results results = builder.buildSpecification(); + // YAML TO XACML + ControlLoopGuard yamlGuardObject = SafePolicyBuilder.loadYamlGuard(results.getSpecification()); + String xacmlTemplateContent; + try { + xacmlTemplateContent = new String(Files.readAllBytes(xacmlTemplatePath)); + HashMap<String, String> yamlSpecs = new HashMap<>(); + yamlSpecs.put(POLICY_NAME, yamlParams.get(POLICY_NAME)); + yamlSpecs.put(DESCRIPTION, yamlParams.get(DESCRIPTION)); + yamlSpecs.put(ONAPNAME, yamlParams.get(ONAPNAME)); + yamlSpecs.put("actor", yamlGuardObject.getGuards().getFirst().getMatch_parameters().getActor()); + yamlSpecs.put("recipe", yamlGuardObject.getGuards().getFirst().getMatch_parameters().getRecipe()); + yamlSpecs.put("clname", yamlGuardObject.getGuards().getFirst().getMatch_parameters().getControlLoopName()); + if(yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getFreq_limit_per_target()!=null){ + yamlSpecs.put("limit", yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getFreq_limit_per_target().toString()); + } + if(yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getTime_window()!=null){ + yamlSpecs.put("twValue", yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getTime_window().get("value")); + yamlSpecs.put("twUnits", yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getTime_window().get("units")); + } + yamlSpecs.put("guardActiveStart", yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getActive_time_range().get("start")); + yamlSpecs.put("guardActiveEnd", yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getActive_time_range().get("end")); + String xacmlPolicyContent = SafePolicyBuilder.generateXacmlGuard(xacmlTemplateContent,yamlSpecs, yamlGuardObject.getGuards().getFirst().getLimit_constraints().getFirst().getBlacklist(), yamlGuardObject.getGuards().getFirst().getMatch_parameters().getTargets()); + // Convert the Policy into Stream input to Policy Adapter. + Object policy = XACMLPolicyScanner.readPolicy(new ByteArrayInputStream(xacmlPolicyContent.getBytes(StandardCharsets.UTF_8))); + return (PolicyType) policy; + } catch (IOException e) { + LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Error while creating the policy " + e.getMessage() , e); + } + } catch (BuilderException e) { + LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Error while creating the policy " + e.getMessage() ,e); + throw e; + } + return null; + } + + private DecisionSettings findDecisionSettingsBySettingId(String settingId) { + DecisionSettings decisionSetting = null; + + EntityManager em = XACMLPapServlet.getEmf().createEntityManager(); + Query getDecisionSettings = em.createNamedQuery("DecisionSettings.findAll"); + List<?> decisionSettingsList = getDecisionSettings.getResultList(); + + for (Object id : decisionSettingsList) { + decisionSetting = (DecisionSettings) id; + if (decisionSetting.getXacmlId().equals(settingId)) { + break; + } + } + return decisionSetting; + } + + private void createRule(PolicyType decisionPolicy, boolean permitRule) { + RuleType rule = new RuleType(); + + rule.setRuleId(policyAdapter.getRuleID()); + + if (permitRule) { + rule.setEffect(EffectType.PERMIT); + } else { + rule.setEffect(EffectType.DENY); + } + rule.setTarget(new TargetType()); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("DECIDE"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "DecisionPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + dynamicLabelRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmLabels(); + dynamicFieldComboRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmCombo(); + dynamicFieldOneRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField1(); + dynamicFieldTwoRuleAlgorithms = policyAdapter.getDynamicRuleAlgorithmField2(); + dropDownMap = createDropDownMap(); + + if(policyAdapter.getRuleProvider()!=null && policyAdapter.getRuleProvider().equals(AAFPROVIDER)){ + // Values for AAF Provider are here for XML Creation. + ConditionType condition = new ConditionType(); + ApplyType decisionApply = new ApplyType(); + String selectedFunction = "boolean-equal"; + + AttributeValueType value1 = new AttributeValueType(); + value1.setDataType(BOOLEAN_DATATYPE); + value1.getContent().add("true"); + + AttributeDesignatorType value2 = new AttributeDesignatorType(); + value2.setAttributeId(AAFEngine.AAF_RESULT); + value2.setCategory(CATEGORY_RESOURCE); + value2.setDataType(BOOLEAN_DATATYPE); + value2.setMustBePresent(false); + + ApplyType innerDecisionApply = new ApplyType(); + innerDecisionApply.setFunctionId(FUNCTION_BOOLEAN_ONE_AND_ONLY); + innerDecisionApply.getExpression().add(new ObjectFactory().createAttributeDesignator(value2)); + + decisionApply.setFunctionId(dropDownMap.get(selectedFunction)); + decisionApply.getExpression().add(new ObjectFactory().createAttributeValue(value1)); + decisionApply.getExpression().add(new ObjectFactory().createApply(innerDecisionApply)); + condition.setExpression(new ObjectFactory().createApply(decisionApply)); + if (!permitRule) { + ApplyType notOuterApply = new ApplyType(); + notOuterApply.setFunctionId(FUNCTION_NOT); + notOuterApply.getExpression().add(condition.getExpression()); + condition.setExpression(new ObjectFactory().createApply(notOuterApply)); + } + rule.setCondition(condition); + allOfInRule.getMatch().add(accessMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + if(!permitRule){ + AdviceExpressionsType adviceExpressions = new AdviceExpressionsType(); + AdviceExpressionType adviceExpression = new AdviceExpressionType(); + adviceExpression.setAdviceId(AAFPROVIDER); + adviceExpression.setAppliesTo(EffectType.DENY); + AttributeAssignmentExpressionType assignment = new AttributeAssignmentExpressionType(); + assignment.setAttributeId("aaf.response"); + assignment.setCategory(CATEGORY_RESOURCE); + AttributeDesignatorType value = new AttributeDesignatorType(); + value.setAttributeId(AAFEngine.AAF_RESPONSE); + value.setCategory(CATEGORY_RESOURCE); + value.setDataType(STRING_DATATYPE); + value.setMustBePresent(false); + assignment.setExpression(new ObjectFactory().createAttributeDesignator(value)); + adviceExpression.getAttributeAssignmentExpression().add(assignment); + adviceExpressions.getAdviceExpression().add(adviceExpression); + rule.setAdviceExpressions(adviceExpressions); + } + decisionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(decisionPolicy); + + }else if (dynamicLabelRuleAlgorithms != null && !dynamicLabelRuleAlgorithms.isEmpty()) { + boolean isCompound = false; + ConditionType condition = new ConditionType(); + int index = dynamicFieldOneRuleAlgorithms.size() - 1; + + for (String labelAttr : dynamicLabelRuleAlgorithms) { + // if the rule algorithm as a label means it is a compound + if (dynamicFieldOneRuleAlgorithms.get(index).equals(labelAttr)) { + ApplyType decisionApply = new ApplyType(); + + String selectedFunction = dynamicFieldComboRuleAlgorithms.get(index); + String value1 = dynamicFieldOneRuleAlgorithms.get(index); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index); + decisionApply.setFunctionId(dropDownMap.get(selectedFunction)); + decisionApply.getExpression().add(new ObjectFactory().createApply(getInnerDecisionApply(value1))); + decisionApply.getExpression().add(new ObjectFactory().createApply(getInnerDecisionApply(value2))); + condition.setExpression(new ObjectFactory().createApply(decisionApply)); + isCompound = true; + } + + // if rule algorithm not a compound + if (!isCompound) { + condition.setExpression(new ObjectFactory().createApply(getInnerDecisionApply(dynamicLabelRuleAlgorithms.get(index)))); + } + } + if (!permitRule) { + ApplyType notOuterApply = new ApplyType(); + notOuterApply.setFunctionId(FUNCTION_NOT); + notOuterApply.getExpression().add(condition.getExpression()); + condition.setExpression(new ObjectFactory().createApply(notOuterApply)); + } + rule.setCondition(condition); + allOfInRule.getMatch().add(accessMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + + decisionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(decisionPolicy); + + } else { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Unsupported data object."+ policyAdapter.getData().getClass().getCanonicalName()); + } + + } + + private void createRainydayRule(PolicyType decisionPolicy, String errorcode, String treatment, boolean permitRule) { + RuleType rule = new RuleType(); + + rule.setRuleId(UUID.randomUUID().toString()); + + if (permitRule) { + rule.setEffect(EffectType.PERMIT); + } else { + rule.setEffect(EffectType.DENY); + } + rule.setTarget(new TargetType()); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for DECIDE in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("DECIDE"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "DecisionPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + + // Creating match for ErrorCode in rule target + MatchType errorcodeMatch = new MatchType(); + AttributeValueType errorcodeAttributeValue = new AttributeValueType(); + errorcodeAttributeValue.setDataType(STRING_DATATYPE); + errorcodeAttributeValue.getContent().add(errorcode); + errorcodeMatch.setAttributeValue(errorcodeAttributeValue); + AttributeDesignatorType errorcodeAttributeDesignator = new AttributeDesignatorType(); + errorcodeAttributeDesignator.setCategory(CATEGORY_RESOURCE); + errorcodeAttributeDesignator.setDataType(STRING_DATATYPE); + errorcodeAttributeDesignator.setAttributeId("ErrorCode"); + errorcodeMatch.setAttributeDesignator(errorcodeAttributeDesignator); + errorcodeMatch.setMatchId(FUNCTION_STRING_REGEXP_MATCH); + + allOfInRule.getMatch().add(errorcodeMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + + AdviceExpressionsType adviceExpressions = new AdviceExpressionsType(); + AdviceExpressionType adviceExpression = new AdviceExpressionType(); + adviceExpression.setAdviceId(RAINY_DAY); + adviceExpression.setAppliesTo(EffectType.PERMIT); + + AttributeAssignmentExpressionType assignment = new AttributeAssignmentExpressionType(); + assignment.setAttributeId("treatment"); + assignment.setCategory(CATEGORY_RESOURCE); + + AttributeValueType treatmentAttributeValue = new AttributeValueType(); + treatmentAttributeValue.setDataType(STRING_DATATYPE); + treatmentAttributeValue.getContent().add(treatment); + assignment.setExpression(new ObjectFactory().createAttributeValue(treatmentAttributeValue)); + + adviceExpression.getAttributeAssignmentExpression().add(assignment); + adviceExpressions.getAdviceExpression().add(adviceExpression); + rule.setAdviceExpressions(adviceExpressions); + decisionPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(decisionPolicy); + + } + + // if compound setting the inner apply here + protected ApplyType getInnerDecisionApply(String value1Label) { + ApplyType decisionApply = new ApplyType(); + int index = 0; + // check the index for the label. + for (String labelAttr : dynamicLabelRuleAlgorithms) { + if (labelAttr.equals(value1Label)) { + String value1 = dynamicFieldOneRuleAlgorithms.get(index); + populateDataTypeList(value1); + + // check if the row contains label again + for (String labelValue : dynamicLabelRuleAlgorithms) { + if (labelValue.equals(value1)) { + return getCompoundDecisionApply(index); + } + } + + // Getting the values from the form. + String functionKey = dynamicFieldComboRuleAlgorithms.get(index); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index); + decisionApply.setFunctionId(dropDownMap.get(functionKey)); + // if two text field are rule attributes. + if ((value1.contains(RULE_VARIABLE)) && (value2.contains(RULE_VARIABLE))) { + ApplyType innerDecisionApply1 = new ApplyType(); + ApplyType innerDecisionApply2 = new ApplyType(); + AttributeDesignatorType attributeDesignator1 = new AttributeDesignatorType(); + AttributeDesignatorType attributeDesignator2 = new AttributeDesignatorType(); + //If selected function is Integer function set integer functionID + if(functionKey.toLowerCase().contains("integer")){ + innerDecisionApply1.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY ); + innerDecisionApply2.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + attributeDesignator1.setDataType(INTEGER_DATATYPE); + attributeDesignator2.setDataType(INTEGER_DATATYPE); + } else{ + //If selected function is not a Integer function set String functionID + innerDecisionApply1.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + innerDecisionApply2.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + attributeDesignator1.setDataType(STRING_DATATYPE); + attributeDesignator2.setDataType(STRING_DATATYPE); + } + attributeDesignator1.setCategory(CATEGORY_RESOURCE); + attributeDesignator2.setCategory(CATEGORY_RESOURCE); + //Here set actual field values + attributeDesignator1.setAttributeId(value1. contains("resource:")?value1.substring( 9):value1.substring(8)); + attributeDesignator2.setAttributeId(value1. contains("resource:")?value1.substring( 9):value1.substring(8)); + innerDecisionApply1.getExpression().add(new ObjectFactory().createAttributeDesignator( attributeDesignator1)); + innerDecisionApply2.getExpression().add(new ObjectFactory().createAttributeDesignator( attributeDesignator2)); + decisionApply.getExpression().add(new ObjectFactory().createApply(innerDecisionApply1)); + decisionApply.getExpression().add(new ObjectFactory().createApply(innerDecisionApply2)); + } else { + // if either of one text field is rule attribute. + if (!value1.startsWith("S_")) { + ApplyType innerDecisionApply = new ApplyType(); + AttributeDesignatorType attributeDesignator = new AttributeDesignatorType(); + AttributeValueType decisionConditionAttributeValue = new AttributeValueType(); + + if (functionKey.toLowerCase().contains("integer")) { + innerDecisionApply.setFunctionId(FUNTION_INTEGER_ONE_AND_ONLY); + decisionConditionAttributeValue.setDataType(INTEGER_DATATYPE); + attributeDesignator.setDataType(INTEGER_DATATYPE); + } else { + innerDecisionApply.setFunctionId(FUNCTION_STRING_ONE_AND_ONLY); + decisionConditionAttributeValue.setDataType(STRING_DATATYPE); + attributeDesignator.setDataType(STRING_DATATYPE); + } + + String attributeId = null; + String attributeValue = null; + + // Find which textField has rule attribute and set it as + // attributeId and the other as attributeValue. + attributeId = value1; + attributeValue = value2; + + if (attributeId != null) { + attributeDesignator.setCategory(CATEGORY_RESOURCE); + attributeDesignator.setAttributeId(attributeId); + } + decisionConditionAttributeValue.getContent().add(attributeValue); + innerDecisionApply.getExpression().add(new ObjectFactory().createAttributeDesignator(attributeDesignator)); + decisionApply.getExpression().add(new ObjectFactory().createAttributeValue(decisionConditionAttributeValue)); + decisionApply.getExpression().add(new ObjectFactory().createApply(innerDecisionApply)); + } else { + value1 = value1.substring(2, value1.length()); + VariableReferenceType variableReferenceType = new VariableReferenceType(); + variableReferenceType.setVariableId(value1); + + String dataType = dataTypeList.get(index); + + AttributeValueType decisionConditionAttributeValue = new AttributeValueType(); + decisionConditionAttributeValue.setDataType(dataType); + decisionConditionAttributeValue.getContent().add(value2); + decisionApply.getExpression().add(new ObjectFactory().createVariableReference(variableReferenceType)); + decisionApply.getExpression().add(new ObjectFactory().createAttributeValue(decisionConditionAttributeValue)); + } + } + } + index++; + } + return decisionApply; + } + + // if the rule algorithm is multiple compound one setting the apply + protected ApplyType getCompoundDecisionApply(int index) { + ApplyType decisionApply = new ApplyType(); + String selectedFunction = dynamicFieldComboRuleAlgorithms.get(index); + String value1 = dynamicFieldOneRuleAlgorithms.get(index); + String value2 = dynamicFieldTwoRuleAlgorithms.get(index); + decisionApply.setFunctionId(dropDownMap.get(selectedFunction)); + decisionApply.getExpression().add(new ObjectFactory().createApply(getInnerDecisionApply(value1))); + decisionApply.getExpression().add(new ObjectFactory().createApply(getInnerDecisionApply(value2))); + return decisionApply; + } + + private VariableDefinitionType createDynamicVariable(String key, String value, String dataType) { + VariableDefinitionType dynamicVariable = new VariableDefinitionType(); + AttributeValueType dynamicAttributeValue = new AttributeValueType(); + + dynamicAttributeValue.setDataType(dataType); + dynamicAttributeValue.getContent().add(value); + + dynamicVariable.setVariableId(key); + dynamicVariable.setExpression(new ObjectFactory().createAttributeValue(dynamicAttributeValue)); + + return dynamicVariable; + + } + + private void populateDataTypeList(String value1) { + String dataType = null; + if(value1.contains("S_")) { + value1 = value1.substring(2, value1.length()); + DecisionSettings decisionSettings = findDecisionSettingsBySettingId(value1.substring(2, value1.length())); + if (decisionSettings != null && "string".equals(decisionSettings.getDatatypeBean().getShortName())) { + dataType = STRING_DATATYPE; + } else if (decisionSettings != null && "boolean".equals(decisionSettings.getDatatypeBean().getShortName())) { + dataType = BOOLEAN_DATATYPE; + } else { + dataType = INTEGER_DATATYPE; + } + } else { + dataType = "OTHER"; + } + + dataTypeList.add(dataType); + } + + private Map<String,String> createDropDownMap(){ + JPAUtils jpaUtils = null; + try { + jpaUtils = JPAUtils.getJPAUtilsInstance(XACMLPapServlet.getEmf()); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + Map<String, String> dropDownOptions = new HashMap<>(); + if(jpaUtils!=null){ + Map<Datatype, List<FunctionDefinition>> functionMap = jpaUtils.getFunctionDatatypeMap(); + for (Map.Entry<Datatype,List<FunctionDefinition>> map: functionMap.entrySet()) { + for (FunctionDefinition functionDef : map.getValue()) { + dropDownOptions.put(functionDef.getShortname(),functionDef.getXacmlid()); + } + } + } + return dropDownOptions; + } + + private String getDataType(String key) { + + DecisionSettings decisionSettings = findDecisionSettingsBySettingId(key); + String dataType = null; + + if (decisionSettings != null && "string".equals(decisionSettings.getDatatypeBean().getShortName())) { + dataType = STRING_DATATYPE; + } else if (decisionSettings != null && "boolean".equals(decisionSettings.getDatatypeBean().getShortName())) { + dataType = BOOLEAN_DATATYPE; + } else { + dataType = INTEGER_DATATYPE; + } + + return dataType; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getData(); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java new file mode 100644 index 000000000..0c8784c81 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/FirewallConfigPolicy.java @@ -0,0 +1,1305 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.StringReader; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.Charset; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.sql.SQLException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.json.Json; +import javax.json.JsonArray; +import javax.json.JsonObject; +import javax.json.JsonReader; +import javax.persistence.EntityManager; +import javax.persistence.Query; + +import org.apache.commons.io.FilenameUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.ActionList; +import org.onap.policy.rest.jpa.AddressGroup; +import org.onap.policy.rest.jpa.GroupServiceList; +import org.onap.policy.rest.jpa.PolicyEntity; +import org.onap.policy.rest.jpa.PortList; +import org.onap.policy.rest.jpa.PrefixList; +import org.onap.policy.rest.jpa.ProtocolList; +import org.onap.policy.rest.jpa.ServiceList; +import org.onap.policy.rest.jpa.TermList; +import org.onap.policy.rest.jpa.UserInfo; + +import com.att.research.xacml.std.IdentifierImpl; +import com.fasterxml.jackson.databind.JsonNode; +import com.github.fge.jackson.JsonLoader; +import com.github.fge.jsonpatch.diff.JsonDiff; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +public class FirewallConfigPolicy extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(FirewallConfigPolicy.class); + + public FirewallConfigPolicy() { + super(); + } + + public FirewallConfigPolicy(PolicyRestAdapter policyAdapter) { + this.policyAdapter = policyAdapter; + this.policyAdapter.setConfigType(policyAdapter.getConfigType()); + } + + // Saving the Configurations file at server location for config policy. + protected void saveConfigurations(String policyName, String jsonBody) { + String configurationName = policyName; + FileWriter fw = null; + try{ + if(configurationName.endsWith(".xml")){ + configurationName = configurationName.replace(".xml", ""); + } + fw = new FileWriter(CONFIG_HOME + File.separator + configurationName + ".json"); + BufferedWriter bw = new BufferedWriter(fw); + bw.write(jsonBody); + bw.close(); + if (LOGGER.isDebugEnabled()) { + LOGGER.debug("Configuration is succesfully saved"); + } + } catch (IOException e) { + LOGGER.error("Exception Occured"+e); + }finally{ + try{ + if(fw != null){ + fw.close(); + } + }catch(Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + } + + //Utility to read json data from the existing file to a string + static String readFile(String path, Charset encoding) throws IOException { + byte[] encoded = Files.readAllBytes(Paths.get(path)); + return new String(encoded, encoding); + } + + @Override + public Map<String, String> savePolicies() throws Exception { + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + if(!isPreparedToSave()){ + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + Boolean dbIsUpdated = false; + if (policyAdapter.getApiflag() != null && "admin".equalsIgnoreCase(policyAdapter.getApiflag())){ + if (policyAdapter.isEditPolicy()) { + dbIsUpdated = updateFirewallDictionaryData(policyAdapter.getJsonBody(), policyAdapter.getPrevJsonBody()); + } else { + dbIsUpdated = insertFirewallDicionaryData(policyAdapter.getJsonBody()); + } + } else { + dbIsUpdated = true; + } + + if(dbIsUpdated) { + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + } else { + PolicyLogger.error("Failed to Update the Database Dictionary Tables."); + + //remove the new json file + String jsonBody = policyAdapter.getPrevJsonBody(); + if (jsonBody!=null){ + saveConfigurations(policyName, jsonBody); + } else { + saveConfigurations(policyName, ""); + } + successMap.put("fwdberror", "DB UPDATE"); + } + + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshaling. + if ("Config".equals(policyAdapter.getPolicyType())) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + policyName = policyAdapter.getNewFileName(); + + //String oldPolicyName = policyName.replace(".xml", ""); + String scope = policyName.substring(0, policyName.indexOf('.')); + String dbPolicyName = policyName.substring(policyName.indexOf('.')+1).replace(".xml", ""); + + int oldversion = Integer.parseInt(dbPolicyName.substring(dbPolicyName.lastIndexOf('.')+1)); + dbPolicyName = dbPolicyName.substring(0, dbPolicyName.lastIndexOf('.')+1); + if(oldversion > 1){ + oldversion = oldversion - 1; + dbPolicyName = dbPolicyName + oldversion + ".xml"; + } + EntityManager em = XACMLPapServlet.getEmf().createEntityManager(); + Query createPolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName"); + createPolicyQuery.setParameter("scope", scope); + createPolicyQuery.setParameter("policyName", dbPolicyName); + List<?> createPolicyQueryList = createPolicyQuery.getResultList(); + if(!createPolicyQueryList.isEmpty()){ + PolicyEntity entitydata = (PolicyEntity) createPolicyQueryList.get(0); + policyAdapter.setPrevJsonBody(entitydata.getConfigurationData().getConfigBody()); + } + em.close(); + if (policyAdapter.getData() != null) { + String jsonBody = policyAdapter.getJsonBody(); + saveConfigurations(policyName, jsonBody); + + // Make sure the filename ends with an extension + if (!policyName.endsWith(".xml")) { + policyName = policyName + ".xml"; + } + + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf('\\') + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf('/') + 1, fileName.length()); + } + allOfOne.getMatch().add(createMatch("PolicyName", name)); + AllOfType allOf = new AllOfType(); + + // Match for ConfigName + allOf.getMatch().add(createMatch("ConfigName", policyAdapter.getConfigName())); + // Match for riskType + allOf.getMatch().add(createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add(createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add(createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add(createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + target.getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "FirewallConfigPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + + configAttributeValue.getContent().add("Config"); + + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try { + configURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "FirewallConfigPolicy", "Exception creating Config URI"); + } + + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl(configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, String fileName) { + + //Firewall Config ID Assignment + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("firewallConfigID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment1); + + // For Config file Url if configurations are provided. + //URL ID Assignment + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + if (policyName.endsWith(".xml")) { + policyName = policyName.substring(0, policyName.lastIndexOf(".xml")); + } + String content = CONFIG_URL + "/Config/" + policyName + ".json"; + + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory().createAttributeValue(AttributeValue)); + advice.getAttributeAssignmentExpression().add(assignment2); + + //Policy Name Assignment + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory().createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + //Version Number Assignment + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue4)); + advice.getAttributeAssignmentExpression().add(assignment4); + + //Onap Name Assignment + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + assignment5.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue5)); + advice.getAttributeAssignmentExpression().add(assignment5); + + //Config Name Assignment + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" + CONFIGID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getConfigName()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + advice.getAttributeAssignmentExpression().add(assignment6); + + //Risk Attributes + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId("RiskType"); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(policyAdapter.getRiskType()); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + + advice.getAttributeAssignmentExpression().add(assignment7); + + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("RiskLevel"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getRiskLevel()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("guard"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getGuard()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("TTLDate"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getTtlDate()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + advices.getAdviceExpression().add(advice); + return advices; + } + + + private Boolean insertFirewallDicionaryData (String jsonBody) throws SQLException { + CommonClassDaoImpl dbConnection = new CommonClassDaoImpl(); + JsonObject json = null; + if (jsonBody != null) { + + //Read jsonBody to JsonObject + json = stringToJson(jsonBody); + + JsonArray firewallRules = null; + JsonArray serviceGroup = null; + JsonArray addressGroup = null; + //insert data into tables + try { + firewallRules = json.getJsonArray("firewallRuleList"); + serviceGroup = json.getJsonArray("serviceGroups"); + addressGroup = json.getJsonArray("addressGroups"); + /* + * Inserting firewallRuleList data into the Terms, SecurityZone, and Action tables + */ + if (firewallRules != null) { + for(int i = 0;i<firewallRules.size();i++) { + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject ruleListobj = firewallRules.getJsonObject(i); + + //get values from JSON fields of firewallRulesList Array + String ruleName = ruleListobj.get("ruleName").toString(); + String action = ruleListobj.get("action").toString(); + String description = ruleListobj.get("description").toString(); + List<Object> result = dbConnection.getDataById(TermList.class, "termName", ruleName); + if(result != null && !result.isEmpty()){ + TermList termEntry = (TermList) result.get(0); + dbConnection.delete(termEntry); + } + + //getting fromZone Array field from the firewallRulesList + JsonArray fromZoneArray = ruleListobj.getJsonArray("fromZones"); + String fromZoneString = null; + + for (int fromZoneIndex = 0;fromZoneIndex<fromZoneArray.size(); fromZoneIndex++) { + String value = fromZoneArray.get(fromZoneIndex).toString(); + value = value.replace("\"", ""); + if (fromZoneString != null) { + fromZoneString = fromZoneString.concat(",").concat(value); + } else { + fromZoneString = value; + } + } + String fromZoneInsert = "'"+fromZoneString+"'"; + + //getting toZone Array field from the firewallRulesList + JsonArray toZoneArray = ruleListobj.getJsonArray("toZones"); + String toZoneString = null; + for (int toZoneIndex = 0; toZoneIndex<toZoneArray.size(); toZoneIndex++) { + String value = toZoneArray.get(toZoneIndex).toString(); + value = value.replace("\"", ""); + if (toZoneString != null) { + toZoneString = toZoneString.concat(",").concat(value); + } else { + toZoneString = value; + } + } + String toZoneInsert = "'"+toZoneString+"'"; + + //getting sourceList Array fields from the firewallRulesList + JsonArray srcListArray = ruleListobj.getJsonArray("sourceList"); + String srcListString = null; + for (int srcListIndex = 0; srcListIndex< srcListArray.size(); srcListIndex++) { + JsonObject srcListObj = srcListArray.getJsonObject(srcListIndex); + String type = srcListObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = srcListObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = srcListObj.get("value").toString(); + } + + if (value!=null){ + value = value.replace("\"", ""); + } + + if (srcListString != null) { + srcListString = srcListString.concat(",").concat(value); + + } else { + srcListString = value; + } + + } + String srcListInsert = "'"+srcListString+"'"; + + //getting destinationList Array fields from the firewallRulesList + JsonArray destListArray = ruleListobj.getJsonArray("destinationList"); + String destListString = null; + for (int destListIndex = 0; destListIndex <destListArray.size(); destListIndex++) { + JsonObject destListObj = destListArray.getJsonObject(destListIndex); + String type = destListObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = destListObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = destListObj.get("value").toString(); + } + + if (value!=null){ + value = value.replace("\"", ""); + } + + if (destListString != null) { + destListString = destListString.concat(",").concat(value); + } else { + destListString = value; + } + } + String destListInsert = "'"+destListString+"'"; + + //getting destServices Array fields from the firewallRulesList + JsonArray destServicesArray = ruleListobj.getJsonArray("destServices"); + String destPortListString = null; + for (int destPortListIndex = 0; destPortListIndex < destServicesArray.size(); destPortListIndex++) { + JsonObject destServicesObj = destServicesArray.getJsonObject(destPortListIndex); + String type = destServicesObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = destServicesObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = destServicesObj.get("value").toString(); + } + + if (value!=null){ + value = value.replace("\"", ""); + } + + if (destPortListString != null) { + destPortListString = destPortListString.concat(",").concat(value); + } else { + destPortListString = value; + } + } + String destPortListInsert = "'"+destPortListString+"'"; + + /* + * Create Queries to INSERT data into database tables and execute + */ + UserInfo userInfo = new UserInfo(); + userInfo.setUserLoginId("API"); + userInfo.setUserName("API"); + + TermList termEntry = new TermList(); + termEntry.setTermName(ruleName); + termEntry.setSrcIPList(srcListInsert); + termEntry.setDestIPList(destListInsert); + termEntry.setProtocolList("null"); + termEntry.setPortList("null"); + termEntry.setSrcPortList("null"); + termEntry.setDestPortList(destPortListInsert); + termEntry.setAction(action); + termEntry.setDescription(description); + termEntry.setFromZones(fromZoneInsert); + termEntry.setToZones(toZoneInsert); + termEntry.setUserCreatedBy(userInfo); + dbConnection.save(termEntry); + + ActionList actionEntry = new ActionList(); + actionEntry.setActionName(action); + actionEntry.setDescription(action); + dbConnection.save(actionEntry); + } + } + + /* + * Inserting serviceGroups data into the ServiceGroup, ServiceList, ProtocolList, and PortList tables + */ + if (serviceGroup != null) { + for(int i = 0; i < serviceGroup.size() ; i++) { + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject svcGroupListobj = serviceGroup.getJsonObject(i); + + String serviceListName = svcGroupListobj.get("name").toString(); + String description = null; + if (svcGroupListobj.containsKey("description")){ + description = svcGroupListobj.get("description").toString(); + } + + //getting members Array from the serviceGroup + JsonArray membersArray = svcGroupListobj.getJsonArray("members"); + + //String type = svcGroupListobj.get("type").toString(); + Boolean isServiceGroup = false; + if (membersArray!=null){ + String membersType = membersArray.getJsonObject(0).get("type").toString(); + if (membersType.contains("REFERENCE")) { + isServiceGroup = true; + } + } + + //Insert values into GROUPSERVICELIST table if name begins with Group + if (isServiceGroup) { + String name = null; + for (int membersIndex = 0; membersIndex< membersArray.size(); membersIndex++) { + JsonObject membersObj = membersArray.getJsonObject(membersIndex); + //String value = membersObj.get("name").toString(); + String type = membersObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")||type.equals("SERVICE")){ + value = membersObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = membersObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (name != null) { + name = name.concat(",").concat(value); + } else { + name = value; + } + } + String nameInsert = "'"+name+"'"; + GroupServiceList groupServiceEntry = new GroupServiceList(); + groupServiceEntry.setGroupName(serviceListName); + groupServiceEntry.setServiceList(nameInsert); + dbConnection.save(groupServiceEntry); + } else { //Insert JSON data serviceList table, protollist table, and portlist table + String type = svcGroupListobj.get("type").toString(); + String transportProtocol = svcGroupListobj.get("transportProtocol").toString(); + String ports = svcGroupListobj.get("ports").toString(); + + /* + * Create Queries to INSERT data into database table and execute + */ + ServiceList serviceListEntry = new ServiceList(); + serviceListEntry.setServiceName(serviceListName); + serviceListEntry.setServiceDescription(description); + serviceListEntry.setServiceType(type); + serviceListEntry.setServiceTransProtocol(transportProtocol); + serviceListEntry.setServiceAppProtocol("null"); + serviceListEntry.setServicePorts(ports); + dbConnection.save(serviceListEntry); + + ProtocolList protocolEntry = new ProtocolList(); + protocolEntry.setProtocolName(transportProtocol); + protocolEntry.setDescription(transportProtocol); + dbConnection.save(protocolEntry); + + PortList portListEntry = new PortList(); + portListEntry.setPortName(ports); + portListEntry.setDescription(ports); + dbConnection.save(portListEntry); + } + } + } + + /* + * Inserting addressGroup data into the ADDRESSGROUP table + */ + if (addressGroup != null) { + for(int i = 0; i < addressGroup.size(); i++) { + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject addressGroupObj = addressGroup.getJsonObject(i); + + //create JSON array for members + JsonArray membersArray = addressGroupObj.getJsonArray("members"); + String addressGroupName = addressGroupObj.get("name").toString(); + + String description = null; + if (addressGroupObj.containsKey("description")){ + description = addressGroupObj.get("description").toString(); + } + + String prefixIP = null; + String type = null; + for (int membersIndex = 0; membersIndex < membersArray.size(); membersIndex++) { + JsonObject membersObj = membersArray.getJsonObject(membersIndex); + //String value = membersObj.get("value").toString(); + type = membersObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")||type.equals("SERVICE")){ + value = membersObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = membersObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (prefixIP != null) { + prefixIP = prefixIP.concat(",").concat(value); + } else { + prefixIP = value; + } + } + String prefixList = "'"+prefixIP+"'"; + + Boolean isAddressGroup = type.contains("REFERENCE"); + + if (isAddressGroup) { + AddressGroup addressGroupEntry = new AddressGroup(); + addressGroupEntry.setGroupName(addressGroupName); + addressGroupEntry.setDescription(description); + addressGroupEntry.setServiceList(prefixList); + dbConnection.save(addressGroupEntry); + } else { + PrefixList prefixListEntry = new PrefixList(); + prefixListEntry.setPrefixListName(addressGroupName); + prefixListEntry.setDescription(description); + prefixListEntry.setPrefixListValue(prefixList); + dbConnection.save(prefixListEntry); + } + } + } + + /* + * Remove duplicate values from 'lookup' dictionary tables + */ + //ProtocolList Table + String protoDelete = "DELETE FROM protocollist USING protocollist, protocollist p1 " + + "WHERE protocollist.id > p1.id AND protocollist.protocolname = p1.protocolname;"; + dbConnection.updateQuery(protoDelete); + + //PortList Table + String portListDelete = "DELETE FROM portlist USING portlist, portlist p1 " + + "WHERE portlist.id > p1.id AND portlist.portname = p1.portname; "; + dbConnection.updateQuery(portListDelete); + + //PrefixList Table + String prefixListDelete = "DELETE FROM prefixlist USING prefixlist, prefixlist p1 " + + "WHERE prefixlist.id > p1.id AND prefixlist.pl_name = p1.pl_name AND " + + "prefixlist.pl_value = p1.pl_value AND prefixlist.description = p1.description; "; + dbConnection.updateQuery(prefixListDelete); + + //GroupServiceList + String groupServiceDelete = "DELETE FROM groupservicelist USING groupservicelist, groupservicelist g1 " + + "WHERE groupservicelist.id > g1.id AND groupservicelist.name = g1.name AND " + + "groupservicelist.serviceList = g1.serviceList; "; + dbConnection.updateQuery(groupServiceDelete); + }catch (Exception e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "FirewallConfigPolicy", "Exception getting Json values"); + return false; + } + return true; + + } else { + return false; + } + + } + + + private Boolean updateFirewallDictionaryData(String jsonBody, String prevJsonBody) { + CommonClassDaoImpl dbConnection = new CommonClassDaoImpl(); + JsonObject oldJson = null; + JsonObject newJson = null; + + if (jsonBody != null || prevJsonBody != null) { + + oldJson = stringToJson(prevJsonBody); + newJson = stringToJson(jsonBody); + + //if no changes to the json then return true + if (oldJson != null && oldJson.equals(newJson)) { + return true; + } + + JsonArray firewallRules = null; + JsonArray serviceGroup = null; + JsonArray addressGroup = null; + + firewallRules = newJson.getJsonArray("firewallRuleList"); + serviceGroup = newJson.getJsonArray("serviceGroups"); + addressGroup = newJson.getJsonArray("addressGroups"); + + //insert data into tables + try { + JsonNode jsonDiff = createPatch(jsonBody, prevJsonBody); + + for (int i = 0; i<jsonDiff.size(); i++) { + //String path = jsonDiff.get(i).asText(); + String jsonpatch = jsonDiff.get(i).toString(); + + JsonObject patchObj = stringToJson(jsonpatch); + + String path = patchObj.get("path").toString().replace('"', ' ').trim(); + + if (path.contains("firewallRuleList")) { + /* + * Inserting firewallRuleList data into the Terms, SecurityZone, and Action tables + */ + for(int ri = 0; ri < firewallRules.size(); ri++) { + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject ruleListobj = firewallRules.getJsonObject(ri); + + //get values from JSON fields of firewallRulesList Array + String ruleName = ruleListobj.get("ruleName").toString().replace('"', '\''); + String action = ruleListobj.get("action").toString().replace('"', '\''); + String description = ruleListobj.get("description").toString().replace('"', '\''); + + List<Object> result = dbConnection.getDataById(TermList.class, "termName", ruleName); + if(result != null && !result.isEmpty()){ + TermList termEntry = (TermList) result.get(0); + dbConnection.delete(termEntry); + } + + //getting fromZone Array field from the firewallRulesList + JsonArray fromZoneArray = ruleListobj.getJsonArray("fromZones"); + String fromZoneString = null; + + for (int fromZoneIndex = 0; fromZoneIndex<fromZoneArray.size() ; fromZoneIndex++) { + String value = fromZoneArray.get(fromZoneIndex).toString(); + value = value.replace("\"", ""); + + if (fromZoneString != null) { + fromZoneString = fromZoneString.concat(",").concat(value); + + } else { + fromZoneString = value; + } + + } + String fromZoneInsert = "'"+fromZoneString+"'"; + + //getting toZone Array field from the firewallRulesList + JsonArray toZoneArray = ruleListobj.getJsonArray("toZones"); + String toZoneString = null; + + + for (int toZoneIndex = 0; toZoneIndex < toZoneArray.size(); toZoneIndex++) { + String value = toZoneArray.get(toZoneIndex).toString(); + value = value.replace("\"", ""); + + if (toZoneString != null) { + toZoneString = toZoneString.concat(",").concat(value); + + } else { + toZoneString = value; + } + + } + String toZoneInsert = "'"+toZoneString+"'"; + //getting sourceList Array fields from the firewallRulesList + JsonArray srcListArray = ruleListobj.getJsonArray("sourceList"); + String srcListString = null; + for (int srcListIndex = 0; srcListIndex<srcListArray.size(); srcListIndex++) { + JsonObject srcListObj = srcListArray.getJsonObject(srcListIndex); + String type = srcListObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = srcListObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = srcListObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (srcListString != null) { + srcListString = srcListString.concat(",").concat(value); + + } else { + srcListString = value; + } + + } + String srcListInsert = "'"+srcListString+"'"; + + //getting destinationList Array fields from the firewallRulesList + JsonArray destListArray = ruleListobj.getJsonArray("destinationList"); + String destListString = null; + for (int destListIndex = 0; destListIndex<destListArray.size(); destListIndex ++) { + JsonObject destListObj = destListArray.getJsonObject(destListIndex); + String type = destListObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = destListObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = destListObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (destListString != null) { + destListString = destListString.concat(",").concat(value); + } else { + destListString = value; + } + } + String destListInsert = "'"+destListString+"'"; + + //getting destServices Array fields from the firewallRulesList + JsonArray destServicesArray = ruleListobj.getJsonArray("destServices"); + String destPortListString = null; + for (int destPortListIndex = 0; destPortListIndex < destServicesArray.size(); destPortListIndex++) { + JsonObject destServicesObj = destServicesArray.getJsonObject(destPortListIndex); + String type = destServicesObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")){ + value = destServicesObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = destServicesObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (destPortListString != null) { + destPortListString = destPortListString.concat(",").concat(value); + } else { + destPortListString = value; + } + } + String destPortListInsert = "'"+destPortListString+"'"; + + /* + * Create Queries to INSERT data into database tables and execute + */ + UserInfo userInfo = new UserInfo(); + userInfo.setUserLoginId("API"); + userInfo.setUserName("API"); + + TermList termEntry = new TermList(); + termEntry.setTermName(ruleName); + termEntry.setSrcIPList(srcListInsert); + termEntry.setDestIPList(destListInsert); + termEntry.setProtocolList("null"); + termEntry.setPortList("null"); + termEntry.setSrcPortList("null"); + termEntry.setDestPortList(destPortListInsert); + termEntry.setAction(action); + termEntry.setDescription(description); + termEntry.setFromZones(fromZoneInsert); + termEntry.setToZones(toZoneInsert); + termEntry.setUserCreatedBy(userInfo); + dbConnection.save(termEntry); + + List<Object> actionResult = dbConnection.getDataById(ActionList.class, "actionName", action); + if(actionResult == null || actionResult.isEmpty()){ + ActionList actionEntry = new ActionList(); + actionEntry.setActionName(action); + actionEntry.setDescription(action); + dbConnection.save(actionEntry); + } + } + } + + if (path.contains("serviceGroups")) { + /* + * Inserting serviceGroups data into the ServiceGroup, ServiceList, ProtocolList, and PortList tables + */ + for(int si = 0; si < serviceGroup.size(); si++) { + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject svcGroupListobj = serviceGroup.getJsonObject(si); + + String groupName = svcGroupListobj.get("name").toString().replace('"', '\''); + + String description = null; + if (svcGroupListobj.containsKey("description")){ + description = svcGroupListobj.get("description").toString().replace('"', '\''); + } + + JsonArray membersArray = svcGroupListobj.getJsonArray("members"); + + Boolean isServiceGroup = false; + if (membersArray!=null){ + String membersType = membersArray.getJsonObject(0).get("type").toString(); + if (membersType.contains("REFERENCE")) { + isServiceGroup = true; + } + } + + //Insert values into GROUPSERVICELIST table if name begins with Group + if (isServiceGroup) { + List<Object> result = dbConnection.getDataById(GroupServiceList.class, "name", groupName); + if(result != null && !result.isEmpty()){ + GroupServiceList groupEntry = (GroupServiceList) result.get(0); + dbConnection.delete(groupEntry); + } + + String name = null; + for (int membersIndex = 0; membersIndex < membersArray.size(); membersIndex++) { + JsonObject membersObj = membersArray.getJsonObject(membersIndex); + String type = membersObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")||type.equals("SERVICE")){ + value = membersObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = membersObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (name != null) { + name = name.concat(",").concat(value); + } else { + name = value; + } + } + String nameInsert = "'"+name+"'"; + GroupServiceList groupServiceEntry = new GroupServiceList(); + groupServiceEntry.setGroupName(groupName); + groupServiceEntry.setServiceList(nameInsert); + dbConnection.save(groupServiceEntry); + } else { //Insert JSON data serviceGroup table, protocollist table, and portlist table + String type = svcGroupListobj.get("type").toString().replace('"', '\''); + String transportProtocol = svcGroupListobj.get("transportProtocol").toString().replace('"', '\''); + String ports = svcGroupListobj.get("ports").toString().replace('"', '\''); + + List<Object> result = dbConnection.getDataById(ServiceList.class, "name", groupName); + if(result != null && !result.isEmpty()){ + ServiceList serviceEntry = (ServiceList) result.get(0); + dbConnection.delete(serviceEntry); + } + + ServiceList serviceListEntry = new ServiceList(); + serviceListEntry.setServiceName(groupName); + serviceListEntry.setServiceDescription(description); + serviceListEntry.setServiceType(type); + serviceListEntry.setServiceTransProtocol(transportProtocol); + serviceListEntry.setServiceAppProtocol("null"); + serviceListEntry.setServicePorts(ports); + dbConnection.save(serviceListEntry); + + List<Object> protocolResult = dbConnection.getDataById(ProtocolList.class, "protocolName", transportProtocol); + if(protocolResult == null || protocolResult.isEmpty()){ + ProtocolList protocolEntry = new ProtocolList(); + protocolEntry.setProtocolName(transportProtocol); + protocolEntry.setDescription(transportProtocol); + dbConnection.save(protocolEntry); + } + + List<Object> portResult = dbConnection.getDataById(PortList.class, "portName", ports); + if(portResult == null || portResult.isEmpty()){ + PortList portEntry = new PortList(); + portEntry.setPortName(ports); + portEntry.setDescription(ports); + dbConnection.save(portEntry); + } + } + } + } + + if (path.contains("addressGroups")) { + /* + * Inserting addressGroup data into the ADDRESSGROUP table + */ + for(int ai=0; ai < addressGroup.size() ; ai++) { + + /* + * Populate ArrayLists with values from the JSON + */ + //create the JSON object from the JSON Array for each iteration through the for loop + JsonObject addressGroupObj = addressGroup.getJsonObject(ai); + + //create JSON array for members + JsonArray membersArray = addressGroupObj.getJsonArray("members"); + String addressGroupName = addressGroupObj.get("name").toString().replace('"', '\''); + + String description = null; + if (addressGroupObj.containsKey("description")){ + description = addressGroupObj.get("description").toString().replace('"', '\''); + } + + String prefixIP = null; + String type = null; + for (int membersIndex=0; membersIndex < membersArray.size(); membersIndex++) { + JsonObject membersObj = membersArray.getJsonObject(membersIndex); + type = membersObj.get("type").toString().replace("\"", ""); + + String value = null; + if(type.equals("REFERENCE")||type.equals("GROUP")||type.equals("SERVICE")){ + value = membersObj.get("name").toString(); + } else if (type.equalsIgnoreCase("ANY")){ + value = null; + } else { + value = membersObj.get("value").toString(); + } + + if(value != null){ + value = value.replace("\"", ""); + } + + if (prefixIP != null) { + prefixIP = prefixIP.concat(",").concat(value); + } else { + prefixIP = value; + } + } + + String prefixList = "'"+prefixIP+"'"; + Boolean isAddressGroup = type.contains("REFERENCE"); + + if (isAddressGroup) { + List<Object> result = dbConnection.getDataById(AddressGroup.class, "name", addressGroupName); + if(result != null && !result.isEmpty()){ + AddressGroup addressGroupEntry = (AddressGroup) result.get(0); + dbConnection.delete(addressGroupEntry); + } + AddressGroup newAddressGroup = new AddressGroup(); + newAddressGroup.setGroupName(addressGroupName); + newAddressGroup.setDescription(description); + newAddressGroup.setServiceList(prefixList); + dbConnection.save(newAddressGroup); + } else { + List<Object> result = dbConnection.getDataById(PrefixList.class, "prefixListName", addressGroupName); + if(result != null && !result.isEmpty()){ + PrefixList prefixListEntry = (PrefixList) result.get(0); + dbConnection.delete(prefixListEntry); + } + PrefixList newPrefixList = new PrefixList(); + newPrefixList.setPrefixListName(addressGroupName); + newPrefixList.setDescription(description); + newPrefixList.setPrefixListValue(prefixList); + dbConnection.save(newPrefixList); + } + } + } + } + + /* + * Remove duplicate values from 'lookup' dictionary tables + */ + //ProtocolList Table + String protoDelete = "DELETE FROM protocollist USING protocollist, protocollist p1 " + + "WHERE protocollist.id > p1.id AND protocollist.protocolname = p1.protocolname;"; + dbConnection.updateQuery(protoDelete); + + //PortList Table + String portListDelete = "DELETE FROM portlist USING portlist, portlist p1 " + + "WHERE portlist.id > p1.id AND portlist.portname = p1.portname; "; + dbConnection.updateQuery(portListDelete); + + //PrefixList Table + String prefixListDelete = "DELETE FROM prefixlist USING prefixlist, prefixlist p1 " + + "WHERE prefixlist.id > p1.id AND prefixlist.pl_name = p1.pl_name AND " + + "prefixlist.pl_value = p1.pl_value AND prefixlist.description = p1.description; "; + dbConnection.updateQuery(prefixListDelete); + + //GroupServiceList + String groupServiceDelete = "DELETE FROM groupservicelist USING groupservicelist, groupservicelist g1 " + + "WHERE groupservicelist.id > g1.id AND groupservicelist.name = g1.name AND " + + "groupservicelist.serviceList = g1.serviceList; "; + dbConnection.updateQuery(groupServiceDelete); + }catch (Exception e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "FirewallConfigPolicy", "Exception executing Firewall queries"); + return false; + } + return true; + } else { + return false; + } + + } + + private JsonObject stringToJson(String jsonString) { + JsonObject json = null; + if (jsonString != null) { + //Read jsonBody to JsonObject + StringReader in = null; + in = new StringReader(jsonString); + + JsonReader jsonReader = Json.createReader(in); + json = jsonReader.readObject(); + jsonReader.close(); + } + return json; + } + + private JsonNode createPatch(String json, String oldJson) { + JsonNode oldJason = null; + JsonNode updatedJason = null; + + try { + oldJason = JsonLoader.fromString(oldJson); + updatedJason = JsonLoader.fromString(json); + } catch (IOException e) { + LOGGER.error("Exception Occured"+e); + } + return JsonDiff.asJson(oldJason, updatedJason); + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } + +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/MicroServiceConfigPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/MicroServiceConfigPolicy.java new file mode 100644 index 000000000..0297f30c0 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/MicroServiceConfigPolicy.java @@ -0,0 +1,555 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.File; +import java.io.PrintWriter; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import org.apache.commons.io.FilenameUtils; +import org.apache.commons.lang.StringUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.daoimpl.CommonClassDaoImpl; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.MicroServiceModels; + +import com.att.research.xacml.std.IdentifierImpl; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.base.Splitter; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AdviceExpressionsType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeAssignmentExpressionType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.EffectType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.ObjectFactory; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.RuleType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + +public class MicroServiceConfigPolicy extends Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(MicroServiceConfigPolicy.class); + + private static Map<String, String> mapAttribute = new HashMap<>(); + private static Map<String, String> matchMap = new HashMap<>(); + + public MicroServiceConfigPolicy() { + super(); + } + + public MicroServiceConfigPolicy(PolicyRestAdapter policyAdapter){ + this.policyAdapter = policyAdapter; + } + + //save configuration of the policy based on the policyname + private void saveConfigurations(String policyName, String jsonBody) { + try { + if(policyName.endsWith(".xml")){ + policyName = policyName.replace(".xml", ""); + } + PrintWriter out = new PrintWriter(CONFIG_HOME + File.separator + policyName +".json"); + out.println(jsonBody); + out.close(); + } catch (Exception e) { + LOGGER.error("Exception Occured While writing Configuration data"+e); + } + } + + + @Override + public Map<String, String> savePolicies() throws Exception { + + Map<String, String> successMap = new HashMap<>(); + if(isPolicyExists()){ + successMap.put("EXISTS", "This Policy already exist on the PAP"); + return successMap; + } + + if(!isPreparedToSave()){ + //Prep and configure the policy for saving + prepareToSave(); + } + + // Until here we prepared the data and here calling the method to create xml. + Path newPolicyPath = null; + newPolicyPath = Paths.get(policyAdapter.getNewFileName()); + + successMap = createPolicy(newPolicyPath,getCorrectPolicyDataObject()); + + return successMap; + } + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + @Override + public boolean prepareToSave() throws Exception{ + + if(isPreparedToSave()){ + //we have already done this + return true; + } + + int version = 0; + String policyID = policyAdapter.getPolicyID(); + version = policyAdapter.getHighestVersion(); + + // Create the Instance for pojo, PolicyType object is used in marshalling. + if (policyAdapter.getPolicyType().equals("Config")) { + PolicyType policyConfig = new PolicyType(); + + policyConfig.setVersion(Integer.toString(version)); + policyConfig.setPolicyId(policyID); + policyConfig.setTarget(new TargetType()); + policyAdapter.setData(policyConfig); + } + policyName = policyAdapter.getNewFileName(); + if (policyAdapter.getData() != null) { + // Save the Configurations file with the policy name with extention based on selection. + String jsonBody = policyAdapter.getJsonBody(); + saveConfigurations(policyName, jsonBody); + + // Make sure the filename ends with an extension + if (policyName.endsWith(".xml") == false) { + policyName = policyName + ".xml"; + } + + + PolicyType configPolicy = (PolicyType) policyAdapter.getData(); + + configPolicy.setDescription(policyAdapter.getPolicyDescription()); + + configPolicy.setRuleCombiningAlgId(policyAdapter.getRuleCombiningAlgId()); + + AllOfType allOfOne = new AllOfType(); + String fileName = policyAdapter.getNewFileName(); + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + + //setup values for pulling out matching attributes + ObjectMapper mapper = new ObjectMapper(); + JsonNode rootNode = mapper.readTree(policyAdapter.getJsonBody()); + String matching = null; + + if (policyAdapter.getTtlDate()==null){ + policyAdapter.setTtlDate("NA"); + } + if (policyAdapter.getServiceType().contains("-v")){ + matching = getValueFromDictionary(policyAdapter.getServiceType()); + } else { + String jsonVersion = StringUtils.replaceEach(rootNode.get("version").toString(), new String[]{"\""}, new String[]{""}); + matching = getValueFromDictionary(policyAdapter.getServiceType() + "-v" + jsonVersion); + } + + if (matching != null && !matching.isEmpty()){ + matchMap = Splitter.on(",").withKeyValueSeparator("=").split(matching); + if(policyAdapter.getJsonBody() != null){ + pullMatchValue(rootNode); + } + } + + // Match for policyName + allOfOne.getMatch().add(createMatch("PolicyName", name)); + + AllOfType allOf = new AllOfType(); + + // Adding the matches to AllOfType element Match for Onap + allOf.getMatch().add(createMatch("ONAPName", policyAdapter.getOnapName())); + if (matchMap==null || matchMap.isEmpty()){ + // Match for ConfigName + allOf.getMatch().add(createMatch("ConfigName", policyAdapter.getConfigName())); + // Match for Service + allOf.getMatch().add(createDynamicMatch("service", policyAdapter.getServiceType())); + // Match for uuid + allOf.getMatch().add(createDynamicMatch("uuid", policyAdapter.getUuid())); + // Match for location + allOf.getMatch().add(createDynamicMatch("location", policyAdapter.getLocation())); + }else { + for (Entry<String, String> matchValue : matchMap.entrySet()){ + String value = matchValue.getValue(); + String key = matchValue.getKey().trim(); + if (value.contains("matching-true")){ + if (mapAttribute.containsKey(key)){ + allOf.getMatch().add(createDynamicMatch(key, mapAttribute.get(key))); + } + } + } + } + // Match for riskType + allOf.getMatch().add( + createDynamicMatch("RiskType", policyAdapter.getRiskType())); + // Match for riskLevel + allOf.getMatch().add( + createDynamicMatch("RiskLevel", String.valueOf(policyAdapter.getRiskLevel()))); + // Match for riskguard + allOf.getMatch().add( + createDynamicMatch("guard", policyAdapter.getGuard())); + // Match for ttlDate + allOf.getMatch().add( + createDynamicMatch("TTLDate", policyAdapter.getTtlDate())); + + AnyOfType anyOf = new AnyOfType(); + anyOf.getAllOf().add(allOfOne); + anyOf.getAllOf().add(allOf); + + TargetType target = new TargetType(); + ((TargetType) target).getAnyOf().add(anyOf); + + // Adding the target to the policy element + configPolicy.setTarget((TargetType) target); + + RuleType rule = new RuleType(); + rule.setRuleId(policyAdapter.getRuleID()); + + rule.setEffect(EffectType.PERMIT); + + // Create Target in Rule + AllOfType allOfInRule = new AllOfType(); + + // Creating match for ACCESS in rule target + MatchType accessMatch = new MatchType(); + AttributeValueType accessAttributeValue = new AttributeValueType(); + accessAttributeValue.setDataType(STRING_DATATYPE); + accessAttributeValue.getContent().add("ACCESS"); + accessMatch.setAttributeValue(accessAttributeValue); + AttributeDesignatorType accessAttributeDesignator = new AttributeDesignatorType(); + URI accessURI = null; + try { + accessURI = new URI(ACTION_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "MicroServiceConfigPolicy", "Exception creating ACCESS URI"); + } + accessAttributeDesignator.setCategory(CATEGORY_ACTION); + accessAttributeDesignator.setDataType(STRING_DATATYPE); + accessAttributeDesignator.setAttributeId(new IdentifierImpl(accessURI).stringValue()); + accessMatch.setAttributeDesignator(accessAttributeDesignator); + accessMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + // Creating Config Match in rule Target + MatchType configMatch = new MatchType(); + AttributeValueType configAttributeValue = new AttributeValueType(); + configAttributeValue.setDataType(STRING_DATATYPE); + configAttributeValue.getContent().add("Config"); + configMatch.setAttributeValue(configAttributeValue); + AttributeDesignatorType configAttributeDesignator = new AttributeDesignatorType(); + URI configURI = null; + try { + configURI = new URI(RESOURCE_ID); + } catch (URISyntaxException e) { + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "MicroServiceConfigPolicy", "Exception creating Config URI"); + } + configAttributeDesignator.setCategory(CATEGORY_RESOURCE); + configAttributeDesignator.setDataType(STRING_DATATYPE); + configAttributeDesignator.setAttributeId(new IdentifierImpl(configURI).stringValue()); + configMatch.setAttributeDesignator(configAttributeDesignator); + configMatch.setMatchId(FUNCTION_STRING_EQUAL_IGNORE); + + allOfInRule.getMatch().add(accessMatch); + allOfInRule.getMatch().add(configMatch); + + AnyOfType anyOfInRule = new AnyOfType(); + anyOfInRule.getAllOf().add(allOfInRule); + + TargetType targetInRule = new TargetType(); + targetInRule.getAnyOf().add(anyOfInRule); + + rule.setTarget(targetInRule); + rule.setAdviceExpressions(getAdviceExpressions(version, policyName)); + + configPolicy.getCombinerParametersOrRuleCombinerParametersOrVariableDefinition().add(rule); + policyAdapter.setPolicyData(configPolicy); + + } else { + PolicyLogger.error("Unsupported data object." + policyAdapter.getData().getClass().getCanonicalName()); + } + setPreparedToSave(true); + return true; + } + + private void pullMatchValue(JsonNode rootNode) { + Iterator<Map.Entry<String, JsonNode>> fieldsIterator = rootNode.fields(); + String newValue = null; + while (fieldsIterator.hasNext()) { + Map.Entry<String, JsonNode> field = fieldsIterator.next(); + final String key = field.getKey(); + final JsonNode value = field.getValue(); + if (value.isContainerNode() && !value.isArray()) { + pullMatchValue(value); // RECURSIVE CALL + } else { + newValue = StringUtils.replaceEach(value.toString(), new String[]{"[", "]", "\""}, new String[]{"", "", ""}); + mapAttribute.put(key, newValue); + } + } + + } + + private String getValueFromDictionary(String service){ + String ruleTemplate=null; + String modelName = service.split("-v")[0]; + String modelVersion = service.split("-v")[1]; + + CommonClassDaoImpl dbConnection = new CommonClassDaoImpl(); + List<Object> result = dbConnection.getDataById(MicroServiceModels.class, "modelName:version", modelName+":"+modelVersion); + if(result != null && !result.isEmpty()){ + MicroServiceModels model = (MicroServiceModels) result.get(0); + ruleTemplate = model.getAnnotation(); + } + return ruleTemplate; + } + + // Data required for Advice part is setting here. + private AdviceExpressionsType getAdviceExpressions(int version, String fileName) { + AdviceExpressionsType advices = new AdviceExpressionsType(); + AdviceExpressionType advice = new AdviceExpressionType(); + advice.setAdviceId("MSID"); + advice.setAppliesTo(EffectType.PERMIT); + // For Configuration + AttributeAssignmentExpressionType assignment1 = new AttributeAssignmentExpressionType(); + assignment1.setAttributeId("type"); + assignment1.setCategory(CATEGORY_RESOURCE); + assignment1.setIssuer(""); + + AttributeValueType configNameAttributeValue = new AttributeValueType(); + configNameAttributeValue.setDataType(STRING_DATATYPE); + configNameAttributeValue.getContent().add("Configuration"); + assignment1.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment1); + // For Config file Url if configurations are provided. + AttributeAssignmentExpressionType assignment2 = new AttributeAssignmentExpressionType(); + assignment2.setAttributeId("URLID"); + assignment2.setCategory(CATEGORY_RESOURCE); + assignment2.setIssuer(""); + + AttributeValueType AttributeValue = new AttributeValueType(); + AttributeValue.setDataType(URI_DATATYPE); + String configName; + if(policyName.endsWith(".xml")){ + configName = policyName.replace(".xml", ""); + }else{ + configName = policyName; + } + String content = CONFIG_URL +"/Config/" + configName + ".json"; + AttributeValue.getContent().add(content); + assignment2.setExpression(new ObjectFactory().createAttributeValue(AttributeValue)); + + advice.getAttributeAssignmentExpression().add(assignment2); + AttributeAssignmentExpressionType assignment3 = new AttributeAssignmentExpressionType(); + assignment3.setAttributeId("PolicyName"); + assignment3.setCategory(CATEGORY_RESOURCE); + assignment3.setIssuer(""); + + AttributeValueType attributeValue3 = new AttributeValueType(); + attributeValue3.setDataType(STRING_DATATYPE); + fileName = FilenameUtils.removeExtension(fileName); + fileName = fileName + ".xml"; + String name = fileName.substring(fileName.lastIndexOf("\\") + 1, fileName.length()); + if ((name == null) || (name.equals(""))) { + name = fileName.substring(fileName.lastIndexOf("/") + 1, fileName.length()); + } + attributeValue3.getContent().add(name); + assignment3.setExpression(new ObjectFactory().createAttributeValue(attributeValue3)); + advice.getAttributeAssignmentExpression().add(assignment3); + + AttributeAssignmentExpressionType assignment4 = new AttributeAssignmentExpressionType(); + assignment4.setAttributeId("VersionNumber"); + assignment4.setCategory(CATEGORY_RESOURCE); + assignment4.setIssuer(""); + + AttributeValueType configNameAttributeValue4 = new AttributeValueType(); + configNameAttributeValue4.setDataType(STRING_DATATYPE); + configNameAttributeValue4.getContent().add(Integer.toString(version)); + assignment4.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue4)); + + advice.getAttributeAssignmentExpression().add(assignment4); + + AttributeAssignmentExpressionType assignment5 = new AttributeAssignmentExpressionType(); + assignment5.setAttributeId("matching:" + ONAPID); + assignment5.setCategory(CATEGORY_RESOURCE); + assignment5.setIssuer(""); + + AttributeValueType configNameAttributeValue5 = new AttributeValueType(); + configNameAttributeValue5.setDataType(STRING_DATATYPE); + configNameAttributeValue5.getContent().add(policyAdapter.getOnapName()); + assignment5.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue5)); + + advice.getAttributeAssignmentExpression().add(assignment5); + + AttributeAssignmentExpressionType assignment7 = new AttributeAssignmentExpressionType(); + assignment7.setAttributeId("matching:service"); + assignment7.setCategory(CATEGORY_RESOURCE); + assignment7.setIssuer(""); + + AttributeValueType configNameAttributeValue7 = new AttributeValueType(); + configNameAttributeValue7.setDataType(STRING_DATATYPE); + configNameAttributeValue7.getContent().add(policyAdapter.getServiceType()); + assignment7.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue7)); + + advice.getAttributeAssignmentExpression().add(assignment7); + + if (matchMap==null || matchMap.isEmpty()){ + AttributeAssignmentExpressionType assignment6 = new AttributeAssignmentExpressionType(); + assignment6.setAttributeId("matching:" + CONFIGID); + assignment6.setCategory(CATEGORY_RESOURCE); + assignment6.setIssuer(""); + + AttributeValueType configNameAttributeValue6 = new AttributeValueType(); + configNameAttributeValue6.setDataType(STRING_DATATYPE); + configNameAttributeValue6.getContent().add(policyAdapter.getConfigName()); + assignment6.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue6)); + + advice.getAttributeAssignmentExpression().add(assignment6); + + + AttributeAssignmentExpressionType assignment8 = new AttributeAssignmentExpressionType(); + assignment8.setAttributeId("matching:uuid"); + assignment8.setCategory(CATEGORY_RESOURCE); + assignment8.setIssuer(""); + + AttributeValueType configNameAttributeValue8 = new AttributeValueType(); + configNameAttributeValue8.setDataType(STRING_DATATYPE); + configNameAttributeValue8.getContent().add(policyAdapter.getUuid()); + assignment8.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue8)); + + advice.getAttributeAssignmentExpression().add(assignment8); + + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("matching:Location"); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(policyAdapter.getLocation()); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + } else { + for (Entry<String, String> matchValue : matchMap.entrySet()){ + String value = matchValue.getValue(); + String key = matchValue.getKey().trim(); + if (value.contains("matching-true")){ + if (mapAttribute.containsKey(key)){ + AttributeAssignmentExpressionType assignment9 = new AttributeAssignmentExpressionType(); + assignment9.setAttributeId("matching:" + key); + assignment9.setCategory(CATEGORY_RESOURCE); + assignment9.setIssuer(""); + + AttributeValueType configNameAttributeValue9 = new AttributeValueType(); + configNameAttributeValue9.setDataType(STRING_DATATYPE); + configNameAttributeValue9.getContent().add(mapAttribute.get(key)); + assignment9.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue9)); + + advice.getAttributeAssignmentExpression().add(assignment9); + + } + } + } + } + + AttributeAssignmentExpressionType assignment10 = new AttributeAssignmentExpressionType(); + assignment10.setAttributeId("Priority"); + assignment10.setCategory(CATEGORY_RESOURCE); + assignment10.setIssuer(""); + + AttributeValueType configNameAttributeValue10 = new AttributeValueType(); + configNameAttributeValue10.setDataType(STRING_DATATYPE); + configNameAttributeValue10.getContent().add(policyAdapter.getPriority()); + assignment10.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue10)); + + advice.getAttributeAssignmentExpression().add(assignment10); + + //Risk Attributes + AttributeAssignmentExpressionType assignment11 = new AttributeAssignmentExpressionType(); + assignment11.setAttributeId("RiskType"); + assignment11.setCategory(CATEGORY_RESOURCE); + assignment11.setIssuer(""); + + AttributeValueType configNameAttributeValue11 = new AttributeValueType(); + configNameAttributeValue11.setDataType(STRING_DATATYPE); + configNameAttributeValue11.getContent().add(policyAdapter.getRiskType()); + assignment11.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue11)); + + advice.getAttributeAssignmentExpression().add(assignment11); + + AttributeAssignmentExpressionType assignment12 = new AttributeAssignmentExpressionType(); + assignment12.setAttributeId("RiskLevel"); + assignment12.setCategory(CATEGORY_RESOURCE); + assignment12.setIssuer(""); + + AttributeValueType configNameAttributeValue12 = new AttributeValueType(); + configNameAttributeValue12.setDataType(STRING_DATATYPE); + configNameAttributeValue12.getContent().add(policyAdapter.getRiskLevel()); + assignment12.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue12)); + + advice.getAttributeAssignmentExpression().add(assignment12); + + AttributeAssignmentExpressionType assignment13 = new AttributeAssignmentExpressionType(); + assignment13.setAttributeId("guard"); + assignment13.setCategory(CATEGORY_RESOURCE); + assignment13.setIssuer(""); + + AttributeValueType configNameAttributeValue13 = new AttributeValueType(); + configNameAttributeValue13.setDataType(STRING_DATATYPE); + configNameAttributeValue13.getContent().add(policyAdapter.getGuard()); + assignment13.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue13)); + + advice.getAttributeAssignmentExpression().add(assignment13); + + AttributeAssignmentExpressionType assignment14 = new AttributeAssignmentExpressionType(); + assignment14.setAttributeId("TTLDate"); + assignment14.setCategory(CATEGORY_RESOURCE); + assignment14.setIssuer(""); + + AttributeValueType configNameAttributeValue14 = new AttributeValueType(); + configNameAttributeValue14.setDataType(STRING_DATATYPE); + configNameAttributeValue14.getContent().add(policyAdapter.getTtlDate()); + assignment14.setExpression(new ObjectFactory().createAttributeValue(configNameAttributeValue14)); + + advice.getAttributeAssignmentExpression().add(assignment14); + + advices.getAdviceExpression().add(advice); + return advices; + } + + @Override + public Object getCorrectPolicyDataObject() { + return policyAdapter.getPolicyData(); + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/Policy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/Policy.java new file mode 100644 index 000000000..6d0a0c79b --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/Policy.java @@ -0,0 +1,416 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.Map; + +import javax.json.Json; +import javax.json.JsonReader; + +import org.apache.commons.io.FilenameUtils; +import org.json.JSONObject; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.XACMLRestProperties; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.xacml.util.XACMLPolicyWriter; + +import com.att.research.xacml.std.IdentifierImpl; +import com.att.research.xacml.util.XACMLProperties; +import com.att.research.xacmlatt.pdp.policy.PolicyDef; +import com.att.research.xacmlatt.pdp.policy.dom.DOMPolicyDef; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; + +public abstract class Policy { + + private static final Logger LOGGER = FlexLogger.getLogger(Policy.class); + + + /** + * Common Fields + */ + public static final String GET_INT_TYPE = "Integer"; + public static final String GET_STRING_TYPE = "String"; + + public static final String ONAPID = "ONAPName"; + public static final String CONFIGID = "ConfigName"; + public static final String CLOSEDLOOPID = "ServiceType"; + + public static final String CONFIG_POLICY = "Config"; + public static final String ACTION_POLICY = "Action"; + public static final String DECISION_POLICY = "Decision"; + + protected String policyName = null; + + protected boolean isValidForm = true; + + private Path finalPolicyPath = null; + + private boolean preparedToSave = false; + + private boolean policyExists = false; + + public Path getFinalPolicyPath() { + return finalPolicyPath; + } + + public void setFinalPolicyPath(Path finalPolicyPath) { + this.finalPolicyPath = finalPolicyPath; + } + + // Constants Used in XML Creation + public static final String CATEGORY_RECIPIENT_SUBJECT = "urn:oasis:names:tc:xacml:1.0:subject-category:recipient-subject"; + public static final String CATEGORY_RESOURCE = "urn:oasis:names:tc:xacml:3.0:attribute-category:resource"; + public static final String CATEGORY_ACTION = "urn:oasis:names:tc:xacml:3.0:attribute-category:action"; + public static final String CATEGORY_ACCESS_SUBJECT = "urn:oasis:names:tc:xacml:1.0:subject-category:access-subject"; + public static final String ACTION_ID = "urn:oasis:names:tc:xacml:1.0:action:action-id"; + public static final String SUBJECT_ID = "urn:oasis:names:tc:xacml:1.0:subject:subject-id"; + public static final String RESOURCE_ID = "urn:oasis:names:tc:xacml:1.0:resource:resource-id"; + public static final String FUNTION_INTEGER_ONE_AND_ONLY = "urn:oasis:names:tc:xacml:1.0:function:integer-one-and-only"; + public static final String FUNCTION_STRING_ONE_AND_ONLY = "urn:oasis:names:tc:xacml:1.0:function:string-one-and-only"; + public static final String FUNCTION_BOOLEAN_ONE_AND_ONLY = "urn:oasis:names:tc:xacml:1.0:function:boolean-one-and-only"; + public static final String FUNCTION_STRING_EQUAL = "urn:oasis:names:tc:xacml:1.0:function:string-equal"; + public static final String FUNCTION_STRING_REGEX_MATCH = "org.onap.function.regex-match"; + public static final String FUNCTION_STRING_REGEXP_MATCH = "urn:oasis:names:tc:xacml:1.0:function:string-regexp-match"; + public static final String FUNCTION_STRING_EQUAL_IGNORE = "urn:oasis:names:tc:xacml:3.0:function:string-equal-ignore-case"; + public static final String INTEGER_DATATYPE = "http://www.w3.org/2001/XMLSchema#integer"; + public static final String BOOLEAN_DATATYPE = "http://www.w3.org/2001/XMLSchema#boolean"; + public static final String STRING_DATATYPE = "http://www.w3.org/2001/XMLSchema#string"; + public static final String URI_DATATYPE = "http://www.w3.org/2001/XMLSchema#anyURI"; + public static final String RULE_VARIABLE = "var:"; + public static final String EMPTY_STRING = ""; + private static final String String = null; + + public static String CONFIG_HOME = null; + public static String ACTION_HOME = null; + public static String CONFIG_URL = null; + + protected Map<String, String> performer = new HashMap<>(); + + private static String actionHome = null; + private static String configHome = null; + + public PolicyRestAdapter policyAdapter = null; + String ruleID = ""; + + public Policy() { + CONFIG_HOME = getConfigHome(); + ACTION_HOME = getActionHome(); + CONFIG_URL = "$URL"; + performer.put("PDP", "PDPAction"); + performer.put("PEP", "PEPAction"); + } + + //Each policy type seems to either use policyData or data field policy adapter when + //getting the xml to save the policy. Instead of keep this hardcoded in the save method, + //this method makes it usable outside. + /** + * Return the data field of the PolicyAdapter that will be used when saving this policy + * with the savePolicies method. + * @return Either the PolicyAdapter.getData() or PolicyAdapter.getPolicyData() + */ + public abstract Object getCorrectPolicyDataObject(); + public abstract Map<String, String> savePolicies() throws Exception; + + //This is the method for preparing the policy for saving. We have broken it out + //separately because the fully configured policy is used for multiple things + public abstract boolean prepareToSave() throws Exception; + + + // create match for onap and config name + protected MatchType createMatch(String key, String value) { + MatchType match = new MatchType(); + + AttributeValueType attributeValue = new AttributeValueType(); + attributeValue.setDataType(STRING_DATATYPE); + attributeValue.getContent().add(value); + match.setAttributeValue(attributeValue); + AttributeDesignatorType attributeDesignator = new AttributeDesignatorType(); + URI uri = null; + try { + uri = new URI(key); + } catch (URISyntaxException e) { + LOGGER.error("Exception Occured"+e); + } + attributeDesignator.setCategory(CATEGORY_ACCESS_SUBJECT); + attributeDesignator.setDataType(STRING_DATATYPE); + attributeDesignator.setAttributeId(new IdentifierImpl(uri).stringValue()); + match.setAttributeDesignator(attributeDesignator); + match.setMatchId(FUNCTION_STRING_REGEX_MATCH); + return match; + } + + // Creating the match for dynamically added components. + protected MatchType createDynamicMatch(String key, String value) { + MatchType dynamicMatch = new MatchType(); + AttributeValueType dynamicAttributeValue = new AttributeValueType(); + String dataType = null; + dataType = STRING_DATATYPE; + dynamicAttributeValue.setDataType(dataType); + dynamicAttributeValue.getContent().add(value); + dynamicMatch.setAttributeValue(dynamicAttributeValue); + + AttributeDesignatorType dynamicAttributeDesignator = new AttributeDesignatorType(); + + URI dynamicURI = null; + try { + dynamicURI = new URI(key); + } catch (URISyntaxException e) { + LOGGER.error("Exception Occured"+e);// log msg + } + dynamicAttributeDesignator.setCategory(CATEGORY_RESOURCE); + dynamicAttributeDesignator.setDataType(dataType); + dynamicAttributeDesignator.setAttributeId(new IdentifierImpl(dynamicURI).stringValue()); + dynamicMatch.setAttributeDesignator(dynamicAttributeDesignator); + dynamicMatch.setMatchId(FUNCTION_STRING_REGEX_MATCH); + + return dynamicMatch; + } + + //validation for numeric + protected boolean isNumeric(String str){ + for (char c : str.toCharArray()){ + if (!Character.isDigit(c)) return false; + } + return true; + } + + // Validation for json. + protected static boolean isJSONValid(String data) { + JsonReader jsonReader = null; + try { + new JSONObject(data); + InputStream stream = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8)); + jsonReader = Json.createReader(stream); + LOGGER.info("Json Value is: " + jsonReader.read().toString() ); + } catch (Exception e) { + LOGGER.error("Exception Occured while reading json"+e); + return false; + }finally{ + if(jsonReader != null){ + jsonReader.close(); + } + } + return true; + } + + // the Policy Name as Unique One throws error + @SuppressWarnings("static-access") + protected Path getNextFilename(Path parent, String policyType, String polcyFileName, Integer version) { + policyType = FilenameUtils.removeExtension(policyType); + polcyFileName = FilenameUtils.removeExtension(polcyFileName); + Path newFile = null; + String policyDir = EMPTY_STRING; + String absolutePath = parent.toString(); + if (absolutePath != null && !absolutePath.equals(EMPTY_STRING)) { + policyDir = absolutePath.substring(absolutePath.lastIndexOf("\\") + 1, absolutePath.length()); + if (policyDir == null || policyDir.equals(EMPTY_STRING)) { + policyDir = absolutePath.substring(absolutePath.lastIndexOf("/") + 1, absolutePath.length()); + } + } + + String fileName = "default"; + if (policyDir != null && !policyDir.equals(EMPTY_STRING)) { + fileName = policyType + "_" + String.format(polcyFileName) + "." + version + ".xml"; + } + if (fileName != null) { + newFile = Paths.get(parent.toString(), fileName); + } + if (Files.notExists(newFile)) { + return newFile; + } + return null; + } + + protected Path getNextLoopFilename(Path parentPath, String policyType, String policyConfigType, String policyFileName, Integer version) { + policyType = FilenameUtils.removeExtension(policyType); + policyConfigType = FilenameUtils.removeExtension(policyConfigType); + policyFileName = FilenameUtils.removeExtension(policyFileName); + Path newFile = null; + String policyDir = EMPTY_STRING; + String absolutePath = parentPath.toString(); + if (absolutePath != null && !absolutePath.equals(EMPTY_STRING)) { + policyDir = absolutePath.substring(absolutePath.lastIndexOf("\\") + 1, absolutePath.length()); + if (policyDir == null || policyDir.equals(EMPTY_STRING)) { + policyDir = absolutePath.substring(absolutePath.lastIndexOf("/") + 1, absolutePath.length()); + } + } + + String fileName = "default"; + if (policyDir != null && !policyDir.equals(EMPTY_STRING)) { + if(policyConfigType.equals("ClosedLoop_PM")){ + fileName = policyType + "_" + "PM" + "_" +java.lang.String.format(policyFileName) + "." +version +".xml"; + }else if(policyConfigType.equals("ClosedLoop_Fault")){ + fileName = policyType + "_" + "Fault" + "_" +java.lang.String.format(policyFileName) + "." + version + ".xml"; + }else if(policyConfigType.equals("ClosedLoop_Fault")){ + fileName = policyType + "_" + "Fault" + "_" +java.lang.String.format(policyFileName) + "." + version + ".xml"; + }else if(policyConfigType.equals("Micro Service")){ + fileName = policyType + "_" + "MS" + "_" + java.lang.String.format(policyFileName) + "." + version + ".xml"; + } + } + if (fileName != null) { + newFile = Paths.get(parentPath.toString(), fileName); + } + if (Files.notExists(newFile)) { + return newFile; + } + return null; + } + + + //create policy once all the validations are completed + protected Map<String, String> createPolicy(final Path policyPath, final Object policyData) { + Map<String, String> success = new HashMap<>(); + // + // Is the root a PolicySet or Policy? + // + + if (policyData instanceof PolicyType) { + // + // Write it out + // + //Does not need to be XACMLPolicyWriterWithPapNotify since it is already in the PAP + //and this transaction is intercepted up stream. + InputStream inputStream = null; + try { + inputStream = XACMLPolicyWriter.getXmlAsInputStream((PolicyType) policyData); + PolicyDef policyDef = DOMPolicyDef.load(inputStream); + if (policyDef == null) { + success.put("validation", "PolicyDef Validation Failed"); + }else{ + success.put("success", "success"); + } + } catch (Exception e) { + LOGGER.error("PolicyDef Validation failed"+e); + success.put("error", "Validation Failed"); + }finally{ + try { + if(inputStream != null) + inputStream.close(); + } catch (IOException e) { + LOGGER.error("Exception Occured while closing the input stream"+e); + } + } + } else { + PolicyLogger.error("Unknown data type sent back."); + return success; + } + return success; + } + + public static String getConfigHome(){ + try { + loadWebapps(); + } catch (Exception e) { + return null; + } + return configHome; + } + + public static String getActionHome(){ + try { + loadWebapps(); + } catch (Exception e) { + return null; + } + return actionHome; + } + + private static void loadWebapps() throws Exception{ + if(actionHome == null || configHome == null){ + Path webappsPath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS)); + //Sanity Check + if (webappsPath == null) { + PolicyLogger.error("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS); + throw new Exception("Invalid Webapps Path Location property : " + XACMLRestProperties.PROP_PAP_WEBAPPS); + } + Path webappsPathConfig; + Path webappsPathAction; + if(webappsPath.toString().contains("\\")){ + webappsPathConfig = Paths.get(webappsPath.toString()+"\\Config"); + webappsPathAction = Paths.get(webappsPath.toString()+"\\Action"); + }else{ + webappsPathConfig = Paths.get(webappsPath.toString()+"/Config"); + webappsPathAction = Paths.get(webappsPath.toString()+"/Action"); + } + if(Files.notExists(webappsPathConfig)){ + try { + Files.createDirectories(webappsPathConfig); + } catch (IOException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "Policy", "Failed to create config directory"); + } + } + if(Files.notExists(webappsPathAction)){ + try { + Files.createDirectories(webappsPathAction); + } catch (IOException e) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "Policy", "Failed to create config directory"); + } + } + actionHome = webappsPathAction.toString(); + configHome = webappsPathConfig.toString(); + } + } + + public boolean validateConfigForm() { + return true; + } + + /** + * @return the preparedToSave + */ + public boolean isPreparedToSave() { + return preparedToSave; + } + + /** + * @param preparedToSave the preparedToSave to set + */ + protected void setPreparedToSave(boolean preparedToSave) { + this.preparedToSave = preparedToSave; + } + + public boolean isPolicyExists() { + return policyExists; + } + + public void setPolicyExists(boolean policyExists) { + this.policyExists = policyExists; + } + + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java new file mode 100644 index 000000000..98c8137de --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDao.java @@ -0,0 +1,2798 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileWriter; +import java.io.IOException; +import java.io.InputStream; +import java.io.StringReader; +import java.net.HttpURLConnection; +import java.net.MalformedURLException; +import java.net.ProtocolException; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.InvalidPathException; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.security.Key; +import java.util.Base64; +import java.util.Date; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.LockModeType; +import javax.persistence.PersistenceException; +import javax.persistence.Query; +import javax.persistence.RollbackException; +import javax.xml.parsers.DocumentBuilder; +import javax.xml.parsers.DocumentBuilderFactory; +import javax.xml.xpath.XPath; +import javax.xml.xpath.XPathFactory; + +import org.apache.commons.io.FilenameUtils; +import org.apache.commons.io.IOUtils; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.rest.XACMLRestProperties; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.ActionBodyEntity; +import org.onap.policy.rest.jpa.ConfigurationDataEntity; +import org.onap.policy.rest.jpa.DatabaseLockEntity; +import org.onap.policy.rest.jpa.GroupEntity; +import org.onap.policy.rest.jpa.PdpEntity; +import org.onap.policy.rest.jpa.PolicyDBDaoEntity; +import org.onap.policy.rest.jpa.PolicyEntity; +import org.onap.policy.rest.util.Webapps; +import org.onap.policy.xacml.api.pap.OnapPDP; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; +import org.onap.policy.xacml.api.pap.PAPPolicyEngine; +import org.onap.policy.xacml.std.pap.StdPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; +import org.onap.policy.xacml.util.XACMLPolicyWriter; +import org.w3c.dom.Document; +import org.xml.sax.InputSource; + +import com.att.research.xacml.api.pap.PAPException; +import com.att.research.xacml.api.pap.PDP; +import com.att.research.xacml.api.pap.PDPPolicy; +import com.att.research.xacml.util.XACMLProperties; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; + +public class PolicyDBDao { + private static final Logger logger = FlexLogger.getLogger(PolicyDBDao.class); + private List<?> otherServers; + private EntityManagerFactory emf; + private static PolicyDBDao currentInstance = null; + private PAPPolicyEngine papEngine; + + public static final String JSON_CONFIG = "JSON"; + public static final String XML_CONFIG = "XML"; + public static final String PROPERTIES_CONFIG = "PROPERTIES"; + public static final String OTHER_CONFIG = "OTHER"; + public static final String AUDIT_USER = "audit"; + + /** + * Get an instance of a PolicyDBDao. It creates one if it does not exist. + * Only one instance is allowed to be created per server. + * @param emf The EntityFactoryManager to be used for database connections + * @return The new instance of PolicyDBDao or throw exception if the given emf is null. + * @throws IllegalStateException if a PolicyDBDao has already been constructed. Call getPolicyDBDaoInstance() to get this. + */ + public static PolicyDBDao getPolicyDBDaoInstance(EntityManagerFactory emf) throws Exception{ + logger.debug("getPolicyDBDaoInstance(EntityManagerFactory emf) as getPolicyDBDaoInstance("+emf+") called"); + if(currentInstance == null){ + if(emf != null){ + currentInstance = new PolicyDBDao(emf); + return currentInstance; + } + throw new IllegalStateException("The EntityManagerFactory is Null"); + } + return currentInstance; + } + + /** + * Gets the current instance of PolicyDBDao. + * @return The instance of PolicyDBDao or throws exception if the given instance is null. + * @throws IllegalStateException if a PolicyDBDao instance is null. Call createPolicyDBDaoInstance(EntityManagerFactory emf) to get this. + */ + public static PolicyDBDao getPolicyDBDaoInstance() throws Exception{ + logger.debug("getPolicyDBDaoInstance() as getPolicyDBDaoInstance() called"); + if(currentInstance != null){ + return currentInstance; + } + throw new IllegalStateException("The PolicyDBDao.currentInstance is Null. Use getPolicyDBDao(EntityManagerFactory emf)"); + } + public void setPapEngine(PAPPolicyEngine papEngine2){ + this.papEngine = (PAPPolicyEngine) papEngine2; + } + private PolicyDBDao(EntityManagerFactory emf){ + logger.debug("PolicyDBDao(EntityManagerFactory emf) as PolicyDBDao("+emf+") called"); + this.emf = emf; + + //not needed in this release + if(!register()){ + PolicyLogger.error("This server's PolicyDBDao instance could not be registered and may not reveive updates"); + } + + otherServers = getRemotePolicyDBDaoList(); + if(logger.isDebugEnabled()){ + logger.debug("Number of remote PolicyDBDao instances: "+otherServers.size()); + } + if(otherServers.isEmpty()){ + logger.warn("List of PolicyDBDao servers is empty or could not be retrieved"); + } + } + + //not static because we are going to be using the instance's emf + //waitTime in ms to wait for lock, or -1 to wait forever (no) + private void startTransactionSynced(EntityManager entityMgr,int waitTime){ + logger.debug("\n\nstartTransactionSynced(EntityManager entityMgr,int waitTime) as " + + "\n startTransactionSynced("+entityMgr+","+waitTime+") called\n\n"); + DatabaseLockEntity lock = null; + + entityMgr.setProperty("javax.persistence.query.timeout", waitTime); + entityMgr.getTransaction().begin(); + + if(logger.isDebugEnabled()){ + Map<String,Object> properties = entityMgr.getProperties(); + logger.debug("\n\nstartTransactionSynced():" + + "\n entityManager.getProperties() = " + properties + + "\n\n"); + } + try{ + if(logger.isDebugEnabled()){ + logger.debug("\n\nstartTransactionSynced():" + + "\n ATTEMPT to get the DB lock" + + "\n\n"); + } + lock = entityMgr.find(DatabaseLockEntity.class, 1, LockModeType.PESSIMISTIC_WRITE); + if(logger.isDebugEnabled()){ + logger.debug("\n\nstartTransactionSynced():" + + "\n GOT the DB lock" + + "\n\n"); + } + } catch(Exception e){ + System.out.println("Could not get lock entity"); + logger.error("Exception Occured"+e); + } + if(lock == null){ + throw new IllegalStateException("The lock row does not exist in the table. Please create a primary key with value = 1."); + } + + } + /** + * Gets the list of other registered PolicyDBDaos from the database + * @return List (type PolicyDBDaoEntity) of other PolicyDBDaos + */ + private List<?> getRemotePolicyDBDaoList(){ + logger.debug("getRemotePolicyDBDaoList() as getRemotePolicyDBDaoList() called"); + List<?> policyDBDaoEntityList = new LinkedList<>(); + EntityManager em = emf.createEntityManager(); + startTransactionSynced(em, 1000); + try{ + Query getPolicyDBDaoEntityQuery = em.createNamedQuery("PolicyDBDaoEntity.findAll"); + policyDBDaoEntityList = getPolicyDBDaoEntityQuery.getResultList(); + + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Exception querying for other registered PolicyDBDaos"); + logger.warn("List of remote PolicyDBDaos will be empty"); + } + try{ + em.getTransaction().commit(); + } catch(Exception e){ + try{ + em.getTransaction().rollback(); + } catch(Exception e2){ + + } + } + em.close(); + return policyDBDaoEntityList; + } + + public PolicyDBDaoTransaction getNewTransaction(){ + logger.debug("getNewTransaction() as getNewTransaction() called"); + return (PolicyDBDaoTransaction)(new PolicyDBDaoTransactionInstance()); + } + + /* + * Because the normal transactions are not used in audits, we can use the same transaction + * mechanism to get a transaction and obtain the emlock and the DB lock. We just need to + * provide different transaction timeout values in ms because the audit will run longer + * than normal transactions. + */ + public PolicyDBDaoTransaction getNewAuditTransaction(){ + logger.debug("getNewAuditTransaction() as getNewAuditTransaction() called"); + //Use the standard transaction wait time in ms + int auditWaitMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT)); + //Use the (extended) audit timeout time in ms + int auditTimeoutMs = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_AUDIT_TIMEOUT)); + return (PolicyDBDaoTransaction)(new PolicyDBDaoTransactionInstance(auditTimeoutMs, auditWaitMs)); + } + + + /** + * Checks if two strings are equal. Null strings ARE allowed. + * @param one A String or null to compare + * @param two A String or null to compare + */ + private static boolean stringEquals(String one, String two){ + logger.debug("stringEquals(String one, String two) as stringEquals("+one+", "+two+") called"); + if(one == null && two == null){ + return true; + } + if(one == null || two == null){ + return false; + } + return one.equals(two); + } + + /** + * Computes the scope in dotted format based on an absolute path and a path that divides the scope. + * @param fullPath An absolute path including scope folders and other folders(does not have to be absolute, must just contain scope and other folders before) + * @param pathToExclude The path that acts as a division between the scope and the other folders + * @return The scope in dotted format (org.onap) + */ + private static String computeScope(String fullPath, String pathToExclude){ + logger.debug("computeScope(String fullPath, String pathToExclude) as computeScope("+fullPath+", "+pathToExclude+") called"); + int excludeIndex = fullPath.indexOf(pathToExclude); + String scopePath = fullPath.substring(excludeIndex+pathToExclude.length()); + String scope = scopePath.replace('\\', '.'); + scope = scope.replace('/', '.'); + if(scope.charAt(0) == '.'){ + scope = scope.substring(1); + } + if(scope.charAt(scope.length()-1) == '.'){ + scope = scope.substring(0, scope.length()-1); + } + return scope; + } + + /** + * Returns the url of this local pap server, removing the username and password, if they are present + * @return The url of this local pap server + */ + private String[] getPapUrlUserPass(){ + logger.debug("getPapUrl() as getPapUrl() called"); + String url = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_URL); + if(url == null){ + return null; + } + return splitPapUrlUserPass(url); + + + } + private String[] splitPapUrlUserPass(String url){ + String[] urlUserPass = new String[3]; + String[] commaSplit = url.split(","); + urlUserPass[0] = commaSplit[0]; + if(commaSplit.length > 2){ + urlUserPass[1] = commaSplit[1]; + urlUserPass[2] = commaSplit[2]; + } + if(urlUserPass[1] == null || urlUserPass[1].equals("")){ + String usernamePropertyValue = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID); + if(usernamePropertyValue != null){ + urlUserPass[1] = usernamePropertyValue; + } + } + if(urlUserPass[2] == null || urlUserPass[2].equals("")){ + String passwordPropertyValue = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS); + if(passwordPropertyValue != null){ + urlUserPass[2] = passwordPropertyValue; + } + } + //if there is no comma, for some reason there is no username and password, so don't try to cut them off + return urlUserPass; + } + + private static String encryptPassword(String password) throws Exception{ + Cipher cipher = Cipher.getInstance("AES"); + cipher.init(Cipher.ENCRYPT_MODE, aesKey()); + byte[] encryption = cipher.doFinal(password.getBytes("UTF-8")); + System.out.println(encryption); + return new String(Base64.getMimeEncoder().encode(encryption),"UTF-8"); + } + + private static String decryptPassword(String encryptedPassword) throws Exception{ + Cipher cipher = Cipher.getInstance("AES"); + cipher.init(Cipher.DECRYPT_MODE, aesKey()); + byte[] password = cipher.doFinal(Base64.getDecoder().decode(encryptedPassword.getBytes("UTF-8"))); + return new String(password,"UTF-8"); + } + private static Key aesKey(){ + byte[] aesValue = (new String("njrmbklcxtoplawf")).getBytes(); + return new SecretKeySpec(aesValue,"AES"); + } + /** + * Register the PolicyDBDao instance in the PolicyDBDaoEntity table + * @return Boolean, were we able to register? + */ + private boolean register(){ + logger.debug("register() as register() called"); + String[] url = getPapUrlUserPass(); + EntityManager em = emf.createEntityManager(); + try{ + startTransactionSynced(em, 1000); + } catch(IllegalStateException e){ + logger.debug ("\nPolicyDBDao.register() caught an IllegalStateException: \n" +e + "\n"); + DatabaseLockEntity lock; + lock = em.find(DatabaseLockEntity.class, 1); + if(lock==null){ + lock = new DatabaseLockEntity(); + em.persist(lock); + lock.setKey(1); + try{ + em.flush(); + em.getTransaction().commit(); + em.close(); + } catch(Exception e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "COULD NOT CREATE DATABASELOCK ROW. WILL TRY ONE MORE TIME"); + } + em = null; + em = emf.createEntityManager(); + try{ + startTransactionSynced(em, 1000); + } catch(Exception e3){ + String msg = "DATABASE LOCKING NOT WORKING. CONCURRENCY CONTROL NOT WORKING"; + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e3, "PolicyDBDao", msg); + throw new IllegalStateException("msg" + "\n" + e3); + } + } + } + logger.debug("\nPolicyDBDao.register. Database locking and concurrency control is initialized\n"); + PolicyDBDaoEntity foundPolicyDBDaoEntity = em.find(PolicyDBDaoEntity.class, url[0]); + Query getPolicyDBDaoEntityQuery = em.createQuery("SELECT e FROM PolicyDBDaoEntity e WHERE e.policyDBDaoUrl=:url"); + getPolicyDBDaoEntityQuery.setParameter("url", url[0]); + if(foundPolicyDBDaoEntity == null){ + PolicyDBDaoEntity newPolicyDBDaoEntity = new PolicyDBDaoEntity(); + em.persist(newPolicyDBDaoEntity); + newPolicyDBDaoEntity.setPolicyDBDaoUrl(url[0]); + newPolicyDBDaoEntity.setDescription("PAP server at "+url[0]); + newPolicyDBDaoEntity.setUsername(url[1]); + try{ + newPolicyDBDaoEntity.setPassword(encryptPassword(url[2])); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Could not encrypt PAP password"); + } + try{ + em.getTransaction().commit(); + } catch(Exception e){ + try{ + em.getTransaction().rollback(); + } catch(Exception e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "Could not add new PolicyDBDao to the database"); + } + } + } else { + //just want to update in order to change modified date + String encryptedPassword = null; + try{ + encryptedPassword = encryptPassword(url[2]); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Could not encrypt PAP password"); + } + if(url[1] != null && !stringEquals(url[1], foundPolicyDBDaoEntity.getUsername())){ + foundPolicyDBDaoEntity.setUsername(url[1]); + } + if(encryptedPassword != null && !stringEquals(encryptedPassword, foundPolicyDBDaoEntity.getPassword())){ + foundPolicyDBDaoEntity.setPassword(encryptedPassword); + } + foundPolicyDBDaoEntity.preUpdate(); + try{ + em.getTransaction().commit(); + } catch(Exception e){ + try{ + em.getTransaction().rollback(); + } catch(Exception e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "Could not update PolicyDBDao in the database"); + } + } + } + em.close(); + logger.debug("\nPolicyDBDao.register(). Success!!\n"); + return true; + } + public void notifyOthers(long entityId,String entityType){ + notifyOthers(entityId,entityType,null); + } + public void notifyOthers(long entityId, String entityType, String newGroupId){ + logger.debug("notifyOthers(long entityId, String entityType, long newGroupId) as notifyOthers("+entityId+","+entityType+","+newGroupId+") called"); + LinkedList<Thread> notifyThreads = new LinkedList<>(); + + //we're going to run notifications in parallel threads to speed things up + for(Object obj : otherServers){ + + Thread newNotifyThread = new Thread(new NotifyOtherThread(obj, entityId, entityType, newGroupId)); + + newNotifyThread.start(); + + notifyThreads.add(newNotifyThread); + + } + //we want to wait for all notifications to complete or timeout before we unlock the interface and allow more changes + for(Thread t : notifyThreads){ + try { + t.join(); + } catch (Exception e) { + logger.warn("Could not join a notifcation thread" + e); + } + } + + + } + + private class NotifyOtherThread implements Runnable { + public NotifyOtherThread(Object obj, long entityId, String entityType, String newGroupId){ + this.obj = obj; + this.entityId = entityId; + this.entityType = entityType; + this.newGroupId = newGroupId; + } + private Object obj; + private long entityId; + private String entityType; + private String newGroupId; + @Override + public void run(){ + //naming of 'o' is for backwards compatibility with the rest of the function + PolicyDBDaoEntity dbdEntity = (PolicyDBDaoEntity)obj; + String o = dbdEntity.getPolicyDBDaoUrl(); + String username = dbdEntity.getUsername(); + String password; + try{ + password = decryptPassword(dbdEntity.getPassword()); + } catch(Exception e){ + //if we can't decrypt, might as well try it anyway + password = dbdEntity.getPassword(); + } + Base64.Encoder encoder = Base64.getEncoder(); + String encoding = encoder.encodeToString((username+":"+password).getBytes(StandardCharsets.UTF_8)); + HttpURLConnection connection = null; + UUID requestID = UUID.randomUUID(); + URL url; + try { + String papUrl = getPapUrlUserPass()[0]; + if(papUrl == null){ + papUrl = "undefined"; + } + logger.debug("We are going to try to notify "+o); + //is this our own url? + String ourUrl = o; + try{ + ourUrl = splitPapUrlUserPass((String)o)[0]; + }catch(Exception e){ + ourUrl = o; + } + if(o == null){ + o = "undefined"; + } + if(papUrl.equals(ourUrl)){ + logger.debug(((String)o)+" is our url, skipping notify"); + return; + } + if(newGroupId == null){ + url = new URL(((String)o)+"?policydbdaourl="+papUrl+"&entityid="+entityId+"&entitytype="+entityType); + } else { + url = new URL(((String)o)+"?policydbdaourl="+papUrl+"&entityid="+entityId+"&entitytype="+entityType+"&extradata="+newGroupId); + } + } catch (MalformedURLException e) { + logger.warn("Caught MalformedURLException on: new URL()", e); + return; + } + // + // Open up the connection + // + logger.debug("Connecting with url: "+url); + try { + connection = (HttpURLConnection)url.openConnection(); + } catch (Exception e) { + logger.warn("Caught exception on: url.openConnection()",e); + return; + } + // + // Setup our method and headers + // + try { + connection.setRequestMethod("PUT"); + } catch (ProtocolException e) { + //why would this error ever occur? + logger.warn("Caught ProtocolException on connection.setRequestMethod(\"PUT\");",e); + return; + } + connection.setRequestProperty("Authorization", "Basic " + encoding); + connection.setRequestProperty("Accept", "text/x-java-properties"); + connection.setRequestProperty("Content-Type", "text/x-java-properties"); + connection.setRequestProperty("requestID", requestID.toString()); + int readTimeout; + try{ + readTimeout = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_NOTIFY_TIMEOUT)); + + } catch(Exception e){ + logger.error("xacml.rest.pap.notify.timeoutms property not set, using a default."); + readTimeout = 10000; + } + connection.setReadTimeout(readTimeout); + connection.setConnectTimeout(readTimeout); + connection.setUseCaches(false); + // + // Adding this in. It seems the HttpUrlConnection class does NOT + // properly forward our headers for POST re-direction. It does so + // for a GET re-direction. + // + // So we need to handle this ourselves. + // + connection.setInstanceFollowRedirects(false); + connection.setDoOutput(true); + connection.setDoInput(true); + try { + connection.connect(); + } catch (Exception e) { + logger.warn("Caught exception on: connection.connect()",e); + return; + } + try { + if (connection.getResponseCode() == 200) { + logger.info("Received response 200 from pap server on notify"); + //notified = true; + } else { + logger.warn("connection response code not 200, received: "+connection.getResponseCode()); + } + } catch (Exception e) { + logger.warn("Caught Exception on: connection.getResponseCode() ", e); + } + + + connection.disconnect(); + } + } + + private static String evaluateXPath(String expression, String xml) { + InputSource source = new InputSource(new StringReader(xml)); + + DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); + String description = ""; + try{ + DocumentBuilder db = dbf.newDocumentBuilder(); + Document document = db.parse(source); + + XPathFactory xpathFactory = XPathFactory.newInstance(); + XPath xpath = xpathFactory.newXPath(); + + + description = xpath.evaluate(expression, document); + }catch(Exception e){ + logger.error("Exception Occured while evaluating path"+e); + } + + return description; + } + + private static String getDescriptionFromXacml(String xacmlData){ + String openTag = "<Description>"; + String closeTag = "</Description>"; + int descIndex = xacmlData.indexOf(openTag); + int endDescIndex = xacmlData.indexOf(closeTag); + String desc = xacmlData.substring(descIndex+openTag.length(),endDescIndex); + return desc; + } + + private final String POLICY_NOTIFICATION = "policy"; + private final String PDP_NOTIFICATION = "pdp"; + private final String GROUP_NOTIFICATION = "group"; + public void handleIncomingHttpNotification(String url, String entityId, String entityType, String extraData, XACMLPapServlet xacmlPapServlet){ + logger.info("DBDao url: " + url + " has reported an update on "+entityType+" entity "+entityId); + PolicyDBDaoTransaction transaction = this.getNewTransaction(); + //although its named retries, this is the total number of tries + int retries; + try{ + retries = Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_INCOMINGNOTIFICATION_TRIES)); + + } catch(Exception e){ + logger.error("xacml.rest.pap.incomingnotification.tries property not set, using a default of 3."+e); + retries = 3; + } + //if someone sets it to some dumb value, we need to make sure it will try at least once + if(retries < 1){ + retries = 1; + } + int pauseBetweenRetries = 1000; + switch(entityType){ + + case POLICY_NOTIFICATION: + for(int i=0; i<retries;i++){ + try{ + handleIncomingPolicyChange(url, entityId,extraData); + break; + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught exception on handleIncomingPolicyChange("+url+", "+entityId+", "+extraData+")"); + } + try{ + Thread.sleep(pauseBetweenRetries); + }catch(InterruptedException ie){ + break; + } + } + break; + case PDP_NOTIFICATION: + for(int i=0; i<retries;i++){ + try{ + handleIncomingPdpChange(url, entityId, transaction); + break; + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught exception on handleIncomingPdpChange("+url+", "+entityId+", "+transaction+")"); + } + try{ + Thread.sleep(pauseBetweenRetries); + }catch(InterruptedException ie){ + break; + } + } + break; + case GROUP_NOTIFICATION: + for(int i=0; i<retries;i++){ + try{ + handleIncomingGroupChange(url, entityId, extraData, transaction, xacmlPapServlet); + break; + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught exception on handleIncomingGroupChange("+url+", "+entityId+", "+extraData+", "+transaction+", "+xacmlPapServlet+")"); + } + try{ + Thread.sleep(pauseBetweenRetries); + }catch(InterruptedException ie){ + break; + } + } + break; + } + //no changes should be being made in this function, we still need to close + transaction.rollbackTransaction(); + } + private void handleIncomingGroupChange(String url, String groupId, String extraData,PolicyDBDaoTransaction transaction,XACMLPapServlet xacmlPapServlet) throws PAPException{ + GroupEntity groupRecord = null; + long groupIdLong = -1; + try{ + groupIdLong = Long.parseLong(groupId); + } catch(NumberFormatException e){ + throw new IllegalArgumentException("groupId "+groupId+" cannot be parsed into a long"); + } + try{ + groupRecord = transaction.getGroup(groupIdLong); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get pdp group record with transaction.getGroup("+groupIdLong+");"); + throw new PAPException("Could not get local group "+groupIdLong); + } + if(groupRecord == null){ + throw new PersistenceException("The group record returned is null"); + } + //compare to local fs + //does group folder exist + OnapPDPGroup localGroup = null; + try { + localGroup = papEngine.getGroup(groupRecord.getGroupId()); + } catch (Exception e) { + logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup("+groupId+");",e); + } + if(localGroup == null && extraData != null){ + //here we can try to load an old group id from the extraData + try{ + localGroup = papEngine.getGroup(extraData); + }catch(Exception e){ + logger.warn("Caught PAPException trying to get local pdp group with papEngine.getGroup("+extraData+");",e); + } + } + if(localGroup != null && groupRecord.isDeleted()){ + OnapPDPGroup newLocalGroup = null; + if(extraData != null){ + try { + newLocalGroup = papEngine.getGroup(extraData); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to get new pdp group with papEngine.getGroup("+extraData+");"); + } + } + try { + papEngine.removeGroup(localGroup, newLocalGroup); + } catch (NullPointerException | PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to get remove pdp group with papEngine.removeGroup("+localGroup+", "+newLocalGroup+");"); + throw new PAPException("Could not remove group "+groupId); + } + } + else if(localGroup == null){ + //creating a new group + try { + papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription()); + } catch (NullPointerException | PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to create pdp group with papEngine.newGroup(groupRecord.getgroupName(), groupRecord.getDescription());"); + throw new PAPException("Could not create group "+groupRecord); + } + try { + localGroup = papEngine.getGroup(groupRecord.getGroupId()); + } catch (PAPException e1) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, "PolicyDBDao", "Caught PAPException trying to get pdp group we just created with papEngine.getGroup(groupRecord.getGroupId());\nAny PDPs or policies in the new group may not have been added"); + return; + } + //add possible pdps to group + List<?> pdpsInGroup = transaction.getPdpsInGroup(Long.parseLong(groupRecord.getGroupId())); + for(Object pdpO : pdpsInGroup){ + PdpEntity pdp = (PdpEntity)pdpO; + try { + papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort()); + } catch (NullPointerException | PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to get create pdp with papEngine.newPDP(pdp.getPdpId(), localGroup, pdp.getPdpName(), pdp.getDescription(), pdp.getJmxPort());"); + throw new PAPException("Could not create pdp "+pdp); + } + } + //add possible policies to group (filesystem only, apparently) + } else { + if(!(localGroup instanceof StdPDPGroup)){ + throw new PAPException("group is not a StdPDPGroup"); + } + //clone the object + //because it will be comparing the new group to its own version + StdPDPGroup localGroupClone = new StdPDPGroup(localGroup.getId(),localGroup.isDefaultGroup(),localGroup.getName(),localGroup.getDescription(),((StdPDPGroup)localGroup).getDirectory()); + localGroupClone.setOnapPdps(localGroup.getOnapPdps()); + localGroupClone.setPipConfigs(localGroup.getPipConfigs()); + localGroupClone.setStatus(localGroup.getStatus()); + //we are updating a group or adding a policy or changing default + //set default if it should be + if(!localGroupClone.isDefaultGroup() && groupRecord.isDefaultGroup()){ + try { + papEngine.SetDefaultGroup(localGroup); + return; + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to set default group with papEngine.SetDefaultGroup("+localGroupClone+");"); + throw new PAPException("Could not set default group to "+localGroupClone); + } + } + boolean needToUpdate = false; + if(updateGroupPoliciesInFileSystem(localGroupClone,localGroup, groupRecord, transaction)){ + needToUpdate = true; + } + if(!stringEquals(localGroupClone.getId(),groupRecord.getGroupId()) || !stringEquals(localGroupClone.getName(),groupRecord.getgroupName())){ + //changing ids + //we do not want to change the id, the papEngine will do this for us, it needs to know the old id + localGroupClone.setName(groupRecord.getgroupName()); + needToUpdate = true; + } + if(!stringEquals(localGroupClone.getDescription(),groupRecord.getDescription())){ + localGroupClone.setDescription(groupRecord.getDescription()); + needToUpdate = true; + } + if(needToUpdate){ + try { + + papEngine.updateGroup(localGroupClone); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to update group with papEngine.updateGroup("+localGroupClone+");"); + throw new PAPException("Could not update group "+localGroupClone); + } + } + + } + //call command that corresponds to the change that was made + } + //this will also handle removes, since incoming pdpGroup has no policies internally, we are just going to add them all in from the db + private boolean updateGroupPoliciesInFileSystem(OnapPDPGroup pdpGroup,OnapPDPGroup oldPdpGroup, GroupEntity groupRecord, PolicyDBDaoTransaction transaction) throws PAPException{ + if(!(pdpGroup instanceof StdPDPGroup)){ + throw new PAPException("group is not a StdPDPGroup"); + } + StdPDPGroup group = (StdPDPGroup)pdpGroup; + //this must always be true since we don't explicitly know when a delete is occuring + boolean didUpdate = true; + HashMap<String,PDPPolicy> currentPolicySet = new HashMap<String,PDPPolicy>(oldPdpGroup.getPolicies().size()); + HashSet<PDPPolicy> newPolicySet = new HashSet<>(); + for(PDPPolicy pdpPolicy : oldPdpGroup.getPolicies()){ + currentPolicySet.put(pdpPolicy.getId(), pdpPolicy); + } + for(PolicyEntity policy : groupRecord.getPolicies()){ + String pdpPolicyName = getPdpPolicyName(policy.getPolicyName(), policy.getScope()); + if(group.getPolicy(pdpPolicyName) == null){ + didUpdate = true; + if(currentPolicySet.containsKey(pdpPolicyName)){ + newPolicySet.add(currentPolicySet.get(pdpPolicyName)); + } else{ + InputStream policyStream = new ByteArrayInputStream(policy.getPolicyData().getBytes()); + group.copyPolicyToFile(pdpPolicyName,policyStream); + ((StdPDPPolicy)(group.getPolicy(pdpPolicyName))).setName(removeExtensionAndVersionFromPolicyName(policy.getPolicyName())); + try { + policyStream.close(); + } catch (IOException e) { + didUpdate = false; + PolicyLogger.error(e.getMessage() +e); + } + } + } + } + if(didUpdate){ + newPolicySet.addAll(group.getPolicies()); + group.setPolicies(newPolicySet); + } + return didUpdate; + + } + private String removeExtensionAndVersionFromPolicyName(String originalPolicyName){ + return getPolicyNameAndVersionFromPolicyFileName(originalPolicyName)[0]; + } + + /** + * Splits apart the policy name and version from a policy file path + * @param originalPolicyName: a policy file name ex: Config_policy.2.xml + * @return An array [0]: The policy name, [1]: the policy version, as a string + */ + private String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName){ + String policyName = originalPolicyName; + String[] nameAndVersion = new String[2]; + try{ + policyName = removeFileExtension(policyName); + nameAndVersion[0] = policyName.substring(0,policyName.lastIndexOf('.')); + if(isNullOrEmpty(nameAndVersion[0])){ + throw new Exception(); + } + } catch(Exception e){ + nameAndVersion[0] = originalPolicyName; + } + try{ + nameAndVersion[1] = policyName.substring(policyName.lastIndexOf('.')+1); + if(isNullOrEmpty(nameAndVersion[1])){ + throw new Exception(); + } + } catch(Exception e){ + nameAndVersion[1] = "1"; + } + return nameAndVersion; + } + + private void handleIncomingPdpChange(String url, String pdpId, PolicyDBDaoTransaction transaction) throws PAPException{ + //get pdp + long pdpIdLong = -1; + try{ + pdpIdLong = Long.parseLong(pdpId); + }catch(NumberFormatException e){ + throw new IllegalArgumentException("pdpId "+pdpId+" cannot be parsed into a long"); + } + PdpEntity pdpRecord = null; + try{ + pdpRecord = transaction.getPdp(pdpIdLong); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get pdp record with transaction.getPdp("+pdpIdLong+");"); + throw new PAPException("Could not get local pdp "+pdpIdLong); + } + if(pdpRecord == null){ + throw new PersistenceException("The pdpRecord returned is null"); + } + PDP localPdp = null; + try { + localPdp = papEngine.getPDP(pdpRecord.getPdpId()); + } catch (PAPException e) { + logger.warn("Caught PAPException trying to get local pdp with papEngine.getPDP("+pdpId+");",e); + } + if(localPdp != null && pdpRecord.isDeleted()){ + try { + papEngine.removePDP((OnapPDP) localPdp); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to get remove pdp with papEngine.removePDP("+localPdp+");"); + throw new PAPException("Could not remove pdp "+pdpId); + } + } + else if(localPdp == null){ + //add new pdp + //get group + OnapPDPGroup localGroup = null; + try { + localGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId()); + } catch (PAPException e1) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, "PolicyDBDao", "Caught PAPException trying to get local group to add pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());"); + throw new PAPException("Could not get local group"); + } + try { + papEngine.newPDP(pdpRecord.getPdpId(), localGroup, pdpRecord.getPdpName(), pdpRecord.getDescription(), pdpRecord.getJmxPort()); + } catch (NullPointerException | PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to create pdp with papEngine.newPDP("+pdpRecord.getPdpId()+", "+localGroup+", "+pdpRecord.getPdpName()+", "+pdpRecord.getDescription()+", "+pdpRecord.getJmxPort()+");"); + throw new PAPException("Could not create pdp "+pdpRecord); + } + } else { + boolean needToUpdate = false; + if(!stringEquals(localPdp.getId(),pdpRecord.getPdpId()) || !stringEquals(localPdp.getName(),pdpRecord.getPdpName())){ + //again, we don't want to change the id, the papEngine will do this + localPdp.setName(pdpRecord.getPdpName()); + needToUpdate = true; + } + if(!stringEquals(localPdp.getDescription(),pdpRecord.getDescription())){ + localPdp.setDescription(pdpRecord.getDescription()); + needToUpdate = true; + } + String localPdpGroupId = null; + try{ + localPdpGroupId = papEngine.getPDPGroup((OnapPDP) localPdp).getId(); + } catch(PAPException e){ + //could be null or something, just warn at this point + logger.warn("Caught PAPException trying to get id of local group that pdp is in with localPdpGroupId = papEngine.getPDPGroup(localPdp).getId();",e); + } + if(!stringEquals(localPdpGroupId,pdpRecord.getGroup().getGroupId())){ + OnapPDPGroup newPdpGroup = null; + try{ + newPdpGroup = papEngine.getGroup(pdpRecord.getGroup().getGroupId()); + }catch(PAPException e){ + //ok, now we have an issue. Time to stop things + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to get id of local group to move pdp to with papEngine.getGroup(pdpRecord.getGroup().getGroupId());"); + throw new PAPException("Could not get local group"); + } + try{ + papEngine.movePDP((OnapPDP) localPdp, newPdpGroup); + }catch(PAPException e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to move pdp with papEngine.movePDP(localPdp, newPdpGroup);"); + throw new PAPException("Could not move pdp "+localPdp); + } + } + if(((PdpEntity) localPdp).getJmxPort() != pdpRecord.getJmxPort()){ + ((PdpEntity) localPdp).setJmxPort(pdpRecord.getJmxPort()); + needToUpdate = true; + } + if(needToUpdate){ + try { + papEngine.updatePDP((OnapPDP) localPdp); + } catch (PAPException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PAPException trying to update pdp with papEngine.updatePdp("+localPdp+");"); + throw new PAPException("Could not update pdp "+localPdp); + } + } + } + //compare to local situation + //call command to update + } + private void handleIncomingPolicyChange(String url, String policyId,String oldPathString){ + String policyName = null; + EntityManager em = emf.createEntityManager(); + Query getPolicyEntityQuery = em.createNamedQuery("PolicyEntity.FindById"); + getPolicyEntityQuery.setParameter("id", Long.valueOf(policyId)); + + @SuppressWarnings("unchecked") + List<PolicyEntity> policies = getPolicyEntityQuery.getResultList(); + PolicyEntity policy = null; + if (!policies.isEmpty()){ + policy = policies.get(0); + } + String action = "unknown action"; + try { + if(policy != null){ + policyName = policy.getPolicyName(); + logger.debug("Deleting Policy: " + policy.getPolicyName()); + action = "delete"; + Path subFile = null; + + if (policy.getConfigurationData()!= null){ + subFile = getPolicySubFile(policy.getConfigurationData().getConfigurationName(), "Config"); + }else if(policy.getActionBodyEntity()!= null){ + subFile = getPolicySubFile(policy.getActionBodyEntity().getActionBodyName(), "Action"); + } + + if(subFile != null){ + Files.deleteIfExists(subFile); + } + if (policy.getConfigurationData()!= null){ + writePolicySubFile(policy, "Config"); + }else if(policy.getActionBodyEntity()!= null){ + writePolicySubFile(policy, "Action"); + } + } + } catch (IOException e1) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, "PolicyDBDao", "Error occurred while performing [" + action + "] of Policy File: " + policyName); + } + } + + private String getPdpPolicyName(String name, String scope){ + String finalName = ""; + finalName += scope; + finalName += "."; + finalName += removeFileExtension(name); + finalName += ".xml"; + return finalName; + } + private String removeFileExtension(String fileName){ + return fileName.substring(0, fileName.lastIndexOf('.')); + } + + private Path getPolicySubFile(String filename, String subFileType){ + logger.debug("getPolicySubFile(" + filename + ", " + subFileType + ")"); + Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), subFileType); + File file = null; + + filename = FilenameUtils.removeExtension(filename); + + for(File tmpFile : filePath.toFile().listFiles()){ + if (FilenameUtils.removeExtension(tmpFile.getName()).equals(filename)){ + file = tmpFile; + } + } + + Path finalPath = null; + if (file!= null){ + finalPath = Paths.get(file.getAbsolutePath()); + } + + logger.debug("end of getPolicySubFile: " + finalPath); + return finalPath; + } + + private boolean writePolicySubFile(PolicyEntity policy, String policyType){ + logger.info("writePolicySubFile with policyName[" + policy.getPolicyName() + "] and policyType[" + policyType + "]"); + String type = null; + String subTypeName = null; + String subTypeBody = null; + if (policyType.equalsIgnoreCase("config")){ + type = "Config"; + subTypeName = FilenameUtils.removeExtension(policy.getConfigurationData().getConfigurationName()); + subTypeBody = policy.getConfigurationData().getConfigBody(); + + String configType = policy.getConfigurationData().getConfigType(); + + + if (configType != null) { + if (configType.equals(JSON_CONFIG)) { + subTypeName = subTypeName + ".json"; + } + if (configType.equals(XML_CONFIG)) { + subTypeName = subTypeName + ".xml"; + } + if (configType.equals(PROPERTIES_CONFIG)) { + subTypeName = subTypeName + ".properties"; + } + if (configType.equals(OTHER_CONFIG)) { + subTypeName = subTypeName + ".txt"; + } + } + + }else if (policyType.equalsIgnoreCase("action")){ + type = "Action"; + subTypeName = policy.getActionBodyEntity().getActionBodyName(); + subTypeBody = policy.getActionBodyEntity().getActionBody(); + + + } + Path filePath = Paths.get(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS).toString(), type); + + if(subTypeBody == null){ + subTypeBody = ""; + } + boolean success = false; + try { + Files.deleteIfExists(Paths.get(filePath.toString(), subTypeName)); + File file = Paths.get(filePath.toString(),subTypeName).toFile(); + file.createNewFile(); + FileWriter fileWriter = new FileWriter(file, false); // false to overwrite + fileWriter.write(subTypeBody); + fileWriter.close(); + success = true; + + } catch (Exception e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Exception occured while creating Configuration File for Policy : " + policy.getPolicyName()); + } + + return success; + + } + + public void auditLocalDatabase(PAPPolicyEngine papEngine2){ + logger.debug("PolicyDBDao.auditLocalDatabase() is called"); + try{ + deleteAllGroupTables(); + auditGroups(papEngine2); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "auditLocalDatabase() error"); + logger.error("Exception Occured"+e); + } + } + + public void deleteAllGroupTables(){ + logger.debug("PolicyDBDao.deleteAllGroupTables() called"); + EntityManager em = emf.createEntityManager(); + em.getTransaction().begin(); + + Query deletePdpEntityEntityTableUpdate = em.createNamedQuery("PdpEntity.deleteAll"); + deletePdpEntityEntityTableUpdate.executeUpdate(); + + Query deleteGroupEntityTableUpdate = em.createNamedQuery("GroupEntity.deleteAll"); + deleteGroupEntityTableUpdate.executeUpdate(); + + em.getTransaction().commit(); + em.close(); + } + + @SuppressWarnings("unchecked") + public void auditGroups(PAPPolicyEngine papEngine2){ + logger.debug("PolicyDBDao.auditGroups() called"); + + EntityManager em = emf.createEntityManager(); + em.getTransaction().begin(); + final String AUDIT_STR = "Audit"; + try{ + + Set<OnapPDPGroup> groups = papEngine2.getOnapPDPGroups(); + + for (OnapPDPGroup grp : groups){ + try{ + GroupEntity groupEntity = new GroupEntity(); + em.persist(groupEntity); + groupEntity.setGroupName(grp.getName()); + groupEntity.setDescription(grp.getDescription()); + groupEntity.setDefaultGroup(grp.isDefaultGroup()); + groupEntity.setCreatedBy(AUDIT_STR); + groupEntity.setGroupId(createNewPDPGroupId(grp.getId())); + groupEntity.setModifiedBy(AUDIT_STR); + Set<OnapPDP> pdps = grp.getOnapPdps(); + + for(OnapPDP pdp : pdps){ + PdpEntity pdpEntity = new PdpEntity(); + em.persist(pdpEntity); + pdpEntity.setGroup(groupEntity); + pdpEntity.setJmxPort(pdp.getJmxPort()); + pdpEntity.setPdpId(pdp.getId()); + pdpEntity.setPdpName(pdp.getName()); + pdpEntity.setModifiedBy(AUDIT_STR); + pdpEntity.setCreatedBy(AUDIT_STR); + + } + + Set<PDPPolicy> policies = grp.getPolicies(); + + for(PDPPolicy policy : policies){ + try{ + String[] stringArray = getNameScopeAndVersionFromPdpPolicy(policy.getId()); + List<PolicyEntity> policyEntityList; + Query getPolicyEntitiesQuery = em.createNamedQuery("PolicyEntity.findByNameAndScope"); + getPolicyEntitiesQuery.setParameter("name", stringArray[0]); + getPolicyEntitiesQuery.setParameter("scope", stringArray[1]); + + policyEntityList = getPolicyEntitiesQuery.getResultList(); + PolicyEntity policyEntity = null; + if(!policyEntityList.isEmpty()){ + policyEntity = policyEntityList.get(0); + } + if(policyEntity != null){ + groupEntity.addPolicyToGroup(policyEntity); + } + }catch(Exception e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "Exception auditGroups inner catch"); + } + } + }catch(Exception e1){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, "PolicyDBDao", "Exception auditGroups middle catch"); + } + } + }catch(Exception e){ + em.getTransaction().rollback(); + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Exception auditGroups outer catch"); + em.close(); + return; + } + + em.getTransaction().commit(); + em.close(); + + } + + private String getConfigFile(String filename, PolicyRestAdapter policy){ + if(policy == null){ + return getConfigFile(filename, (String)null); + } + return getConfigFile(filename, policy.getConfigType()); + } + //copied from ConfigPolicy.java and modified + // Here we are adding the extension for the configurations file based on the + // config type selection for saving. + private String getConfigFile(String filename, String configType) { + logger.debug("getConfigFile(String filename, String scope, String configType) as getConfigFile("+filename+", "+configType+") called"); + filename = FilenameUtils.removeExtension(filename); + String id = configType; + + if (id != null) { + if (id.equals(ConfigPolicy.JSON_CONFIG) || id.contains("Firewall")) { + filename = filename + ".json"; + } + if (id.equals(ConfigPolicy.XML_CONFIG)) { + filename = filename + ".xml"; + } + if (id.equals(ConfigPolicy.PROPERTIES_CONFIG)) { + filename = filename + ".properties"; + } + if (id.equals(ConfigPolicy.OTHER_CONFIG)) { + filename = filename + ".txt"; + } + } + return filename; + } + + private String[] getNameScopeAndVersionFromPdpPolicy(String fileName){ + String[] splitByDots = fileName.split("\\."); + if(splitByDots.length < 3){ + //should we throw something + return null; + } + String policyName = splitByDots[splitByDots.length-3]; + String version = splitByDots[splitByDots.length-2]; + //policy names now include version + String scope = ""; + for(int i=0;i<splitByDots.length-3;i++){ + scope += ".".concat(splitByDots[i]); + } + //remove the first dot + if(scope.length() > 0){ + scope = scope.substring(1); + } + String[] returnArray = new String[3]; + returnArray[0] = policyName + "." + version + ".xml"; + returnArray[2] = version; + returnArray[1] = scope; + return returnArray; + } + + //copied from StdEngine.java + public static String createNewPDPGroupId(String name) { + String id = name; + // replace "bad" characters with sequences that will be ok for file names and properties keys. + id = id.replace(" ", "_sp_"); + id = id.replace("\t", "_tab_"); + id = id.replace("\\", "_bksl_"); + id = id.replace("/", "_sl_"); + id = id.replace(":", "_col_"); + id = id.replace("*", "_ast_"); + id = id.replace("?", "_q_"); + id = id.replace("\"", "_quo_"); + id = id.replace("<", "_lt_"); + id = id.replace(">", "_gt_"); + id = id.replace("|", "_bar_"); + id = id.replace("=", "_eq_"); + id = id.replace(",", "_com_"); + id = id.replace(";", "_scom_"); + + return id; + } + + /** + * Checks if any of the given strings are empty or null + * @param strings One or more Strings (or nulls) to check if they are null or empty + * @return true if one or more of the given strings are empty or null + */ + private static boolean isNullOrEmpty(String... strings){ + for(String s : strings){ + if(!(s instanceof String)){ + return true; + } + if(s.equals("")){ + return true; + } + } + return false; + } + + + private class PolicyDBDaoTransactionInstance implements PolicyDBDaoTransaction { + private EntityManager em; + private final Object emLock = new Object(); + long policyId; + long groupId; + long pdpId; + String newGroupId; + private boolean operationRun = false; + private final Thread transactionTimer; + + private PolicyDBDaoTransactionInstance(){ + //call the constructor with arguments + this(Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_TIMEOUT)), + Integer.parseInt(XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_TRANS_WAIT))); + } + //timeout is how long the transaction can sit before rolling back + //wait time is how long to wait for the transaction to start before throwing an exception + private PolicyDBDaoTransactionInstance(int transactionTimeout, int transactionWaitTime){ + if(logger.isDebugEnabled()){ + logger.debug("\n\nPolicyDBDaoTransactionInstance() as PolicyDBDaoTransactionInstance() called:" + + "\n transactionTimeout = " + transactionTimeout + + "\n transactionWaitTime = " + transactionWaitTime + "\n\n"); + } + this.em = emf.createEntityManager(); + policyId = -1; + groupId = -1; + pdpId = -1; + newGroupId = null; + synchronized(emLock){ + try{ + startTransactionSynced(this.em,transactionWaitTime); + } catch(Exception e){ + throw new PersistenceException("Could not lock transaction within "+transactionWaitTime+" milliseconds"); + } + } + class TransactionTimer implements Runnable { + + private int sleepTime; + public TransactionTimer(int timeout){ + this.sleepTime = timeout; + } + @Override + public void run() { + if(logger.isDebugEnabled()){ + Date date= new java.util.Date(); + logger.debug("\n\nTransactionTimer.run() - SLEEPING: " + + "\n sleepTime (ms) = " + sleepTime + + "\n TimeStamp = " + date.getTime() + + "\n\n"); + } + try { + Thread.sleep(sleepTime); + } catch (InterruptedException e) { + //probably, the transaction was completed, the last thing we want to do is roll back + if(logger.isDebugEnabled()){ + Date date= new java.util.Date(); + logger.debug("\n\nTransactionTimer.run() - WAKE Interrupt: " + + "\n TimeStamp = " + date.getTime() + + "\n\n"); + } + return; + } + if(logger.isDebugEnabled()){ + Date date= new java.util.Date(); + logger.debug("\n\nTransactionTimer.run() - WAKE Timeout: " + + "\n TimeStamp = " + date.getTime() + + "\n\n"); + } + rollbackTransaction(); + } + + } + + transactionTimer = new Thread(new TransactionTimer(transactionTimeout),"transactionTimerThread"); + transactionTimer.start(); + + + } + + private void checkBeforeOperationRun(){ + checkBeforeOperationRun(false); + } + private void checkBeforeOperationRun(boolean justCheckOpen){ + if(!isTransactionOpen()){ + PolicyLogger.error("There is no transaction currently open"); + throw new IllegalStateException("There is no transaction currently open"); + } + if(operationRun && !justCheckOpen){ + PolicyLogger.error("An operation has already been performed and the current transaction should be committed"); + throw new IllegalStateException("An operation has already been performed and the current transaction should be committed"); + } + operationRun = true; + } + @Override + public void commitTransaction() { + synchronized(emLock){ + logger.debug("commitTransaction() as commitTransaction() called"); + if(!isTransactionOpen()){ + logger.warn("There is no open transaction to commit"); + try{ + em.close(); + } catch(Exception e){ + logger.error("Exception Occured"+e); + } + return; + } + try{ + em.getTransaction().commit(); + } catch(RollbackException e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught RollbackException on em.getTransaction().commit()"); + throw new PersistenceException("The commit failed. Message:\n"+e.getMessage()); + } + em.close(); + // need to revisit + if(policyId >= 0){ + if(newGroupId != null){ + try{ + notifyOthers(policyId,POLICY_NOTIFICATION,newGroupId); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on notifyOthers("+policyId+","+POLICY_NOTIFICATION+","+newGroupId+")"); + } + } else { + try{ + notifyOthers(policyId,POLICY_NOTIFICATION); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on notifyOthers("+policyId+","+POLICY_NOTIFICATION+")"); + } + } + } + if(groupId >= 0){ + //we don't want commit to fail just because this does + if(newGroupId != null){ + try{ + notifyOthers(groupId,GROUP_NOTIFICATION,newGroupId); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on notifyOthers("+groupId+","+GROUP_NOTIFICATION+","+newGroupId+")"); + } + } else { + try{ + notifyOthers(groupId,GROUP_NOTIFICATION); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on notifyOthers("+groupId+","+GROUP_NOTIFICATION+")"); + } + } + } + if(pdpId >= 0){ + //we don't want commit to fail just because this does + try{ + notifyOthers(pdpId,PDP_NOTIFICATION); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on notifyOthers("+pdpId+","+PDP_NOTIFICATION+")"); + } + } + } + if(transactionTimer instanceof Thread){ + transactionTimer.interrupt(); + } + } + + @Override + public void rollbackTransaction() { + logger.debug("rollbackTransaction() as rollbackTransaction() called"); + synchronized(emLock){ + if(isTransactionOpen()){ + + try{ + em.getTransaction().rollback(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Could not rollback transaction"); + } + try{ + em.close(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Could not close EntityManager"); + } + + } else { + try{ + em.close(); + }catch(Exception e){ + logger.warn("Could not close already closed transaction"); + } + } + + } + if(transactionTimer instanceof Thread){ + transactionTimer.interrupt(); + } + + + } + + private void createPolicy(PolicyRestAdapter policy, String username, String policyScope, String policyName, String policyDataString) { + logger.debug("createPolicy(PolicyRestAdapter policy, String username, String policyScope, String policyName, String policyDataString) as createPolicy("+policy+", "+username+", "+policyScope+", "+policyName+", "+policyDataString+") called"); + synchronized(emLock){ + checkBeforeOperationRun(); + String configName = policyName; + if(policyName.contains("Config_")){ + policyName = policyName.replace(".Config_", ":Config_"); + }else if(policyName.contains("Action_")){ + policyName = policyName.replace(".Action_", ":Action_"); + }else if(policyName.contains("Decision_")){ + policyName = policyName.replace(".Decision_", ":Decision_"); + } + policyName = policyName.split(":")[1]; + Query createPolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName"); + createPolicyQuery.setParameter("scope", policyScope); + createPolicyQuery.setParameter("policyName", policyName); + List<?> createPolicyQueryList = createPolicyQuery.getResultList(); + PolicyEntity newPolicyEntity; + boolean update; + if(createPolicyQueryList.size() < 1){ + newPolicyEntity = new PolicyEntity(); + update = false; + } else if(createPolicyQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one policy with the same scope, name, and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one policy with the same scope, name, and deleted status were found in the database"); + } else { + newPolicyEntity = (PolicyEntity)createPolicyQueryList.get(0); + update = true; + } + + ActionBodyEntity newActionBodyEntity = null; + if(policy.getPolicyType().equals("Action")){ + boolean abupdate = false; + if(newPolicyEntity.getActionBodyEntity() == null){ + newActionBodyEntity = new ActionBodyEntity(); + }else{ + newActionBodyEntity = em.find(ActionBodyEntity.class, newPolicyEntity.getActionBodyEntity().getActionBodyId()); + abupdate = true; + } + + if(newActionBodyEntity != null){ + if(!abupdate){ + em.persist(newActionBodyEntity); + } + //build the file path + //trim the .xml off the end + String policyNameClean = FilenameUtils.removeExtension(configName); + String actionBodyName = policyNameClean + ".json"; + Path actionBodyPath = Paths.get(Webapps.getActionHome(), actionBodyName); + if(logger.isDebugEnabled()){ + logger.debug("\nPolicyDBDao.createPolicy" + + "\n actionBodyPath = " + actionBodyPath); + } + //get the action body + String actionBodyString = null; + String actionBodyPathStr = null; + InputStream fileContentStream = null; + + if (Files.exists(actionBodyPath)) { + try { + actionBodyPathStr = (actionBodyPath != null ? actionBodyPath.toString() : null); + fileContentStream = new FileInputStream(actionBodyPathStr); + actionBodyString = IOUtils.toString(fileContentStream); + if(logger.isDebugEnabled()){ + logger.debug("\nPolicyDBDao.createPolicy" + + "\n actionBodyPathStr = " + actionBodyPathStr + + "\n actionBodyString = " + actionBodyString); + } + } catch (FileNotFoundException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught FileNotFoundException on new actionBodyPathStr FileInputStream("+actionBodyPathStr+")"); + throw new IllegalArgumentException("The actionBodyPathStr file path " + actionBodyPathStr + " does not exist" + + "\nEXCEPTION: " + e); + } catch(IOException e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "Caught IOException on actionBodyPath newIOUtils.toString("+fileContentStream+")"); + throw new IllegalArgumentException("The actionBodyPath file path cannot be read" + fileContentStream + + "\nEXCEPTION: " + e2); + } finally { + IOUtils.closeQuietly(fileContentStream); + } + + if(actionBodyString == null){ + throw new IllegalArgumentException("The file path (" + actionBodyPathStr + ") cannot be read"); + } + } else { + actionBodyString = "{}"; + } + + newActionBodyEntity.setActionBody(actionBodyString); + newActionBodyEntity.setActionBodyName(actionBodyName); + newActionBodyEntity.setModifiedBy("PolicyDBDao.createPolicy()"); + newActionBodyEntity.setDeleted(false); + if(!abupdate){ + newActionBodyEntity.setCreatedBy("PolicyDBDao.createPolicy()"); + } + if(logger.isDebugEnabled()){ + logger.debug("\nPolicyDBDao.createPolicy" + + "\n newActionBodyEntity.getActionBody() = " + newActionBodyEntity.getActionBody() + + "\n newActionBodyEntity.getActionBodyName() = " + newActionBodyEntity.getActionBodyName() + + "\n newActionBodyEntity.getModifiedBy() = " + newActionBodyEntity.getModifiedBy() + + "\n newActionBodyEntity.getCreatedBy() = " + newActionBodyEntity.getCreatedBy() + + "\n newActionBodyEntity.isDeleted() = " + newActionBodyEntity.isDeleted() + + "\n FLUSHING to DB"); + } + //push the actionBodyEntity to the DB + em.flush(); + }else{ + //newActionBodyEntity == null + //We have a actionBody in the policy but we found no actionBody in the DB + String msg = "\n\nPolicyDBDao.createPolicy - Incoming Action policy had an " + + "actionBody, but it could not be found in the DB for update." + + "\n policyScope = " + policyScope + + "\n policyName = " + policyName + "\n\n"; + PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Action policy had an actionBody, but it could not be found in the DB for update: policyName = " + policyName); + throw new IllegalArgumentException(msg); + } + } + + ConfigurationDataEntity newConfigurationDataEntity; + if(policy.getPolicyType().equals("Config")){ + boolean configUpdate; + if(newPolicyEntity.getConfigurationData() == null){ + newConfigurationDataEntity = new ConfigurationDataEntity(); + configUpdate = false; + } else { + newConfigurationDataEntity = em.find(ConfigurationDataEntity.class, newPolicyEntity.getConfigurationData().getConfigurationDataId()); + configUpdate = true; + } + + if(newConfigurationDataEntity != null){ + if(!configUpdate){ + em.persist(newConfigurationDataEntity); + } + if(!stringEquals(newConfigurationDataEntity.getConfigurationName(),getConfigFile(configName,policy))){ + newConfigurationDataEntity.setConfigurationName(getConfigFile(configName,policy)); + } + if(newConfigurationDataEntity.getConfigType() == null || !newConfigurationDataEntity.getConfigType().equals(policy.getConfigType())){ + newConfigurationDataEntity.setConfigType(policy.getConfigType()); + } + if(!configUpdate){ + newConfigurationDataEntity.setCreatedBy(username); + } + if(newConfigurationDataEntity.getModifiedBy() == null || !newConfigurationDataEntity.getModifiedBy().equals(username)){ + newConfigurationDataEntity.setModifiedBy(username); + } + if(newConfigurationDataEntity.getDescription() == null || !newConfigurationDataEntity.getDescription().equals("")){ + newConfigurationDataEntity.setDescription(""); + } + if(newConfigurationDataEntity.getConfigBody() == null || newConfigurationDataEntity.getConfigBody().isEmpty() || + (!newConfigurationDataEntity.getConfigBody().equals(policy.getConfigBodyData()))){ + //hopefully one of these won't be null + if(policy.getConfigBodyData() == null || policy.getConfigBodyData().isEmpty()){ + newConfigurationDataEntity.setConfigBody(policy.getJsonBody()); + }else{ + newConfigurationDataEntity.setConfigBody(policy.getConfigBodyData()); + } + } + if(newConfigurationDataEntity.isDeleted() == true){ + newConfigurationDataEntity.setDeleted(false); + } + + em.flush(); + }else{ + //We have a configurationData body in the policy but we found no configurationData body in the DB + String msg = "\n\nPolicyDBDao.createPolicy - Incoming Config policy had a " + + "configurationData body, but it could not be found in the DB for update." + + "\n policyScope = " + policyScope + + "\n policyName = " + policyName + "\n\n"; + PolicyLogger.error("PolicyDBDao.createPolicy - Incoming Config policy had a configurationData body, but it could not be found in the DB for update: policyName = " + policyName); + throw new IllegalArgumentException(msg); + } + + } else { + newConfigurationDataEntity = null; + } + if(!update){ + em.persist(newPolicyEntity); + } + + policyId = newPolicyEntity.getPolicyId(); + + if(!stringEquals(newPolicyEntity.getPolicyName(),policyName)){ + newPolicyEntity.setPolicyName(policyName); + } + if(!stringEquals(newPolicyEntity.getCreatedBy(),username)){ + newPolicyEntity.setCreatedBy(username); + } + if(!stringEquals(newPolicyEntity.getDescription(),policy.getPolicyDescription())){ + newPolicyEntity.setDescription(policy.getPolicyDescription()); + } + if(!stringEquals(newPolicyEntity.getModifiedBy(),username)){ + newPolicyEntity.setModifiedBy(username); + } + if(!stringEquals(newPolicyEntity.getPolicyData(),policyDataString)){ + newPolicyEntity.setPolicyData(policyDataString); + } + if(!stringEquals(newPolicyEntity.getScope(),policyScope)){ + newPolicyEntity.setScope(policyScope); + } + if(newPolicyEntity.isDeleted() == true){ + newPolicyEntity.setDeleted(false); + } + newPolicyEntity.setConfigurationData(newConfigurationDataEntity); + newPolicyEntity.setActionBodyEntity(newActionBodyEntity); + + + em.flush(); + this.policyId = newPolicyEntity.getPolicyId(); + } + + return; + } + + @SuppressWarnings("unused") + public PolicyEntity getPolicy(int policyID){ + return getPolicy(policyID,null,null); + } + public PolicyEntity getPolicy(String policyName,String scope){ + return getPolicy(-1,policyName,scope); + } + private PolicyEntity getPolicy(int policyID, String policyName,String scope){ + logger.debug("getPolicy(int policyId, String policyName) as getPolicy("+policyID+","+policyName+") called"); + if(policyID < 0 && isNullOrEmpty(policyName,scope)){ + throw new IllegalArgumentException("policyID must be at least 0 or policyName must be not null or blank"); + } + + synchronized(emLock){ + checkBeforeOperationRun(true); + //check if group exists + String policyId; + Query policyQuery; + if(!isNullOrEmpty(policyName,scope)){ + policyId = policyName; + policyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:name AND p.scope=:scope"); + policyQuery.setParameter("name", policyId); + policyQuery.setParameter("scope", scope); + } else{ + policyId = String.valueOf(policyID); + policyQuery = em.createNamedQuery("PolicyEntity.FindById"); + policyQuery.setParameter("id", policyId); + } + List<?> policyQueryList; + try{ + policyQueryList = policyQuery.getResultList(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get policy with policyQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get policy "+policyId); + } + if(policyQueryList.size() < 1){ + PolicyLogger.error("Policy does not exist with id "+policyId); + throw new PersistenceException("Group policy is being added to does not exist with id "+policyId); + } else if(policyQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one policy with the id "+policyId+" were found in the database"); + throw new PersistenceException("Somehow, more than one policy with the id "+policyId+" were found in the database"); + } + return (PolicyEntity)policyQueryList.get(0); + } + } + + @Override + public void renamePolicy(String oldPath, String newPath,String username){ +/* String[] oldPolicy = getScopeAndNameAndType(oldPath); + String[] newPolicy = getScopeAndNameAndType(newPath); + if(oldPolicy == null || newPolicy == null){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW+"Could not parse one or more of the path names: " + +oldPath+", "+newPath); + throw new IllegalArgumentException("Could not parse one or more of the path names"); + } + synchronized (emLock) { + checkBeforeOperationRun(); + + PolicyEntity existingPolicy; + boolean existingPolicyDeleted = false; + List<?> groups = null; + try{ + existingPolicy = getPolicy(newPolicy[1],newPolicy[0]); + } catch(Exception e){ + existingPolicy = null; + } + if(existingPolicy != null && !existingPolicy.isDeleted()){ + logger.error("The policy named "+existingPolicy.getPolicyName()+" already exists, cannot rename policy: "+newPolicy); + throw new IllegalArgumentException("The policy named "+existingPolicy.getPolicyName()+" already exists, cannot rename policy: "+newPolicy); + } else if(existingPolicy != null && existingPolicy.isDeleted()){ + try{ + Query getGroups = em.createQuery("SELECT g FROM GroupEntity g JOIN g.policies p WHERE p.policyId=:pid"); + + getGroups.setParameter("pid", existingPolicy.getPolicyId()); + groups = getGroups.getResultList(); + }catch(Exception e){ + groups = new LinkedList<>(); + } + for(Object o : groups){ + GroupEntity group = (GroupEntity)o; + group.removePolicyFromGroup(existingPolicy); + } + try{ + em.flush(); + }catch(Exception e){ + logger.error("Error while removing the policy from groups: "+existingPolicy.getPolicyName()); + } + try{ + em.remove(existingPolicy); + em.flush(); + }catch(Exception e){ + logger.error("Could not remove the existing deleted policy: "+existingPolicy.getPolicyName()); + } + existingPolicyDeleted = true; + //create the new policy + //for each of the groups, add the new policy + } + + PolicyEntity policyToRename; + try{ + policyToRename = getPolicy(oldPolicy[1],oldPolicy[0]); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "PolicyDBDao", "Could not get policy record to rename: " + +oldPolicy[1]); + throw new PersistenceException("Could not get policy record to rename"); + } + String policyDataString = null; + InputStream fileContentStream = null; + String policyFilePath = Paths.get(oldPath).toAbsolutePath().toString(); + //I want to try the old path first, then if it doesn't work, try the new path + for(int i=0;i<2;i++){ + try { + fileContentStream = new FileInputStream(policyFilePath); + policyDataString = IOUtils.toString(fileContentStream); + } catch (FileNotFoundException e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught FileNotFoundException on new FileInputStream("+policyFilePath+")"); + //if we can't find the oldPath, we'll try the new path + if(i == 0){ + policyFilePath = Paths.get(newPath).toAbsolutePath().toString(); + continue; + } + throw new IllegalArgumentException("The file path does not exist"); + } catch(IOException e2){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e2, "PolicyDBDao", "Caught IOException on newIOUtils.toString("+fileContentStream+")"); + throw new IllegalArgumentException("The file path cannot be read"); + } finally { + IOUtils.closeQuietly(fileContentStream); + } + if(policyDataString == null){ + throw new IllegalArgumentException("The file path cannot be read"); + } + //escape the loop + i=2; + } + policyToRename.setPolicyName(newPolicy[1]); + policyToRename.setPolicyData(policyDataString); + policyToRename.setScope(newPolicy[0]); + policyToRename.setModifiedBy(username); + if(policyToRename.getConfigurationData() != null){ + String configType = policyToRename.getConfigurationData().getConfigType(); + policyToRename.getConfigurationData().setConfigurationName(getConfigFile(newPolicy[1], configType)); + policyToRename.getConfigurationData().setModifiedBy(username); + } + if(policyToRename.getActionBodyEntity() != null){ + String newActionName = newPolicy[0]+"."+removeFileExtension(newPolicy[1])+".json"; + policyToRename.getActionBodyEntity().setActionBodyName(newActionName); + policyToRename.getActionBodyEntity().setModifiedBy(username); + } + if(existingPolicyDeleted){ + for(Object o : groups){ + + GroupEntity group = (GroupEntity)o; + group.addPolicyToGroup(policyToRename); + } + } + em.flush(); + this.policyId = policyToRename.getPolicyId(); + this.newGroupId = oldPath; + }*/ + } + + @Override + public GroupEntity getGroup(long groupKey){ + logger.debug("getGroup(int groupKey) as getGroup("+groupKey+") called"); + if(groupKey < 0){ + throw new IllegalArgumentException("groupKey must be at least 0"); + } + synchronized(emLock){ + checkBeforeOperationRun(true); + //check if group exists + Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupKey=:groupKey"); + groupQuery.setParameter("groupKey", groupKey); + List<?> groupQueryList; + try{ + groupQueryList = groupQuery.getResultList(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get group with groupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get group "+groupKey); + } + if(groupQueryList.size() < 1){ + PolicyLogger.error("Group does not exist with groupKey "+groupKey); + throw new PersistenceException("Group does not exist with groupKey "+groupKey); + } else if(groupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the groupKey "+groupKey+" were found in the database"); + throw new PersistenceException("Somehow, more than one group with the groupKey "+groupKey+" were found in the database"); + } + return (GroupEntity)groupQueryList.get(0); + } + } + + @Override + public GroupEntity getGroup(String groupId){ + logger.debug("getGroup(String groupId) as getGroup("+groupId+") called"); + if(isNullOrEmpty(groupId)){ + throw new IllegalArgumentException("groupId must not be null or empty"); + } + synchronized(emLock){ + checkBeforeOperationRun(true); + //check if group exists + Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId"); + groupQuery.setParameter("groupId", groupId); + List<?> groupQueryList; + try{ + groupQueryList = groupQuery.getResultList(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get group with groupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get group "+groupId); + } + if(groupQueryList.size() < 1){ + PolicyLogger.error("Group does not exist with id "+groupId); + throw new PersistenceException("Group does not exist with id "+groupId); + } else if(groupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the id "+groupId+" were found in the database"); + throw new PersistenceException("Somehow, more than one group with the id "+groupId+" were found in the database"); + } + return (GroupEntity)groupQueryList.get(0); + } + } + @Override + public List<?> getPdpsInGroup(long groupKey){ + logger.debug("getPdpsInGroup(int groupKey) as getPdpsInGroup("+groupKey+") called"); + if(groupKey < 0){ + throw new IllegalArgumentException("groupId must not be < 0"); + } + synchronized(emLock){ + checkBeforeOperationRun(true); + Query pdpsQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group"); + pdpsQuery.setParameter("group", getGroup(groupKey)); + return pdpsQuery.getResultList(); + } + } + @Override + public PdpEntity getPdp(long pdpKey){ + logger.debug("getPdp(int pdpKey) as getPdp("+pdpKey+") called"); + if(pdpKey < 0){ + throw new IllegalArgumentException("pdpKey must be at least 0"); + } + synchronized(emLock){ + checkBeforeOperationRun(true); + //check if group exists + Query pdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpKey=:pdpKey"); + pdpQuery.setParameter("pdpKey", pdpKey); + List<?> pdpQueryList; + try{ + pdpQueryList = pdpQuery.getResultList(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get pdp with pdpQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get pdp "+pdpKey); + } + if(pdpQueryList.size() < 1){ + PolicyLogger.error("Pdp does not exist with pdpKey "+pdpKey); + throw new PersistenceException("Pdp does not exist with pdpKey "+pdpKey); + } else if(pdpQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one pdp with the pdpKey "+pdpKey+" were found in the database"); + throw new PersistenceException("Somehow, more than one pdp with the pdpKey "+pdpKey+" were found in the database"); + } + return (PdpEntity)pdpQueryList.get(0); + } + } + + public void deletePolicy(String policyToDeletes){ + /*synchronized(emLock){ + checkBeforeOperationRun(); + logger.debug("deletePolicy(String policyToDeletes) as deletePolicy("+policyToDeletes+") called"); + String[] scopeNameAndType = getScopeAndNameAndType(policyToDeletes); + if(scopeNameAndType == null){ + throw new IllegalArgumentException("Could not parse file path"); + } + String realScope = scopeNameAndType[0]; + String realName = scopeNameAndType[1]; + Query deletePolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName AND p.deleted=:deleted"); + deletePolicyQuery.setParameter("scope",realScope); + deletePolicyQuery.setParameter("policyName", realName); + deletePolicyQuery.setParameter("deleted", false); + List<?> deletePolicyQueryList = deletePolicyQuery.getResultList(); + if(deletePolicyQueryList.size() < 1){ + logger.warn("The policy being deleted could not be found."); + return; + } else if(deletePolicyQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one policy with the same scope, name, and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one policy with the same scope, name, and deleted status were found in the database"); + } else { + PolicyEntity policyToDelete = (PolicyEntity)deletePolicyQueryList.get(0); + policyToDelete.setDeleted(true); + if(policyToDelete.getConfigurationData() != null){ + ConfigurationDataEntity cde = em.find(ConfigurationDataEntity.class,policyToDelete.getConfigurationData().getConfigurationDataId()); + if(cde != null){ + cde.setDeleted(true); + } + } + if(policyToDelete.getActionBodyEntity() != null){ + ActionBodyEntity abe = em.find(ActionBodyEntity.class,policyToDelete.getActionBodyEntity().getActionBodyId()); + if(abe != null){ + abe.setDeleted(true); + } + } + + em.flush(); + this.policyId = policyToDelete.getPolicyId(); + + } + } +*/ + } + + + @Override + public boolean isTransactionOpen() { + logger.debug("isTransactionOpen() as isTransactionOpen() called"); + synchronized(emLock){ + return em.isOpen() && em.getTransaction().isActive(); + } + } + + + @Override + public void clonePolicy(String oldPolicyPath, String newPolicyPath, String username){ + /*String[] oldPolicyData = getScopeAndNameAndType(oldPolicyPath); + String[] newPolicyData = getScopeAndNameAndType(newPolicyPath); + if(oldPolicyData == null || newPolicyData == null){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW+"Could not parse one or more of the path names: " + +oldPolicyPath+", "+newPolicyPath); + throw new IllegalArgumentException("Could not parse the oldPolicyPath or newPolicyPath"); + } + PolicyEntity oldPolicy; + try{ + oldPolicy = getPolicy(oldPolicyData[1],oldPolicyData[0]); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "PolicyDBDao", "Could not get policy record to clone: " + +oldPolicyData[1]); + throw new PersistenceException("Could not get policy record to clone"); + } + ConfigurationDataEntity clonedConfig = null; + if(oldPolicy.getConfigurationData() != null){ + clonedConfig = new ConfigurationDataEntity(); + em.persist(clonedConfig); + clonedConfig.setConfigBody(oldPolicy.getConfigurationData().getConfigBody()); + clonedConfig.setConfigType(oldPolicy.getConfigurationData().getConfigType()); + clonedConfig.setCreatedBy(username); + clonedConfig.setConfigurationName(getConfigFile(newPolicyData[1], oldPolicy.getConfigurationData().getConfigType())); + clonedConfig.setDescription(oldPolicy.getConfigurationData().getDescription()); + clonedConfig.setModifiedBy(username); + em.flush(); + } + ActionBodyEntity clonedAction = null; + if(oldPolicy.getActionBodyEntity() != null){ + clonedAction = new ActionBodyEntity(); + em.persist(clonedAction); + clonedAction.setActionBody(oldPolicy.getActionBodyEntity().getActionBody()); + clonedAction.setActionBodyName(newPolicyData[0]+"."+newPolicyData[1]+".json"); + clonedAction.setCreatedBy(username); + clonedAction.setModifiedBy(username); + em.flush(); + } + +*/ + } + + private String processConfigPath(String configPath){ + String webappsPath = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_WEBAPPS); + if(webappsPath == null){ + logger.error("Webapps property does not exist"); + throw new IllegalArgumentException("Webapps property does not exist"); + } + configPath = configPath.replace("$URL", webappsPath); + //make sure the correct slashes are in + try{ + configPath = Paths.get(configPath).toString(); + } catch(InvalidPathException e){ + logger.error("Invalid config path: "+configPath); + throw new IllegalArgumentException("Invalid config path: "+configPath); + } + return configPath; + } + private String readConfigFile(String configPath){ + String configDataString = null; + InputStream configContentStream = null; + try { + configContentStream = new FileInputStream(configPath); + configDataString = IOUtils.toString(configContentStream); + } catch (FileNotFoundException e) { + logger.error("Caught FileNotFoundException on new FileInputStream("+configPath+")",e); + throw new IllegalArgumentException("The config file path does not exist"); + } catch(IOException e2){ + logger.error("Caught IOException on newIOUtils.toString("+configContentStream+")",e2); + throw new IllegalArgumentException("The config file path cannot be read"); + } finally { + IOUtils.closeQuietly(configContentStream); + } + if(configDataString == null){ + throw new IllegalArgumentException("The config file path cannot be read"); + } + return configDataString; + } + + @Override + public void createPolicy(Policy policy, String username){ + InputStream policyXmlStream = null; + try{ + logger.debug("createPolicy(PolicyRestAdapter policy, String username) as createPolicy("+policy+","+username+") called"); + String policyScope = policy.policyAdapter.getDomainDir().replace(File.separator, "."); + //Does not need to be XACMLPolicyWriterWithPapNotify since it is already in the PAP + //and this transaction is intercepted up stream. + String policyDataString; + try { + policyXmlStream = XACMLPolicyWriter.getXmlAsInputStream((PolicyType)policy.getCorrectPolicyDataObject()); + policyDataString = IOUtils.toString(policyXmlStream); + } catch (IOException e) { + policyDataString = "could not read"; + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught IOException on IOUtils.toString("+policyXmlStream+")"); + throw new IllegalArgumentException("Cannot parse the policy xml from the PolicyRestAdapter."); + } + IOUtils.closeQuietly(policyXmlStream); + String configPath = ""; + if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Config")) { + configPath = evaluateXPath("/Policy/Rule/AdviceExpressions/AdviceExpression[contains(@AdviceId,'ID')]/AttributeAssignmentExpression[@AttributeId='URLID']/AttributeValue/text()", policyDataString); + } else if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Action")) { + configPath = evaluateXPath("/Policy/Rule/ObligationExpressions/ObligationExpression[contains(@ObligationId, " +policy.policyAdapter.getActionAttribute()+ ")]/AttributeAssignmentExpression[@AttributeId='body']/AttributeValue/text()", policyDataString); + } + + String prefix = null; + if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Config")) { + + prefix = configPath.substring(configPath.indexOf(policyScope+".")+policyScope.concat(".").length(), configPath.indexOf(policy.policyAdapter.getPolicyName())); + if(isNullOrEmpty(policy.policyAdapter.getConfigBodyData())){ + String configData = ""; + try{ + String newConfigPath = configPath; + try{ + newConfigPath = processConfigPath(newConfigPath); + }catch(Exception e2){ + logger.error("Could not process config path: "+newConfigPath,e2); + } + configData = readConfigFile(newConfigPath); + }catch(Exception e){ + logger.error("Could not read config body data for "+configPath,e); + } + policy.policyAdapter.setConfigBodyData(configData); + } + } else if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Action")) { + prefix = "Action_"; + } else if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Decision")) { + prefix = "Decision_"; + } + + if(!(policy.policyAdapter.getData() instanceof PolicyType)){ + PolicyLogger.error("The data field is not an instance of PolicyType"); + throw new IllegalArgumentException("The data field is not an instance of PolicyType"); + } + String finalName = policyScope + "." + prefix+policy.policyAdapter.getPolicyName()+"."+((PolicyType)policy.policyAdapter.getData()).getVersion()+".xml"; + if(policy.policyAdapter.getConfigType() == null || policy.policyAdapter.getConfigType().equals("")){ + //get the config file extension + String ext = ""; + if (configPath != null) { + if (!configPath.equalsIgnoreCase("")) { + ext = configPath.substring(configPath.lastIndexOf('.'), configPath.length());; + } + } + + if(ext.contains("txt")){ + policy.policyAdapter.setConfigType(OTHER_CONFIG); + } else if(ext.contains("json")){ + policy.policyAdapter.setConfigType(JSON_CONFIG); + } else if(ext.contains("xml")){ + policy.policyAdapter.setConfigType(XML_CONFIG); + } else if(ext.contains("properties")){ + policy.policyAdapter.setConfigType(PROPERTIES_CONFIG); + } else { + if (policy.policyAdapter.getPolicyType().equalsIgnoreCase("Action")){ + policy.policyAdapter.setConfigType(JSON_CONFIG); + } + } + } + + createPolicy(policy.policyAdapter, username, policyScope,finalName,policyDataString); + }finally{ + if(policyXmlStream != null){ + try { + policyXmlStream.close(); + } catch (IOException e) { + logger.error("Exception Occured while closing input stream"+e); + } + } + } + } + + @Override + public void close(){ + synchronized(emLock){ + if(em.isOpen()){ + if(em.getTransaction().isActive()){ + em.getTransaction().rollback(); + } + em.close(); + } + if(transactionTimer instanceof Thread){ + transactionTimer.interrupt(); + } + } + } + + + + @Override + public void createGroup(String groupId, String groupName, String groupDescription, String username) { + logger.debug("deletePolicy(String policyToDeletes) as createGroup("+groupId+", "+groupName+", "+groupDescription+") called"); + if(isNullOrEmpty(groupId, groupName, username)){ + throw new IllegalArgumentException("groupId, groupName, and username must not be null or empty"); + } + if(!(groupDescription instanceof String)){ + groupDescription = ""; + } + + synchronized(emLock){ + checkBeforeOperationRun(); + Query checkGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + checkGroupQuery.setParameter("groupId", groupId); + checkGroupQuery.setParameter("deleted", false); + List<?> checkGroupQueryList; + try{ + checkGroupQueryList = checkGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on checkGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check for existing group"); + } + if(checkGroupQueryList.size() > 0){ + PolicyLogger.error("The group being added already exists with id "+groupId); + throw new PersistenceException("The group being added already exists with id "+groupId); + } + GroupEntity newGroup = new GroupEntity(); + em.persist(newGroup); + newGroup.setCreatedBy(username); + newGroup.setModifiedBy(username); + newGroup.setGroupName(groupName); + newGroup.setGroupId(groupId); + newGroup.setDescription(groupDescription); + + em.flush(); + this.groupId = newGroup.getGroupKey(); + } + } + + @Override + public void updateGroup(OnapPDPGroup group, String username){ + logger.debug("updateGroup(PDPGroup group) as updateGroup("+group+","+username+") called"); + if(group == null){ + throw new IllegalArgumentException("PDPGroup group must not be null"); + } + if(isNullOrEmpty(group.getId(), username)){ + throw new IllegalArgumentException("group.getId() and username must not be null or empty"); + } + + synchronized(emLock){ + checkBeforeOperationRun(); + Query getGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + getGroupQuery.setParameter("groupId", group.getId()); + getGroupQuery.setParameter("deleted", false); + List<?> getGroupQueryList; + try{ + getGroupQueryList = getGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on getGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get group "+group.getId()+" for editing"); + } + if(getGroupQueryList.size() < 1){ + PolicyLogger.error("The group cannot be found to update with id "+group.getId()); + throw new PersistenceException("The group cannot be found to update with id "+group.getId()); + } else if(getGroupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the same id "+group.getId()+" and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one group with the same id "+group.getId()+" and deleted status were found in the database"); + } + GroupEntity groupToUpdate = (GroupEntity)getGroupQueryList.get(0); + if(!stringEquals(groupToUpdate.getModifiedBy(), username)){ + groupToUpdate.setModifiedBy(username); + } + if(group.getDescription() != null && !stringEquals(group.getDescription(),groupToUpdate.getDescription())){ + groupToUpdate.setDescription(group.getDescription()); + } + //let's find out what policies have been deleted + StdPDPGroup oldGroup = null; + try { + oldGroup = (StdPDPGroup) papEngine.getGroup(group.getId()); + } catch (PAPException e1) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e1, "PolicyDBDao", "We cannot get the group from the papEngine to delete policies"); + } + if(oldGroup == null){ + PolicyLogger.error("We cannot get the group from the papEngine to delete policies"); + } else { + + Set<String> newPolicySet = new HashSet<>(group.getPolicies().size()); + //a multiple of n runtime is faster than n^2, so I am using a hashset to do the comparison + for(PDPPolicy pol: group.getPolicies()){ + newPolicySet.add(pol.getId()); + } + for(PDPPolicy pol : oldGroup.getPolicies()){ + //should be fast since getPolicies uses a HashSet in StdPDPGroup + if(!newPolicySet.contains(pol.getId())){ + String[] scopeAndName = getNameScopeAndVersionFromPdpPolicy(pol.getId()); + PolicyEntity policyToDelete; + try{ + policyToDelete = getPolicy(scopeAndName[0],scopeAndName[1]); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Could not get policy to remove: "+pol.getId()); + throw new PersistenceException("Could not get policy to remove: "+pol.getId()); + } + groupToUpdate.getPolicies().remove(policyToDelete); + + } + } + } + if(group.getName() != null && !stringEquals(group.getName(),groupToUpdate.getgroupName())){ + //we need to check if the new id exists in the database + String newGroupId = createNewPDPGroupId(group.getName()); + Query checkGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + checkGroupQuery.setParameter("groupId", newGroupId); + checkGroupQuery.setParameter("deleted", false); + List<?> checkGroupQueryList; + try{ + checkGroupQueryList = checkGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on checkGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check for existing group"); + } + if(checkGroupQueryList.size() != 0){ + PolicyLogger.error("The new group name already exists, group id "+newGroupId); + throw new PersistenceException("The new group name already exists, group id "+newGroupId); + } + groupToUpdate.setGroupId(newGroupId); + groupToUpdate.setGroupName(group.getName()); + this.newGroupId = group.getId(); + } + + em.flush(); + this.groupId = groupToUpdate.getGroupKey(); + } + } + + @Override + public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) { + logger.debug("addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) as addPdpToGroup("+pdpID+", "+groupID+", "+pdpName+", "+pdpDescription+", "+pdpJmxPort+", "+username+") called"); + if(isNullOrEmpty(pdpID, groupID,pdpName,username)){ + throw new IllegalArgumentException("pdpID, groupID, pdpName, and username must not be null or empty"); + } + if(!(pdpDescription instanceof String)){ + pdpDescription = ""; + } + synchronized(emLock){ + checkBeforeOperationRun(); + Query checkGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + checkGroupQuery.setParameter("groupId", groupID); + checkGroupQuery.setParameter("deleted", false); + List<?> checkGroupQueryList; + try{ + checkGroupQueryList = checkGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check for existing group on checkGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check for existing group"); + } + if(checkGroupQueryList.size() != 1){ + PolicyLogger.error("The group does not exist"); + throw new PersistenceException("The group does not exist"); + } + Query checkDuplicateQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted"); + checkDuplicateQuery.setParameter("pdpId", pdpID); + checkDuplicateQuery.setParameter("deleted", false); + List<?> checkDuplicateList; + try{ + checkDuplicateList = checkDuplicateQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check for duplicate PDP "+pdpID+" on checkDuplicateQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check for duplicate PDP "+pdpID); + } + PdpEntity newPdp; + if(checkDuplicateList.size() > 0){ + logger.warn("PDP already exists with id "+pdpID); + newPdp = (PdpEntity)checkDuplicateList.get(0); + } else { + newPdp = new PdpEntity(); + em.persist(newPdp); + } + + newPdp.setCreatedBy(username); + newPdp.setDeleted(false); + newPdp.setDescription(pdpDescription); + newPdp.setGroup((GroupEntity)checkGroupQueryList.get(0)); + newPdp.setJmxPort(pdpJmxPort); + newPdp.setModifiedBy(username); + newPdp.setPdpId(pdpID); + newPdp.setPdpName(pdpName); + + em.flush(); + this.pdpId = newPdp.getPdpKey(); + + } + } + + + @Override + public void updatePdp(OnapPDP pdp, String username){ + logger.debug("updatePdp(PDP pdp, String username) as updatePdp("+pdp+","+username+") called"); + if(pdp == null){ + throw new IllegalArgumentException("PDP pdp must not be null"); + } + if(isNullOrEmpty(pdp.getId(),username)){ + throw new IllegalArgumentException("pdp.getId() and username must not be null or empty"); + } + + synchronized(emLock){ + checkBeforeOperationRun(); + Query getPdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted"); + getPdpQuery.setParameter("pdpId", pdp.getId()); + getPdpQuery.setParameter("deleted", false); + List<?> getPdpQueryList; + try{ + getPdpQueryList = getPdpQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on getPdpQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get PDP "+pdp.getId()); + } + if(getPdpQueryList.size() < 1){ + PolicyLogger.error("The pdp cannot be found to update with id "+pdp.getId()); + throw new PersistenceException("The pdp cannot be found to update with id "+pdp.getId()); + } else if(getPdpQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one pdp with the same id "+pdp.getId()+" and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one pdp with the same id "+pdp.getId()+" and deleted status were found in the database"); + } + PdpEntity pdpToUpdate = (PdpEntity)getPdpQueryList.get(0); + if(!stringEquals(pdpToUpdate.getModifiedBy(), username)){ + pdpToUpdate.setModifiedBy(username); + } + if(pdp.getDescription() != null && !stringEquals(pdp.getDescription(),pdpToUpdate.getDescription())){ + pdpToUpdate.setDescription(pdp.getDescription()); + } + if(pdp.getName() != null && !stringEquals(pdp.getName(),pdpToUpdate.getPdpName())){ + pdpToUpdate.setPdpName(pdp.getName()); + } + if(pdp.getJmxPort() != null && !pdp.getJmxPort().equals(pdpToUpdate.getJmxPort())){ + pdpToUpdate.setJmxPort(pdp.getJmxPort()); + } + + em.flush(); + this.pdpId = pdpToUpdate.getPdpKey(); + } + } + + @Override + public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username){ + logger.debug("movePdp(PDP pdp, PDPGroup group, String username) as movePdp("+pdp+","+group+","+username+") called"); + if(pdp == null || group == null){ + throw new IllegalArgumentException("PDP pdp and PDPGroup group must not be null"); + } + if(isNullOrEmpty(username,pdp.getId(),group.getId())){ + throw new IllegalArgumentException("pdp.getId(), group.getId(), and username must not be null or empty"); + } + + synchronized(emLock){ + checkBeforeOperationRun(); + //check if pdp exists + Query getPdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted"); + getPdpQuery.setParameter("pdpId", pdp.getId()); + getPdpQuery.setParameter("deleted", false); + List<?> getPdpQueryList; + try{ + getPdpQueryList = getPdpQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on getPdpQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get pdp to move with id "+pdp.getId()); + } + if(getPdpQueryList.size() < 1){ + PolicyLogger.error("The pdp cannot be found to move with id "+pdp.getId()); + throw new PersistenceException("The pdp cannot be found to move with id "+pdp.getId()); + } else if(getPdpQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one pdp with the same id "+pdp.getId()+" and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one pdp with the same id "+pdp.getId()+" and deleted status were found in the database"); + } + + //check if new group exists + Query checkGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + checkGroupQuery.setParameter("groupId", group.getId()); + checkGroupQuery.setParameter("deleted", false); + List<?> checkGroupQueryList; + try{ + checkGroupQueryList = checkGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get group on checkGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get new group "+group.getId()); + } + if(checkGroupQueryList.size() != 1){ + PolicyLogger.error("The group "+group.getId()+" does not exist"); + throw new PersistenceException("The group "+group.getId()+" does not exist"); + } + GroupEntity groupToMoveInto = (GroupEntity)checkGroupQueryList.get(0); + PdpEntity pdpToUpdate = (PdpEntity)getPdpQueryList.get(0); + pdpToUpdate.setGroup(groupToMoveInto); + if(!stringEquals(pdpToUpdate.getModifiedBy(), username)){ + pdpToUpdate.setModifiedBy(username); + } + + em.flush(); + this.pdpId = pdpToUpdate.getPdpKey(); + } + } + + @Override + public void changeDefaultGroup(OnapPDPGroup group, String username){ + logger.debug("changeDefaultGroup(PDPGroup group, String username) as changeDefaultGroup("+group+","+username+") called"); + if(group == null){ + throw new IllegalArgumentException("PDPGroup group must not be null"); + } + if(isNullOrEmpty(group.getId(),username)){ + throw new IllegalArgumentException("group.getId() and username must not be null or empty"); + } + + synchronized(emLock){ + checkBeforeOperationRun(); + Query getGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + getGroupQuery.setParameter("groupId", group.getId()); + getGroupQuery.setParameter("deleted", false); + List<?> getGroupQueryList; + try{ + getGroupQueryList = getGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on getGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get group "+group.getId()); + } + if(getGroupQueryList.size() < 1){ + PolicyLogger.error("The group cannot be found to set default with id "+group.getId()); + throw new PersistenceException("The group cannot be found to set default with id "+group.getId()); + } else if(getGroupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the same id "+group.getId()+" and deleted status were found in the database"); + throw new PersistenceException("Somehow, more than one group with the same id "+group.getId()+" and deleted status were found in the database"); + } + GroupEntity newDefaultGroup = (GroupEntity)getGroupQueryList.get(0); + newDefaultGroup.setDefaultGroup(true); + if(!stringEquals(newDefaultGroup.getModifiedBy(), username)){ + newDefaultGroup.setModifiedBy(username); + } + + em.flush(); + this.groupId = newDefaultGroup.getGroupKey(); + Query setAllGroupsNotDefault = em.createQuery("UPDATE GroupEntity g SET g.defaultGroup=:defaultGroup WHERE g.deleted=:deleted AND g.groupKey<>:groupKey"); + //not going to set modified by for all groups + setAllGroupsNotDefault.setParameter("defaultGroup", false); + setAllGroupsNotDefault.setParameter("deleted", false); + setAllGroupsNotDefault.setParameter("groupKey", newDefaultGroup.getGroupKey()); + try{ + logger.info("set " + setAllGroupsNotDefault.executeUpdate() + " groups as not default"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception on setAllGroupsNotDefault.executeUpdate()"); + throw new PersistenceException("Could not set all other groups default to false"); + } + + em.flush(); + } + } + + + @Override + public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username) throws PAPException { + logger.debug("deleteGroup(PDPGroup group, PDPGroup moveToGroup, String username) as deleteGroup("+group+", "+moveToGroup+","+username+") called"); + if(group == null){ + throw new IllegalArgumentException("PDPGroup group cannot be null"); + } + if(isNullOrEmpty(username,group.getId())){ + throw new IllegalArgumentException("group.getId() and and username must not be null or empty"); + } + + if(group.isDefaultGroup()){ + PolicyLogger.error("The default group "+group.getId()+" was attempted to be deleted. It cannot be."); + throw new PAPException("You cannot delete the default group."); + } + synchronized(emLock){ + checkBeforeOperationRun(); + Query deleteGroupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + deleteGroupQuery.setParameter("groupId", group.getId()); + deleteGroupQuery.setParameter("deleted", false); + List<?> deleteGroupQueryList; + try{ + deleteGroupQueryList = deleteGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check if group exists deleteGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check if group exists"); + } + if(deleteGroupQueryList.size() < 1){ + logger.warn("The group could not be found with id " + group.getId()); + return; + } else if(deleteGroupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the id "+group.getId()+" were found in the database that are not deleted"); + throw new PersistenceException("Somehow, more than one group with the id "+group.getId()+" were found in the database that are not deleted"); + } + + Query pdpsInGroupQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.groupEntity=:group and p.deleted=:deleted"); + pdpsInGroupQuery.setParameter("group", ((GroupEntity)deleteGroupQueryList.get(0))); + pdpsInGroupQuery.setParameter("deleted", false); + List<?> pdpsInGroupList; + try{ + pdpsInGroupList = pdpsInGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to get PDPs in group on pdpsInGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to get PDPs in group"); + } + if(pdpsInGroupList.size() > 0){ + if(moveToGroup != null){ + Query checkMoveToGroupQuery = em.createQuery("SELECT o FROM GroupEntity o WHERE o.groupId=:groupId AND o.deleted=:deleted"); + checkMoveToGroupQuery.setParameter("groupId", moveToGroup.getId()); + checkMoveToGroupQuery.setParameter("deleted", false); + List<?> checkMoveToGroupList; + try{ + checkMoveToGroupList = checkMoveToGroupQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check if group exists checkMoveToGroupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check if group exists"); + } + if(checkMoveToGroupList.size() < 1){ + PolicyLogger.error("The group could not be found with id " + moveToGroup.getId()); + throw new PersistenceException("The group could not be found with id " + moveToGroup.getId()); + } else if(checkMoveToGroupList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the id "+moveToGroup.getId()+" were found in the database that are not deleted"); + throw new PersistenceException("Somehow, more than one group with the id "+moveToGroup.getId()+" were found in the database that are not deleted"); + } else { + GroupEntity newGroup = (GroupEntity)checkMoveToGroupList.get(0); + for(Object pdpObject : pdpsInGroupList){ + PdpEntity pdp = (PdpEntity)pdpObject; + pdp.setGroup(newGroup); + if(!stringEquals(pdp.getModifiedBy(),username)){ + pdp.setModifiedBy(username); + } + try{ + + em.flush(); + this.newGroupId = newGroup.getGroupId(); + } catch(PersistenceException e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught PersistenceException trying to set pdp group to null on em.flush()"); + throw new PersistenceException("Query failed trying to set pdp group to "); + } + } + } + } else { + PolicyLogger.error("Group "+group.getId()+" is trying to be delted with PDPs. No group was provided to move them to"); + throw new PAPException("Group has PDPs. Must provide a group for them to move to"); + } + } + + //delete group here + GroupEntity groupToDelete = (GroupEntity)deleteGroupQueryList.get(0); + groupToDelete.setDeleted(true); + if(!stringEquals(groupToDelete.getModifiedBy(), username)){ + groupToDelete.setModifiedBy(username); + } + em.flush(); + this.groupId = groupToDelete.getGroupKey(); + } + } + + @Override + public void addPolicyToGroup(String groupID, String policyID, String username) { + logger.debug("addPolicyToGroup(String groupID, String policyID, String username) as addPolicyToGroup("+groupID+", "+policyID+","+username+") called"); + if(isNullOrEmpty(groupID, policyID, username)){ + throw new IllegalArgumentException("groupID, policyID, and username must not be null or empty"); + } + synchronized(emLock){ + checkBeforeOperationRun(); + //check if group exists + Query groupQuery = em.createQuery("SELECT g FROM GroupEntity g WHERE g.groupId=:groupId AND g.deleted=:deleted"); + groupQuery.setParameter("groupId", groupID); + groupQuery.setParameter("deleted", false); + List<?> groupQueryList; + try{ + groupQueryList = groupQuery.getResultList(); + }catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check if group exists groupQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check if group "+groupID+" exists"); + } + if(groupQueryList.size() < 1){ + PolicyLogger.error("Group policy is being added to does not exist with id "+groupID); + throw new PersistenceException("Group policy is being added to does not exist with id "+groupID); + } else if(groupQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one group with the id "+groupID+" were found in the database that are not deleted"); + throw new PersistenceException("Somehow, more than one group with the id "+groupID+" were found in the database that are not deleted"); + } + //we need to convert the form of the policy id that is used groups into the form that is used + //for the database. (com.Config_mypol.1.xml) to (Config_mypol.xml) + String[] policyNameScopeAndVersion = getNameScopeAndVersionFromPdpPolicy(policyID); + Query policyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:policyName AND p.scope=:scope AND p.deleted=:deleted"); + policyQuery.setParameter("policyName", policyNameScopeAndVersion[0]); + policyQuery.setParameter("scope", policyNameScopeAndVersion[1]); + policyQuery.setParameter("deleted", false); + List<?> policyQueryList; + try{ + policyQueryList = policyQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check if policy exists policyQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check if policy "+policyNameScopeAndVersion[0]+" exists"); + } + if(policyQueryList.size() < 1){ + PolicyLogger.error("Policy being added to the group does not exist with policy id "+policyNameScopeAndVersion[0]); + throw new PersistenceException("Policy being added to the group does not exist with policy id "+policyNameScopeAndVersion[0]); + } else if(policyQueryList.size() > 1){ + PolicyLogger.error("Somehow, more than one policy with the id "+policyNameScopeAndVersion[0]+" were found in the database that are not deleted"); + throw new PersistenceException("Somehow, more than one group with the id "+policyNameScopeAndVersion[0]+" were found in the database that are not deleted"); + } + GroupEntity group = (GroupEntity)groupQueryList.get(0); + PolicyEntity policy = (PolicyEntity)policyQueryList.get(0); + Iterator<PolicyEntity> policyIt = group.getPolicies().iterator(); + String policyName = getPolicyNameAndVersionFromPolicyFileName(policy.getPolicyName())[0]; + try{ + while(policyIt.hasNext()){ + PolicyEntity pol = policyIt.next(); + if(getPolicyNameAndVersionFromPolicyFileName(pol.getPolicyName())[0].equals(policyName)){ + policyIt.remove(); + } + } + }catch(Exception e){ + PolicyLogger.error("Could not delete old versions for policy "+policy.getPolicyName()+", ID: "+policy.getPolicyId()); + } + group.addPolicyToGroup(policy); + em.flush(); + } + } + + //this means delete pdp not just remove from group + @Override + public void removePdpFromGroup(String pdpID, String username) { + logger.debug("removePdpFromGroup(String pdpID, String username) as removePdpFromGroup("+pdpID+","+username+") called"); + if(isNullOrEmpty(pdpID,username)){ + throw new IllegalArgumentException("pdpID and username must not be null or empty"); + } + synchronized(emLock){ + checkBeforeOperationRun(); + Query pdpQuery = em.createQuery("SELECT p FROM PdpEntity p WHERE p.pdpId=:pdpId AND p.deleted=:deleted"); + pdpQuery.setParameter("pdpId", pdpID); + pdpQuery.setParameter("deleted", false); + List<?> pdpList; + try{ + pdpList = pdpQuery.getResultList(); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "PolicyDBDao", "Caught Exception trying to check if pdp exists pdpQuery.getResultList()"); + throw new PersistenceException("Query failed trying to check if pdp "+pdpID+" exists"); + } + if(pdpList.size() > 1){ + PolicyLogger.error("Somehow, more than one pdp with the id "+pdpID+" were found in the database that are not deleted"); + throw new PersistenceException("Somehow, more than one pdp with the id "+pdpID+" were found in the database that are not deleted"); + } else if(pdpList.size() < 1){ + PolicyLogger.error("Pdp being removed does not exist with id "+pdpID); + return; + } + PdpEntity pdp = (PdpEntity)pdpList.get(0); + pdp.setGroup(null); + if(!stringEquals(pdp.getModifiedBy(),username)){ + pdp.setModifiedBy(username); + } + pdp.setDeleted(true); + + em.flush(); + this.pdpId = pdp.getPdpKey(); + } + } + } + + private PolicyDBDao(){ + + } + + public static PolicyDBDaoTestClass getPolicyDBDaoTestClass(){ + return new PolicyDBDao().new PolicyDBDaoTestClass(); + } + + final class PolicyDBDaoTestClass { + String getConfigFile(String filename, String scope, PolicyRestAdapter policy){ + return scope + "." + PolicyDBDao.this.getConfigFile(filename, policy); + } + String computeScope(String fullPath, String pathToExclude){ + return PolicyDBDao.computeScope(fullPath, pathToExclude); + } + String encryptPassword(String password) throws Exception{ + return PolicyDBDao.encryptPassword(password); + } + String decryptPassword(String password) throws Exception{ + return PolicyDBDao.decryptPassword(password); + } + String getDescriptionFromXacml(String xacmlData){ + return PolicyDBDao.getDescriptionFromXacml(xacmlData); + } + String[] getPolicyNameAndVersionFromPolicyFileName(String originalPolicyName){ + return PolicyDBDao.this.getPolicyNameAndVersionFromPolicyFileName(originalPolicyName); + } + } + +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java new file mode 100644 index 000000000..f5a22bcd4 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/PolicyDBDaoTransaction.java @@ -0,0 +1,188 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; + +import java.util.List; + +import javax.persistence.PersistenceException; + +import org.onap.policy.rest.jpa.GroupEntity; +import org.onap.policy.rest.jpa.PdpEntity; +import org.onap.policy.xacml.api.pap.OnapPDP; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; + +import com.att.research.xacml.api.pap.PAPException; + +public interface PolicyDBDaoTransaction { + + /** + * Commits (makes permanent) the current transaction. Also, notifies other PolicyDBDao instances on other PAP servers of the update. + * @throws IllegalStateException if the PolicyDBDao transaction has not been used or has been committed already. + * @throws PersistenceException if the commit fails for some reason + */ + public void commitTransaction(); + + /** + * Create or update a policy + * @param policy A Policy object representing the policy to store or update + * @param username A string of the username you want to be stored for doing this operation + * @throws IllegalStateException If a transaction is open that has not yet been committed + * @throws PersistenceException If a database error occurs + * @throws IllegalArgumentException If the Policy's PolicyRestAdapter contains incorrect data. + */ + public void createPolicy(Policy policy, String username) throws IllegalStateException, PersistenceException, IllegalArgumentException; + + /** + * Check if the PolicyDBDaoTransaction is currently open + * @return False if the PolicyDBDao transaction has not been used or has been committed already, true if it is open. + */ + public boolean isTransactionOpen(); + + + + /** + * Delete an existing policy + * @param policyToDelete The file path of the policy to delete + * @throws IllegalArgumentException If the file path given can not be parsed + * @throws IllegalStateException If a transaction is open that has not yet been committed + * @throws PersistenceException If a database error occurs + */ + public void deletePolicy(String policyToDelete) throws IllegalStateException, PersistenceException, IllegalArgumentException; + + /** + * Rollback (undo) the current transaction. + */ + public void rollbackTransaction(); + + /** + * Close the PolicyDBDaoTransaction without rolling back or doing anything. Just used to close the EntityManager + */ + public void close(); + + + /** + * Create a new PDP group in the database + * @param groupID The ID to name the new group (use PolicyDBDao.createNewPDPGroupId) + * @param groupName The name to use for the new group + * @param groupDescription Description of the new group (optional) + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void createGroup(String groupID, String groupName, String groupDescription, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Updates a group in the database with a new name of description + * @param group The group with updated information. The id must match an existing group, but the name and description can be changed. + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs or if the group can not be found + */ + public void updateGroup(OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Updates a PDP in the database with new information + * @param pdp The PDP to update + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs or if the pdp can not be found + */ + public void updatePdp(OnapPDP pdp, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Change the default group in the database to the group provided. + * @param group The new group which should be set as default in the database + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void changeDefaultGroup(OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Moves a PDP to a new group. + * @param pdp The PDP which is to be moved to a new group + * @param group The new group which the PDP should be added to + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void movePdp(OnapPDP pdp, OnapPDPGroup group, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Add a new PDP to an existing group + * @param pdpID The ID to name the new PDP + * @param groupID The ID of the existing group to add the PDP to + * @param pdpName The name to use for the new PDP + * @param pdpDescription Description of the new PDP (optional) + * @param pdpJmxPort + * @param username Username of the user performing the operation + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void addPdpToGroup(String pdpID, String groupID, String pdpName, String pdpDescription, int pdpJmxPort, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + /** + * Add an existing policy to an existing group + * @param group The ID of the existing group to add the policy to + * @param policyID The ID of an existing policy + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void addPolicyToGroup(String group, String policyID, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + + /** + * Delete an existing PDP group + * @param group A PDPGroup object representing the group to delete + * @param moveToGroup A PDPGroup object representing another existing group which PDPs in the group being deleted should be moved to + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + * @throws PAPException If an error relating to how groups are handled occurs + */ + public void deleteGroup(OnapPDPGroup group, OnapPDPGroup moveToGroup, String username)throws IllegalArgumentException, IllegalStateException, PersistenceException, PAPException; + + /** + * Removes an existing PDP from its group and deletes it. + * @param pdpID The ID of the existing PDP which should be deleted + * @throws IllegalArgumentException If non-optional parameters are null or empty strings + * @throws IllegalStateException If a transaction is already open + * @throws PersistenceException If a database error occurs + */ + public void removePdpFromGroup(String pdpID, String username) throws IllegalArgumentException, IllegalStateException, PersistenceException; + + public GroupEntity getGroup(long groupKey); + public GroupEntity getGroup(String groupId); + public List<?> getPdpsInGroup(long groupKey); + public PdpEntity getPdp(long pdpKey); + + void renamePolicy(String oldPath, String newPath,String username); + + void clonePolicy(String oldPolicyPath, String newPolicyPath, String username); + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/SafePolicyBuilder.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/SafePolicyBuilder.java new file mode 100644 index 000000000..ba5b0026a --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/SafePolicyBuilder.java @@ -0,0 +1,86 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.components; + +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.controlloop.policy.guard.ControlLoopGuard; +import org.yaml.snakeyaml.Yaml; +import org.yaml.snakeyaml.constructor.Constructor; + +public class SafePolicyBuilder { + + private SafePolicyBuilder(){ + //Private Constructor. + } + + public static ControlLoopGuard loadYamlGuard(String specification) { + // + // Read the yaml into our Java Object + // + PolicyLogger.info("Requested YAML to convert : " + specification); + Yaml yaml = new Yaml(new Constructor(ControlLoopGuard.class)); + Object obj = yaml.load(specification); + return (ControlLoopGuard) obj; + } + + public static String generateXacmlGuard(String xacmlFileContent,Map<String, String> generateMap, List<String> blacklist, List<String> targets) { + //Setup default values and Targets. + StringBuilder targetRegex= new StringBuilder(".*|"); + if(targets!=null && !targets.isEmpty()){ + targetRegex = new StringBuilder(); + for(String t : targets){ + targetRegex.append(t + "|"); + } + } + if(generateMap.get("clname")==null|| generateMap.get("clname").isEmpty()){ + generateMap.put("clname",".*"); + } + generateMap.put("targets", targetRegex.toString().substring(0, targetRegex.length()-1)); + // Replace values. + for(Map.Entry<String,String> map: generateMap.entrySet()){ + Pattern p = Pattern.compile("\\$\\{" +map.getKey() +"\\}"); + Matcher m = p.matcher(xacmlFileContent); + String finalInput = map.getValue(); + if(finalInput.contains("$")){ + finalInput = finalInput.replace("$", "\\$"); + } + xacmlFileContent=m.replaceAll(finalInput); + } + if(blacklist!=null && !blacklist.isEmpty()){ + StringBuilder rule = new StringBuilder(); + for(String blackListName : blacklist){ + if(blackListName.contains("$")){ + blackListName = blackListName.replace("$", "\\$"); + } + rule.append("<AttributeValue DataType=\"http://www.w3.org/2001/XMLSchema#string\">"+blackListName+"</AttributeValue>"); + } + Pattern p = Pattern.compile("\\$\\{blackListElement\\}"); + Matcher m = p.matcher(xacmlFileContent); + xacmlFileContent=m.replaceAll(rule.toString()); + } + PolicyLogger.info("Generated XACML from the YAML Spec: \n" + xacmlFileContent); + return xacmlFileContent; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/package-info.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/package-info.java new file mode 100644 index 000000000..31e504883 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/components/package-info.java @@ -0,0 +1,21 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.components; diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ActionPolicyDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ActionPolicyDictionaryController.java new file mode 100644 index 000000000..f7a170131 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ActionPolicyDictionaryController.java @@ -0,0 +1,261 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ActionPolicyDict; +import org.onap.policy.rest.jpa.UserInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class ActionPolicyDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(ActionPolicyDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public ActionPolicyDictionaryController(CommonClassDao commonClassDao){ + ActionPolicyDictionaryController.commonClassDao = commonClassDao; + } + + public ActionPolicyDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + @RequestMapping(value={"/get_ActionPolicyDictDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getActionEntitybyName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("actionPolicyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ActionPolicyDict.class, "attributeName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/get_ActionPolicyDictData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getActionPolicyDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("actionPolicyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ActionPolicyDict.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/action_dictionary/save_ActionDict"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveActionPolicyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ActionPolicyDict actionPolicyDict = null; + ActionAdapter adapter = null; + String userId = null; + + if(fromAPI) { + actionPolicyDict = (ActionPolicyDict)mapper.readValue(root.get("dictionaryFields").toString(), ActionPolicyDict.class); + adapter = (ActionAdapter)mapper.readValue(root.get("dictionaryFields").toString(), ActionAdapter.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(actionPolicyDict.getAttributeName(), "attributeName", ActionPolicyDict.class); + int id = 0; + ActionPolicyDict data = (ActionPolicyDict) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + actionPolicyDict.setId(1); + } else { + actionPolicyDict.setId(id); + } + actionPolicyDict.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + actionPolicyDict = (ActionPolicyDict)mapper.readValue(root.get("actionPolicyDictionaryData").toString(), ActionPolicyDict.class); + adapter = mapper.readValue(root.get("actionPolicyDictionaryData").toString(), ActionAdapter.class); + userId = root.get("userid").textValue(); + } + String header = ""; + int counter = 0; + if(adapter.getHeaders().size() > 0){ + for(Object attribute : adapter.getHeaders()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("number").toString(); + if(counter>0){ + header = header + ":"; + } + header = header + key + "="; + header = header + value; + counter ++; + } + } + } + actionPolicyDict.setHeader(header); + if(actionPolicyDict.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(actionPolicyDict.getAttributeName(), "attributeName", ActionPolicyDict.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + actionPolicyDict.setUserCreatedBy(this.getUserInfo(userId)); + actionPolicyDict.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(actionPolicyDict); + } + }else{ + if(!isFakeUpdate) { + actionPolicyDict.setUserModifiedBy(this.getUserInfo(userId)); + actionPolicyDict.setModifiedDate(new Date()); + commonClassDao.update(actionPolicyDict); + } + } + + String responseString = null; + if(duplicateflag) { + responseString = "Duplicate"; + } else { + responseString = mapper.writeValueAsString(commonClassDao.getData(ActionPolicyDict.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate) { + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{actionPolicyDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/action_dictionary/remove_actionPolicyDict"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeActionPolicyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ActionPolicyDict actionPolicyDict = (ActionPolicyDict)mapper.readValue(root.get("data").toString(), ActionPolicyDict.class); + commonClassDao.delete(actionPolicyDict); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(ActionPolicyDictionaryController.commonClassDao.getData(ActionPolicyDict.class)); + JSONObject j = new JSONObject("{actionPolicyDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } +} + +class ActionAdapter{ + private ArrayList<Object> headers; + + public ArrayList<Object> getHeaders() { + return headers; + } + + public void setHeaders(ArrayList<Object> headers) { + this.headers = headers; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/BRMSDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/BRMSDictionaryController.java new file mode 100644 index 000000000..26d3ccfff --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/BRMSDictionaryController.java @@ -0,0 +1,552 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.io.StringWriter; +import java.nio.charset.StandardCharsets; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.io.IOUtils; +import org.json.JSONObject; +import org.onap.policy.api.PEDependency; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.BRMSController; +import org.onap.policy.rest.jpa.BRMSDependency; +import org.onap.policy.rest.jpa.BRMSParamTemplate; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.utils.PolicyUtils; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + + +@Controller +public class BRMSDictionaryController{ + + private static final Logger LOGGER = FlexLogger.getLogger(BRMSDictionaryController.class); + + + private static CommonClassDao commonClassDao; + + @Autowired + public BRMSDictionaryController(CommonClassDao commonClassDao){ + BRMSDictionaryController.commonClassDao = commonClassDao; + } + + public BRMSDictionaryController() {} + + private String rule; + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + @RequestMapping(value={"/get_BRMSParamDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSParamDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsParamDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSParamTemplate.class, "ruleName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_BRMSParamData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSParamDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsParamDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSParamTemplate.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/brms_dictionary/set_BRMSParamData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public void SetRuleData(HttpServletRequest request, HttpServletResponse response) throws Exception{ + StringWriter writer = new StringWriter(); + IOUtils.copy(request.getInputStream() , writer, StandardCharsets.UTF_8); + String cleanStreamBoundary = writer.toString().replaceFirst("------(.*)(?s).*octet-stream", ""); + rule = cleanStreamBoundary.substring(0, cleanStreamBoundary.lastIndexOf("end")+4); + } + + @RequestMapping(value={"/brms_dictionary/save_BRMSParam"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + + BRMSParamTemplate bRMSParamTemplateData; + String userId = null; + if(fromAPI) { + bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get("dictionaryFields").toString(), BRMSParamTemplate.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(bRMSParamTemplateData.getRuleName(), "ruleName", BRMSParamTemplate.class); + int id = 0; + BRMSParamTemplate data = (BRMSParamTemplate) duplicateData.get(0); + id = data.getId(); + bRMSParamTemplateData.setId(id); + bRMSParamTemplateData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get("brmsParamDictionaryData").toString(), BRMSParamTemplate.class); + userId = root.get("userid").textValue(); + } + + bRMSParamTemplateData.setRule(rule); + if(bRMSParamTemplateData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(bRMSParamTemplateData.getRuleName(), "ruleName", BRMSParamTemplate.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + bRMSParamTemplateData.setUserCreatedBy(this.getUserInfo(userId)); + commonClassDao.save(bRMSParamTemplateData); + } + }else{ + commonClassDao.update(bRMSParamTemplateData); + } + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(BRMSDictionaryController.commonClassDao.getData(BRMSParamTemplate.class)); + } + if(fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{brmsParamDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/brms_dictionary/remove_brmsParam"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + BRMSParamTemplate bRMSParamTemplateData = (BRMSParamTemplate)mapper.readValue(root.get("data").toString(), BRMSParamTemplate.class); + commonClassDao.delete(bRMSParamTemplateData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(BRMSDictionaryController.commonClassDao.getData(BRMSParamTemplate.class)); + JSONObject j = new JSONObject("{brmsParamDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_BRMSDependencyDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSDependencyDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsDependencyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSDependency.class, "dependencyName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_BRMSDependencyData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSDependencyDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsDependencyDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/brms_dictionary/save_BRMSDependencyData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveBRMSDependencyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + LOGGER.debug("DictionaryController: saveBRMSDependencyDictionary() is called"); + + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + + BRMSDependency brmsDependency; + String userId = null; + if (fromAPI) { + brmsDependency = (BRMSDependency)mapper.readValue(root.get("dictionaryFields").toString(), BRMSDependency.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(brmsDependency.getDependencyName(), "dependencyName", BRMSDependency.class); + int id = 0; + BRMSDependency data = (BRMSDependency) duplicateData.get(0); + id = data.getId(); + brmsDependency.setId(id); + brmsDependency.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + brmsDependency = (BRMSDependency)mapper.readValue(root.get("brmsDependencyDictionaryData").toString(), BRMSDependency.class); + userId = root.get("userid").textValue(); + } + + LOGGER.audit("the userId from the onap portal is: " + userId); + String responseString = null; + + if(brmsDependency.getDependency()!=null && !brmsDependency.getDependency().trim().equals("")){ + PEDependency dependency = null; + try{ + dependency = PolicyUtils.jsonStringToObject(brmsDependency.getDependency(), PEDependency.class); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_SCHEMA_INVALID + "wrong data given for BRMS PEDependency Dictionary : " + brmsDependency.getDependency()); + } + if(dependency==null){ + responseString = "Error"; + }else{ + if(brmsDependency.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(brmsDependency.getDependencyName(), "dependencyName", BRMSDependency.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + brmsDependency.setUserCreatedBy(getUserInfo(userId)); + brmsDependency.setUserModifiedBy(getUserInfo(userId)); + LOGGER.audit("DictionaryController: got the user info now about to call Save() method on brmsDependencydao"); + commonClassDao.save(brmsDependency); + } + }else{ + brmsDependency.setUserModifiedBy(this.getUserInfo(userId)); + brmsDependency.setModifiedDate(new Date()); + commonClassDao.update(brmsDependency); + } + if(duplicateflag) { + responseString = "Duplicate"; + } else { + responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class)); + } + } + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate") && !responseString.equals("Error")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{brmsDependencyDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + } catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/brms_dictionary/remove_brmsDependency"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeBRMSDependencyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + BRMSDependency brmsDependency = (BRMSDependency)mapper.readValue(root.get("data").toString(), BRMSDependency.class); + commonClassDao.delete(brmsDependency); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSDependency.class)); + JSONObject j = new JSONObject("{brmsDependencyDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_BRMSControllerDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSControllerDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsControllerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(BRMSController.class, "controllerName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_BRMSControllerData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getBRMSControllerDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("brmsControllerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(BRMSController.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/brms_dictionary/save_BRMSControllerData"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveBRMSControllerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + LOGGER.debug("DictionaryController: saveBRMSControllerDictionary() is called"); + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + BRMSController brmsController; + String userId = null; + if (fromAPI) { + brmsController = (BRMSController)mapper.readValue(root.get("dictionaryFields").toString(), BRMSController.class); + userId = "API"; + //check if update operation or create, get id for data to be updated + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(brmsController.getControllerName(), "controllerName", BRMSController.class); + int id = 0; + BRMSController data = (BRMSController) duplicateData.get(0); + id = data.getId(); + brmsController.setId(id); + brmsController.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + brmsController = (BRMSController)mapper.readValue(root.get("brmsControllerDictionaryData").toString(), BRMSController.class); + userId = root.get("userid").textValue(); + } + LOGGER.audit("the userId from the onap portal is: " + userId); + String responseString = null; + if(brmsController.getController()!=null && !brmsController.getController().trim().equals("")){ + PEDependency dependency = null; + try{ + dependency = PolicyUtils.jsonStringToObject(brmsController.getController(), PEDependency.class); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_SCHEMA_INVALID + "wrong data given for BRMS Controller Dictionary : " + brmsController.getController()); + } + if(dependency==null){ + responseString = "Error"; + }else{ + if(brmsController.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(brmsController.getControllerName(), "controllerName", BRMSController.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + brmsController.setUserCreatedBy(getUserInfo(userId)); + brmsController.setUserModifiedBy(getUserInfo(userId)); + LOGGER.audit("DictionaryController: got the user info now about to call Save() method on brmsControllerdao"); + commonClassDao.save(brmsController); + } + }else{ + brmsController.setUserModifiedBy(this.getUserInfo(userId)); + brmsController.setModifiedDate(new Date()); + commonClassDao.update(brmsController); + } + if(duplicateflag) { + responseString = "Duplicate"; + } else { + responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSController.class)); + } + } + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate") && !responseString.equals("Error")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{brmsControllerDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/brms_dictionary/remove_brmsController"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeBRMSControllerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + BRMSController brmsController = (BRMSController)mapper.readValue(root.get("data").toString(), BRMSController.class); + commonClassDao.delete(brmsController); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(BRMSController.class)); + JSONObject j = new JSONObject("{brmsControllerDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + public BRMSDependency getDependencyDataByID(String dependencyName){ + return (BRMSDependency) commonClassDao.getEntityItem(BRMSDependency.class, "dependencyName", dependencyName); + } + + public BRMSController getControllerDataByID(String controllerName){ + return (BRMSController) commonClassDao.getEntityItem(BRMSController.class, "controllerName", controllerName); + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ClosedLoopDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ClosedLoopDictionaryController.java new file mode 100644 index 000000000..75345f99c --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/ClosedLoopDictionaryController.java @@ -0,0 +1,1031 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.adapters.GridData; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ClosedLoopD2Services; +import org.onap.policy.rest.jpa.ClosedLoopSite; +import org.onap.policy.rest.jpa.PEPOptions; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.rest.jpa.VNFType; +import org.onap.policy.rest.jpa.VSCLAction; +import org.onap.policy.rest.jpa.VarbindDictionary; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class ClosedLoopDictionaryController{ + + private static final Logger LOGGER = FlexLogger.getLogger(ClosedLoopDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public ClosedLoopDictionaryController(CommonClassDao commonClassDao){ + ClosedLoopDictionaryController.commonClassDao = commonClassDao; + } + + public ClosedLoopDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + + @RequestMapping(value={"/get_VSCLActionDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVSCLActionDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("vsclActionDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VSCLAction.class, "vsclaction"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + + @RequestMapping(value={"/get_VSCLActionData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVSCLActionDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("vsclActionDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_VNFTypeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVNFTypeDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("vnfTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VNFType.class, "vnftype"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_VNFTypeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVNFTypeDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("vnfTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VNFType.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_PEPOptionsDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPEPOptionsDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("pepOptionsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PEPOptions.class, "pepName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_PEPOptionsData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPEPOptionsDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("pepOptionsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_VarbindDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVarbindDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("varbindDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(VarbindDictionary.class, "varbindName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_VarbindDictionaryData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getVarbindDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("varbindDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_ClosedLoopServicesDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getClosedLoopServiceDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("closedLoopServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ClosedLoopD2Services.class, "serviceName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_ClosedLoopServicesData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getClosedLoopServiceDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("closedLoopServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_ClosedLoopSiteDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getClosedLoopSiteDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("closedLoopSiteDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ClosedLoopSite.class, "siteName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_ClosedLoopSiteData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getClosedLoopSiteDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("closedLoopSiteDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/cl_dictionary/save_vsclAction"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveVSCLAction(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VSCLAction vSCLAction; + String userId = null; + if (fromAPI) { + vSCLAction = (VSCLAction)mapper.readValue(root.get("dictionaryFields").toString(), VSCLAction.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vSCLAction.getVsclaction(), "vsclaction", VSCLAction.class); + int id = 0; + VSCLAction data = (VSCLAction) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + vSCLAction.setId(1); + } else { + vSCLAction.setId(id); + } + + vSCLAction.setUserCreatedBy(this.getUserInfo(userId)); + } + + } else { + vSCLAction = (VSCLAction)mapper.readValue(root.get("vsclActionDictionaryData").toString(), VSCLAction.class); + userId = root.get("userid").textValue(); + } + if(vSCLAction.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vSCLAction.getVsclaction(), "vsclaction", VSCLAction.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + vSCLAction.setUserCreatedBy(this.getUserInfo(userId)); + vSCLAction.setUserModifiedBy(this.getUserInfo(userId)); + vSCLAction.setModifiedDate(new Date()); + commonClassDao.save(vSCLAction); + } + }else{ + if(!isFakeUpdate) { + vSCLAction.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.update(vSCLAction); + } + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate) { + responseString = "Exists"; + } else { + responseString = "Success"; + } + + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{vsclActionDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_VsclAction"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeVSCLAction(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VSCLAction vSCLAction = (VSCLAction)mapper.readValue(root.get("data").toString(), VSCLAction.class); + commonClassDao.delete(vSCLAction); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(VSCLAction.class)); + JSONObject j = new JSONObject("{vsclActionDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/save_vnfType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveVnfType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VNFType vNFType; + String userId = null; + + if (fromAPI) { + vNFType = (VNFType)mapper.readValue(root.get("dictionaryFields").toString(), VNFType.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vNFType.getVnftype(), "vnftype", VNFType.class); + int id = 0; + VNFType data = (VNFType) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + vNFType.setId(1); + } else { + vNFType.setId(id); + } + vNFType.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + vNFType = (VNFType)mapper.readValue(root.get("vnfTypeDictionaryData").toString(), VNFType.class); + userId = root.get("userid").textValue(); + } + if(vNFType.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(vNFType.getVnftype(), "vnftype", VNFType.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + vNFType.setUserCreatedBy(this.getUserInfo(userId)); + vNFType.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(vNFType); + } + }else{ + if(!isFakeUpdate) { + vNFType.setUserModifiedBy(this.getUserInfo(userId)); + vNFType.setModifiedDate(new Date()); + commonClassDao.update(vNFType); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(VNFType.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate) { + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{vnfTypeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_vnfType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeVnfType(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VNFType vNFType = (VNFType)mapper.readValue(root.get("data").toString(), VNFType.class); + commonClassDao.delete(vNFType); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(VNFType.class)); + JSONObject j = new JSONObject("{vnfTypeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/save_pepOptions"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePEPOptions(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PEPOptions pEPOptions; + GridData gridData; + String userId = null; + if (fromAPI) { + pEPOptions = (PEPOptions)mapper.readValue(root.get("dictionaryFields").toString(), PEPOptions.class); + gridData = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(pEPOptions.getPepName(), "pepName", PEPOptions.class); + int id = 0; + PEPOptions data = (PEPOptions) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + pEPOptions.setId(1); + } else { + pEPOptions.setId(id); + } + pEPOptions.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + pEPOptions = (PEPOptions)mapper.readValue(root.get("pepOptionsDictionaryData").toString(), PEPOptions.class); + gridData = (GridData)mapper.readValue(root.get("pepOptionsDictionaryData").toString(), GridData.class); + userId = root.get("userid").textValue(); + } + String actions = ""; + int counter = 0; + if(gridData.getAttributes().size() > 0){ + for(Object attribute : gridData.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("number").toString(); + if(counter>0){ + actions = actions + ":#@"; + } + actions = actions + key + "=#@"; + actions = actions + value; + counter ++; + } + } + } + pEPOptions.setActions(actions); + if(pEPOptions.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(pEPOptions.getPepName(), "pepName", PEPOptions.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + pEPOptions.setUserCreatedBy(this.getUserInfo(userId)); + pEPOptions.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(pEPOptions); + } + }else{ + if(!isFakeUpdate){ + pEPOptions.setUserModifiedBy(this.getUserInfo(userId)); + pEPOptions.setModifiedDate(new Date()); + commonClassDao.update(pEPOptions); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{pepOptionsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_pepOptions"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePEPOptions(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PEPOptions pEPOptions = (PEPOptions)mapper.readValue(root.get("data").toString(), PEPOptions.class); + commonClassDao.delete(pEPOptions); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(PEPOptions.class)); + JSONObject j = new JSONObject("{pepOptionsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/save_service"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveServiceType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ClosedLoopD2Services serviceData; + String userId = null; + if (fromAPI) { + serviceData = (ClosedLoopD2Services)mapper.readValue(root.get("dictionaryFields").toString(), ClosedLoopD2Services.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceData.getServiceName(), "serviceName", ClosedLoopD2Services.class); + int id = 0; + ClosedLoopD2Services data = (ClosedLoopD2Services) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + serviceData.setId(1); + } else { + serviceData.setId(id); + } + serviceData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + serviceData = (ClosedLoopD2Services)mapper.readValue(root.get("closedLoopServiceDictionaryData").toString(), ClosedLoopD2Services.class); + userId = root.get("userid").textValue(); + } + if(serviceData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceData.getServiceName(), "serviceName", ClosedLoopD2Services.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + serviceData.setUserCreatedBy(this.getUserInfo(userId)); + serviceData.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(serviceData); + } + }else{ + if(!isFakeUpdate){ + serviceData.setUserModifiedBy(this.getUserInfo(userId)); + serviceData.setModifiedDate(new Date()); + commonClassDao.update(serviceData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{closedLoopServiceDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_Service"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeServiceType(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ClosedLoopD2Services closedLoopD2Services = (ClosedLoopD2Services)mapper.readValue(root.get("data").toString(), ClosedLoopD2Services.class); + commonClassDao.delete(closedLoopD2Services); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopD2Services.class)); + JSONObject j = new JSONObject("{closedLoopServiceDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/save_siteName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveSiteType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ClosedLoopSite siteData; + String userId = null; + if (fromAPI) { + siteData = (ClosedLoopSite)mapper.readValue(root.get("dictionaryFields").toString(), ClosedLoopSite.class); + userId = "API"; + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(siteData.getSiteName(), "siteName", ClosedLoopSite.class); + int id = 0; + ClosedLoopSite data = (ClosedLoopSite) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + siteData.setId(1); + } else { + siteData.setId(id); + } + siteData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + siteData = (ClosedLoopSite)mapper.readValue(root.get("closedLoopSiteDictionaryData").toString(), ClosedLoopSite.class); + userId = root.get("userid").textValue(); + } + if(siteData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(siteData.getSiteName(), "siteName", ClosedLoopSite.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + siteData.setUserCreatedBy(this.getUserInfo(userId)); + siteData.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(siteData); + } + }else{ + if(!isFakeUpdate) { + siteData.setUserModifiedBy(this.getUserInfo(userId)); + siteData.setModifiedDate(new Date()); + commonClassDao.update(siteData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{closedLoopSiteDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_site"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeSiteType(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ClosedLoopSite closedLoopSite = (ClosedLoopSite)mapper.readValue(root.get("data").toString(), ClosedLoopSite.class); + commonClassDao.delete(closedLoopSite); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(ClosedLoopSite.class)); + JSONObject j = new JSONObject("{closedLoopSiteDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/save_varbind"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveVarbind(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VarbindDictionary varbindDictionary; + String userId = null; + if (fromAPI) { + varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("dictionaryFields").toString(), VarbindDictionary.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(varbindDictionary.getVarbindName(), "varbindName", VarbindDictionary.class); + int id = 0; + VarbindDictionary data = (VarbindDictionary) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + varbindDictionary.setId(1); + } else { + varbindDictionary.setId(id); + } + varbindDictionary.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("varbindDictionaryData").toString(), VarbindDictionary.class); + userId = root.get("userid").textValue(); + } + if(varbindDictionary.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(varbindDictionary.getVarbindName(), "varbindName", VarbindDictionary.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + varbindDictionary.setUserCreatedBy(this.getUserInfo(userId)); + varbindDictionary.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(varbindDictionary); + } + }else{ + if(!isFakeUpdate){ + varbindDictionary.setUserModifiedBy(this.getUserInfo(userId)); + varbindDictionary.setModifiedDate(new Date()); + commonClassDao.update(varbindDictionary); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{varbindDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/cl_dictionary/remove_varbindDict"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeVarbind(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + VarbindDictionary varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("data").toString(), VarbindDictionary.class); + commonClassDao.delete(varbindDictionary); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(VarbindDictionary.class)); + JSONObject j = new JSONObject("{varbindDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + +} + diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DecisionPolicyDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DecisionPolicyDictionaryController.java new file mode 100644 index 000000000..ac19b99a2 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DecisionPolicyDictionaryController.java @@ -0,0 +1,426 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.DecisionSettings; +import org.onap.policy.rest.jpa.RainyDayTreatments; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class DecisionPolicyDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(DecisionPolicyDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public DecisionPolicyDictionaryController(CommonClassDao commonClassDao){ + DecisionPolicyDictionaryController.commonClassDao = commonClassDao; + } + + public DecisionPolicyDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + @RequestMapping(value={"/get_SettingsDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getSettingsDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("settingsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(DecisionSettings.class, "xacmlId"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + + @RequestMapping(value={"/get_SettingsDictionaryData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getSettingsDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("settingsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(DecisionSettings.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/decision_dictionary/save_Settings"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveSettingsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DecisionSettings decisionSettings; + String userId = null; + + if (fromAPI) { + decisionSettings = (DecisionSettings)mapper.readValue(root.get("dictionaryFields").toString(), DecisionSettings.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(decisionSettings.getXacmlId(), "xacmlId", DecisionSettings.class); + int id = 0; + DecisionSettings data = (DecisionSettings) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + decisionSettings.setId(1); + } else { + decisionSettings.setId(id); + } + decisionSettings.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + decisionSettings = (DecisionSettings)mapper.readValue(root.get("settingsDictionaryData").toString(), DecisionSettings.class); + userId = root.get("userid").textValue(); + } + if(decisionSettings.getDatatypeBean().getShortName() != null){ + String datatype = decisionSettings.getDatatypeBean().getShortName(); + Datatype a = new Datatype(); + if(datatype.equalsIgnoreCase("string")){ + a.setId(26); + }else if(datatype.equalsIgnoreCase("integer")){ + a.setId(12); + }else if(datatype.equalsIgnoreCase("boolean")){ + a.setId(18); + }else if(datatype.equalsIgnoreCase("double")){ + a.setId(25); + }else if(datatype.equalsIgnoreCase("user")){ + a.setId(29); + } + decisionSettings.setDatatypeBean(a); + } + if(decisionSettings.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(decisionSettings.getXacmlId(), "xacmlId", DecisionSettings.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + decisionSettings.setUserCreatedBy(this.getUserInfo(userId)); + decisionSettings.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(decisionSettings); + } + }else{ + if(!isFakeUpdate) { + decisionSettings.setUserModifiedBy(this.getUserInfo(userId)); + decisionSettings.setModifiedDate(new Date()); + commonClassDao.update(decisionSettings); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(DecisionSettings.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{settingsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/settings_dictionary/remove_settings"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeSettingsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DecisionSettings decisionSettings = (DecisionSettings)mapper.readValue(root.get("data").toString(), DecisionSettings.class); + commonClassDao.delete(decisionSettings); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(DecisionSettings.class)); + JSONObject j = new JSONObject("{settingsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + + @RequestMapping(value={"/get_RainyDayDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getRainyDayDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("rainyDayDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(RainyDayTreatments.class, "bbid"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + + @RequestMapping(value={"/get_RainyDayDictionaryData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getRainyDayDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("rainyDayDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(RainyDayTreatments.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/decision_dictionary/save_RainyDay"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveRainyDayDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + RainyDayTreatments decisionRainyDay; + TreatmentValues treatmentsData = null; + if (fromAPI) { + decisionRainyDay = (RainyDayTreatments)mapper.readValue(root.get("dictionaryFields").toString(), RainyDayTreatments.class); + treatmentsData = (TreatmentValues)mapper.readValue(root.get("dictionaryFields").toString(), TreatmentValues.class); + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(decisionRainyDay.getBbid()+":"+decisionRainyDay.getWorkstep(), "bbid:workstep", RainyDayTreatments.class); + int id = 0; + RainyDayTreatments data = (RainyDayTreatments) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + } else { + decisionRainyDay.setId(id); + } + } + } else { + decisionRainyDay = (RainyDayTreatments)mapper.readValue(root.get("rainyDayDictionaryData").toString(), RainyDayTreatments.class); + treatmentsData = (TreatmentValues)mapper.readValue(root.get("rainyDayDictionaryData").toString(), TreatmentValues.class); + } + + String userValue = ""; + int counter = 0; + if(treatmentsData.getUserDataTypeValues().size() > 0){ + for(Object treatment : treatmentsData.getUserDataTypeValues()){ + if(treatment instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) treatment).get("treatment").toString(); + if(counter>0){ + userValue = userValue + ","; + } + userValue = userValue + key ; + counter ++; + } + } + } + decisionRainyDay.setTreatments(userValue); + + if(decisionRainyDay.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(decisionRainyDay.getBbid()+":"+decisionRainyDay.getWorkstep(), "bbid:workstep", RainyDayTreatments.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(decisionRainyDay); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(decisionRainyDay); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(RainyDayTreatments.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{rainyDayDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/decision_dictionary/remove_rainyDay"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeRainyDayDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + RainyDayTreatments decisionRainyDay = (RainyDayTreatments)mapper.readValue(root.get("data").toString(), RainyDayTreatments.class); + commonClassDao.delete(decisionRainyDay); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(RainyDayTreatments.class)); + JSONObject j = new JSONObject("{rainyDayDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + +} + +class TreatmentValues { + private ArrayList<Object> userDataTypeValues; + + public ArrayList<Object> getUserDataTypeValues() { + return userDataTypeValues; + } + + public void setUserDataTypeValues(ArrayList<Object> userDataTypeValues) { + this.userDataTypeValues = userDataTypeValues; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DescriptiveDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DescriptiveDictionaryController.java new file mode 100644 index 000000000..1811223e6 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DescriptiveDictionaryController.java @@ -0,0 +1,246 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.adapters.GridData; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.DescriptiveScope; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class DescriptiveDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(DescriptiveDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public DescriptiveDictionaryController(CommonClassDao commonClassDao){ + DescriptiveDictionaryController.commonClassDao = commonClassDao; + } + + public DescriptiveDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + @RequestMapping(value={"/get_DescriptiveScopeByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getDescriptiveDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("descriptiveScopeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(DescriptiveScope.class, "descriptiveScopeName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_DescriptiveScope"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getDescriptiveDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("descriptiveScopeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(DescriptiveScope.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/descriptive_dictionary/save_descriptive"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveDescriptiveDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DescriptiveScope descriptiveScope; + GridData data; + String userId = null; + if (fromAPI) { + descriptiveScope = (DescriptiveScope)mapper.readValue(root.get("dictionaryFields").toString(), DescriptiveScope.class); + data = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(descriptiveScope.getScopeName(), "descriptiveScopeName", DescriptiveScope.class); + int id = 0; + DescriptiveScope dbdata = (DescriptiveScope) duplicateData.get(0); + id = dbdata.getId(); + if(id==0){ + isFakeUpdate=true; + descriptiveScope.setId(1); + } else { + descriptiveScope.setId(id); + } + descriptiveScope.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + descriptiveScope = (DescriptiveScope)mapper.readValue(root.get("descriptiveScopeDictionaryData").toString(), DescriptiveScope.class); + data = (GridData)mapper.readValue(root.get("descriptiveScopeDictionaryData").toString(), GridData.class); + userId = root.get("userid").textValue(); + } + String header = ""; + int counter = 0; + if(data.getAttributes().size() > 0){ + for(Object attribute : data.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("number").toString(); + if(counter>0){ + header = header + "AND"; + } + header = header + key + ":"; + header = header + value; + counter ++; + } + } + } + descriptiveScope.setSearch(header); + if(descriptiveScope.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(descriptiveScope.getScopeName(), "descriptiveScopeName", DescriptiveScope.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + descriptiveScope.setUserCreatedBy(this.getUserInfo(userId)); + descriptiveScope.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(descriptiveScope); + } + }else{ + if(!isFakeUpdate){ + descriptiveScope.setUserModifiedBy(this.getUserInfo(userId)); + descriptiveScope.setModifiedDate(new Date()); + commonClassDao.update(descriptiveScope); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(DescriptiveScope.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{descriptiveScopeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/descriptive_dictionary/remove_descriptiveScope"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeDescriptiveDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DescriptiveScope descriptiveScope = (DescriptiveScope)mapper.readValue(root.get("data").toString(), DescriptiveScope.class); + commonClassDao.delete(descriptiveScope); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(DescriptiveScope.class)); + JSONObject j = new JSONObject("{descriptiveScopeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } +} + diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryController.java new file mode 100644 index 000000000..d16de1f9c --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryController.java @@ -0,0 +1,447 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.json.JSONObject; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.Attribute; +import org.onap.policy.rest.jpa.Category; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.OnapName; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class DictionaryController { + + private static final Log LOGGER = LogFactory.getLog(DictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public DictionaryController(CommonClassDao commonClassDao){ + DictionaryController.commonClassDao = commonClassDao; + } + + public DictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + + public Category getCategory(){ + List<Object> list = commonClassDao.getData(Category.class); + for (int i = 0; i < list.size() ; i++) { + Category value = (Category) list.get(i); + if (value.getShortName().equals("resource")) { + return value; + } + } + return null; + } + + @RequestMapping(value={"/get_AttributeDatabyAttributeName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getAttributeDictionaryEntityDatabyAttributeName(HttpServletRequest request, HttpServletResponse response){ + try{ + System.out.println(); + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("attributeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(Attribute.class, "xacmlId"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + //Attribute Dictionary + @RequestMapping(value="/get_AttributeData", method= RequestMethod.GET , produces=MediaType.APPLICATION_JSON_VALUE) + public void getAttributeDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + System.out.println(); + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("attributeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(Attribute.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/attribute_dictionary/save_attribute"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + Attribute attributeData = null; + AttributeValues attributeValueData = null; + String userId = null; + if (fromAPI) { + //JsonNode json = root.get("dictionaryFields"); + attributeData = (Attribute)mapper.readValue(root.get("dictionaryFields").toString(), Attribute.class); + attributeValueData = (AttributeValues)mapper.readValue(root.get("dictionaryFields").toString(), AttributeValues.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(attributeData.getXacmlId(), "xacmlId", Attribute.class); + int id = 0; + Attribute data = (Attribute) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + attributeData.setId(1); + } else { + attributeData.setId(id); + } + attributeData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + attributeData = (Attribute)mapper.readValue(root.get("attributeDictionaryData").toString(), Attribute.class); + attributeValueData = (AttributeValues)mapper.readValue(root.get("attributeDictionaryData").toString(), AttributeValues.class); + userId = root.get("userid").textValue(); + } + String userValue = ""; + int counter = 0; + if(attributeValueData.getUserDataTypeValues().size() > 0){ + for(Object attribute : attributeValueData.getUserDataTypeValues()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("attributeValues").toString(); + if(counter>0){ + userValue = userValue + ","; + } + userValue = userValue + key ; + counter ++; + } + } + } + attributeData.setAttributeValue(userValue); + if(attributeData.getDatatypeBean().getShortName() != null){ + String datatype = attributeData.getDatatypeBean().getShortName(); + Datatype a = new Datatype(); + if(datatype.equalsIgnoreCase("string")){ + a.setId(26); + }else if(datatype.equalsIgnoreCase("integer")){ + a.setId(12); + }else if(datatype.equalsIgnoreCase("boolean")){ + a.setId(18); + }else if(datatype.equalsIgnoreCase("double")){ + a.setId(25); + }else if(datatype.equalsIgnoreCase("user")){ + a.setId(29); + } + attributeData.setDatatypeBean(a); + } + if(attributeData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(attributeData.getXacmlId(), "xacmlId", Attribute.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + attributeData.setCategoryBean(this.getCategory()); + attributeData.setUserCreatedBy(this.getUserInfo(userId)); + attributeData.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(attributeData); + } + }else{ + if(!isFakeUpdate) { + attributeData.setUserModifiedBy(this.getUserInfo(userId)); + attributeData.setModifiedDate(new Date()); + commonClassDao.update(attributeData); + } + } + String responseString = null; + if(duplicateflag) { + responseString = "Duplicate"; + } else { + responseString = mapper.writeValueAsString(commonClassDao.getData(Attribute.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate) { + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{attributeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/attribute_dictionary/remove_attribute"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + Attribute attributeData = (Attribute)mapper.readValue(root.get("data").toString(), Attribute.class); + commonClassDao.delete(attributeData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(Attribute.class)); + JSONObject j = new JSONObject("{attributeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + //OnapName Dictionary + @RequestMapping(value={"/get_OnapNameDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getOnapNameDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + LOGGER.info("get_OnapNameDataByName is called"); + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("onapNameDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(OnapName.class, "onapName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_OnapNameData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getOnapNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("onapNameDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(OnapName.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/onap_dictionary/save_onapName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveOnapDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + OnapName onapData; + String userId = null; + if (fromAPI) { + onapData = (OnapName)mapper.readValue(root.get("dictionaryFields").toString(), OnapName.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getOnapName(), "onapName", OnapName.class); + int id = 0; + OnapName data = (OnapName) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + onapData.setId(1); + } else { + onapData.setId(id); + } + onapData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + onapData = (OnapName)mapper.readValue(root.get("onapNameDictionaryData").toString(), OnapName.class); + userId = root.get("userid").textValue(); + } + if(onapData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getOnapName(), "onapName", OnapName.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + onapData.setUserCreatedBy(getUserInfo(userId)); + onapData.setUserModifiedBy(getUserInfo(userId)); + commonClassDao.save(onapData); + } + }else{ + if(!isFakeUpdate){ + onapData.setUserModifiedBy(this.getUserInfo(userId)); + onapData.setModifiedDate(new Date()); + commonClassDao.update(onapData); + } + } + String responseString = null; + if(duplicateflag) { + responseString = "Duplicate"; + } else { + responseString = mapper.writeValueAsString(commonClassDao.getData(OnapName.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{onapNameDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/onap_dictionary/remove_onap"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeOnapDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + OnapName onapData = (OnapName)mapper.readValue(root.get("data").toString(), OnapName.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(OnapName.class)); + JSONObject j = new JSONObject("{onapNameDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + +} + +class AttributeValues{ + private ArrayList<Object> userDataTypeValues; + + public ArrayList<Object> getUserDataTypeValues() { + return userDataTypeValues; + } + + public void setUserDataTypeValues(ArrayList<Object> userDataTypeValues) { + this.userDataTypeValues = userDataTypeValues; + } +} + diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryImportController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryImportController.java new file mode 100644 index 000000000..12851917a --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/DictionaryImportController.java @@ -0,0 +1,539 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + /* + * + * + * */ +import java.io.File; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.OutputStream; +import java.util.List; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.compress.utils.IOUtils; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ActionList; +import org.onap.policy.rest.jpa.ActionPolicyDict; +import org.onap.policy.rest.jpa.AddressGroup; +import org.onap.policy.rest.jpa.Attribute; +import org.onap.policy.rest.jpa.BRMSParamTemplate; +import org.onap.policy.rest.jpa.Category; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.DecisionSettings; +import org.onap.policy.rest.jpa.DescriptiveScope; +import org.onap.policy.rest.jpa.OnapName; +import org.onap.policy.rest.jpa.GroupServiceList; +import org.onap.policy.rest.jpa.PEPOptions; +import org.onap.policy.rest.jpa.PrefixList; +import org.onap.policy.rest.jpa.ProtocolList; +import org.onap.policy.rest.jpa.SecurityZone; +import org.onap.policy.rest.jpa.ServiceList; +import org.onap.policy.rest.jpa.TermList; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.rest.jpa.VNFType; +import org.onap.policy.rest.jpa.VSCLAction; +import org.onap.policy.rest.jpa.VarbindDictionary; +import org.onap.policy.rest.jpa.Zone; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; + +import au.com.bytecode.opencsv.CSVReader; + + +@Controller +public class DictionaryImportController { + private String newFile; + + private static CommonClassDao commonClassDao; + + @Autowired + public DictionaryImportController(CommonClassDao commonClassDao){ + DictionaryImportController.commonClassDao = commonClassDao; + } + + public DictionaryImportController(){} + + + @RequestMapping(value={"/dictionary/import_dictionary"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public void ImportDictionaryData(HttpServletRequest request, HttpServletResponse response) throws Exception{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + //JsonNode root = mapper.readTree(request.getReader()); + String userId = request.getParameter("userId"); + String dictionaryName = request.getParameter("dictionaryName"); + + File file = new File(dictionaryName); + OutputStream outputStream = new FileOutputStream(file); + IOUtils.copy(request.getInputStream(), outputStream); + outputStream.close(); + this.newFile = file.toString(); + CSVReader csvReader = new CSVReader(new FileReader(this.newFile)); + List<String[]> dictSheet = csvReader.readAll(); + if(dictionaryName.startsWith("Attribute")){ + for(int i = 1; i< dictSheet.size(); i++){ + Attribute attribute = new Attribute(""); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("xacml_id") || dictSheet.get(0)[j].equalsIgnoreCase("Attribute ID")){ + attribute.setXacmlId(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("priority")){ + attribute.setPriority(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("datatype") || dictSheet.get(0)[j].equalsIgnoreCase("Data Type")){ + Datatype dataType = new Datatype(); + if(rows[j].equalsIgnoreCase("string")){ + dataType.setId(26); + }else if(rows[j].equalsIgnoreCase("integer")){ + dataType.setId(12); + }else if(rows[j].equalsIgnoreCase("double")){ + dataType.setId(25); + }else if(rows[j].equalsIgnoreCase("boolean")){ + dataType.setId(18); + }else if(rows[j].equalsIgnoreCase("user")){ + dataType.setId(29); + } + attribute.setDatatypeBean(dataType); + Category category = new Category(); + category.setId(5); + attribute.setCategoryBean(category); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("attribute_value") || dictSheet.get(0)[j].equalsIgnoreCase("Attribute Value")){ + attribute.setAttributeValue(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("ActionPolicyDictionary")){ + for(int i = 1; i< dictSheet.size(); i++){ + ActionPolicyDict attribute = new ActionPolicyDict("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("attribute_name") || dictSheet.get(0)[j].equalsIgnoreCase("Attribute Name")){ + attribute.setAttributeName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("body")){ + attribute.setBody(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("headers")){ + attribute.setHeader(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("method")){ + attribute.setMethod(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("type")){ + attribute.setMethod(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("url")){ + attribute.setMethod(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("OnapName")){ + for(int i = 1; i< dictSheet.size(); i++){ + OnapName attribute = new OnapName("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("onap_name") || dictSheet.get(0)[j].equalsIgnoreCase("Onap Name")){ + attribute.setOnapName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("VNFType")){ + for(int i = 1; i< dictSheet.size(); i++){ + VNFType attribute = new VNFType("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("vnf_type") || dictSheet.get(0)[j].equalsIgnoreCase("VNF Type")){ + attribute.setVnftype(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("VSCLAction")){ + for(int i = 1; i< dictSheet.size(); i++){ + VSCLAction attribute = new VSCLAction("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("vscl_action") || dictSheet.get(0)[j].equalsIgnoreCase("VSCL Action")){ + attribute.setVsclaction(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("PEPOptions")){ + for(int i = 1; i< dictSheet.size(); i++){ + PEPOptions attribute = new PEPOptions("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("PEP_NAME") || dictSheet.get(0)[j].equalsIgnoreCase("PEP Name")){ + attribute.setPepName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("Actions")){ + attribute.setActions(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("VarbindDictionary")){ + for(int i = 1; i< dictSheet.size(); i++){ + VarbindDictionary attribute = new VarbindDictionary("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("varbind_Name") || dictSheet.get(0)[j].equalsIgnoreCase("Varbind Name")){ + attribute.setVarbindName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("varbind_Description") || dictSheet.get(0)[j].equalsIgnoreCase("Varbind Description")){ + attribute.setVarbindDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("varbind_oid") || dictSheet.get(0)[j].equalsIgnoreCase("Varbind OID")){ + attribute.setVarbindOID(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("BRMSParamDictionary")){ + for(int i = 1; i< dictSheet.size(); i++){ + BRMSParamTemplate attribute = new BRMSParamTemplate(); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("param_template_name") || dictSheet.get(0)[j].equalsIgnoreCase("Rule Name")){ + attribute.setRuleName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("DESCRIPTION") || dictSheet.get(0)[j].equalsIgnoreCase("Description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("rule")){ + attribute.setRule(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("Settings")){ + for(int i = 1; i< dictSheet.size(); i++){ + DecisionSettings attribute = new DecisionSettings("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("xacml_id") || dictSheet.get(0)[j].equalsIgnoreCase("Settings ID")){ + attribute.setXacmlId(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("priority")){ + attribute.setPriority(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("datatype") || dictSheet.get(0)[j].equalsIgnoreCase("Data Type")){ + Datatype dataType = new Datatype(); + if(rows[j].equalsIgnoreCase("string")){ + dataType.setId(26); + }else if(rows[j].equalsIgnoreCase("integer")){ + dataType.setId(12); + }else if(rows[j].equalsIgnoreCase("double")){ + dataType.setId(25); + }else if(rows[j].equalsIgnoreCase("boolean")){ + dataType.setId(18); + }else if(rows[j].equalsIgnoreCase("user")){ + dataType.setId(29); + } + attribute.setDatatypeBean(dataType); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("PrefixList")){ + for(int i = 1; i< dictSheet.size(); i++){ + PrefixList attribute = new PrefixList("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("prefixListName") || dictSheet.get(0)[j].equalsIgnoreCase("PrefixList Name")){ + attribute.setPrefixListName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setPrefixListValue(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("prefixListValue") || dictSheet.get(0)[j].equalsIgnoreCase("PrefixList Value")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("SecurityZone")){ + for(int i = 1; i< dictSheet.size(); i++){ + SecurityZone attribute = new SecurityZone("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("zoneName") || dictSheet.get(0)[j].equalsIgnoreCase("Zone Name")){ + attribute.setZoneName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("zoneValue") || dictSheet.get(0)[j].equalsIgnoreCase("Zone Value")){ + attribute.setZoneValue(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("Zone")){ + for(int i = 1; i< dictSheet.size(); i++){ + Zone attribute = new Zone("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("zoneName") || dictSheet.get(0)[j].equalsIgnoreCase("Zone Name")){ + attribute.setZoneName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("zoneValue") || dictSheet.get(0)[j].equalsIgnoreCase("Zone Value")){ + attribute.setZoneValue(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("ServiceList")){ + for(int i = 1; i< dictSheet.size(); i++){ + ServiceList attribute = new ServiceList("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceName") || dictSheet.get(0)[j].equalsIgnoreCase("Service Name")){ + attribute.setServiceName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceDesc") || dictSheet.get(0)[j].equalsIgnoreCase("Description")){ + attribute.setServiceDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceType") || dictSheet.get(0)[j].equalsIgnoreCase("Service Type")){ + attribute.setServiceType(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceTrasProtocol") || dictSheet.get(0)[j].equalsIgnoreCase("Transport Protocol")){ + attribute.setServiceTransProtocol(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceAppProtocol") || dictSheet.get(0)[j].equalsIgnoreCase("APP Protocol")){ + attribute.setServiceAppProtocol(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("servicePorts") || dictSheet.get(0)[j].equalsIgnoreCase("Ports")){ + attribute.setServicePorts(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("ServiceGroup")){ + for(int i = 1; i< dictSheet.size(); i++){ + GroupServiceList attribute = new GroupServiceList("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("name") || dictSheet.get(0)[j].equalsIgnoreCase("Group Name")){ + attribute.setGroupName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceList") || dictSheet.get(0)[j].equalsIgnoreCase("Service List")){ + attribute.setServiceList(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("AddressGroup")){ + for(int i = 1; i< dictSheet.size(); i++){ + AddressGroup attribute = new AddressGroup("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("name") || dictSheet.get(0)[j].equalsIgnoreCase("Group Name")){ + attribute.setGroupName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("serviceList") || dictSheet.get(0)[j].equalsIgnoreCase("Prefix List")){ + attribute.setServiceList(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("ProtocolList")){ + for(int i = 1; i< dictSheet.size(); i++){ + ProtocolList attribute = new ProtocolList("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("protocolName") || dictSheet.get(0)[j].equalsIgnoreCase("Protocol Name")){ + attribute.setProtocolName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("ActionList")){ + for(int i = 1; i< dictSheet.size(); i++){ + ActionList attribute = new ActionList("", userId); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("actionName") || dictSheet.get(0)[j].equalsIgnoreCase("Action Name")){ + attribute.setActionName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("TermList")){ + for(int i = 1; i< dictSheet.size(); i++){ + TermList attribute = new TermList("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("termName") || dictSheet.get(0)[j].equalsIgnoreCase("Term-Name")){ + attribute.setTermName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("Term-Description") || dictSheet.get(0)[j].equalsIgnoreCase("termDescription")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("fromZone") || dictSheet.get(0)[j].equalsIgnoreCase("From Zone")){ + attribute.setFromZones(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("toZone") || dictSheet.get(0)[j].equalsIgnoreCase("To Zone")){ + attribute.setToZones(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("srcIPList") || dictSheet.get(0)[j].equalsIgnoreCase("Source-IP-List")){ + attribute.setSrcIPList(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("destIPList") || dictSheet.get(0)[j].equalsIgnoreCase("Destination-IP-List")){ + attribute.setDestIPList(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("srcPortList") || dictSheet.get(0)[j].equalsIgnoreCase("Source-Port-List")){ + attribute.setSrcPortList(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("destPortList") || dictSheet.get(0)[j].equalsIgnoreCase("Destination-Port-List")){ + attribute.setDestPortList(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("action") || dictSheet.get(0)[j].equalsIgnoreCase("Action List")){ + attribute.setAction(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + if(dictionaryName.startsWith("SearchCriteria")){ + for(int i = 1; i< dictSheet.size(); i++){ + DescriptiveScope attribute = new DescriptiveScope("", userId); + UserInfo userinfo = new UserInfo(); + userinfo.setUserLoginId(userId); + attribute.setUserCreatedBy(userinfo); + attribute.setUserModifiedBy(userinfo); + String[] rows = dictSheet.get(i); + for (int j=0 ; j<rows.length; j++ ){ + if(dictSheet.get(0)[j].equalsIgnoreCase("descriptiveScopeName") || dictSheet.get(0)[j].equalsIgnoreCase("Descriptive ScopeName")){ + attribute.setScopeName(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("description")){ + attribute.setDescription(rows[j]); + } + if(dictSheet.get(0)[j].equalsIgnoreCase("search") || dictSheet.get(0)[j].equalsIgnoreCase("Search Criteria")){ + attribute.setSearch(rows[j]); + } + } + commonClassDao.save(attribute); + } + } + csvReader.close(); + if(file.exists()){ + file.delete(); + } + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/EnforcerDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/EnforcerDictionaryController.java new file mode 100644 index 000000000..f0389fcde --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/EnforcerDictionaryController.java @@ -0,0 +1,139 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.EnforcingType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class EnforcerDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(EnforcerDictionaryController.class); + + @Autowired + CommonClassDao commonClassDao; + + @RequestMapping(value={"/get_EnforcerTypeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getEnforcerDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + List<Object> list = commonClassDao.getData(EnforcingType.class); + List<String> dictList = new ArrayList<>(); + for(int i = 0; i < list.size(); i++){ + EnforcingType dict = (EnforcingType) list.get(i); + dictList.add(dict.getEnforcingType()); + } + model.put("enforcerDictionaryDatas", mapper.writeValueAsString(dictList)); + org.onap.policy.pap.xacml.rest.util.JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/enforcer_dictionary/save_enforcerType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveEnforcerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + EnforcingType enforcingType = (EnforcingType)mapper.readValue(root.get("enforcerDictionaryData").toString(), EnforcingType.class); + if(enforcingType.getId() == 0){ + commonClassDao.save(enforcingType); + }else{ + commonClassDao.update(enforcingType); + } + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(EnforcingType.class)); + JSONObject j = new JSONObject("{enforcerDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/enforcer_dictionary/remove_enforcer"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeEnforcerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + EnforcingType enforcingType = (EnforcingType)mapper.readValue(root.get("data").toString(), EnforcingType.class); + commonClassDao.delete(enforcingType); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(EnforcingType.class)); + JSONObject j = new JSONObject("{enforcerDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/FirewallDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/FirewallDictionaryController.java new file mode 100644 index 000000000..ee2d1d622 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/FirewallDictionaryController.java @@ -0,0 +1,2279 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.jboss.netty.handler.ipfilter.CIDR; +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.adapters.GridData; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ActionList; +import org.onap.policy.rest.jpa.AddressGroup; +import org.onap.policy.rest.jpa.FWTag; +import org.onap.policy.rest.jpa.FWTagPicker; +import org.onap.policy.rest.jpa.FirewallDictionaryList; +import org.onap.policy.rest.jpa.GroupServiceList; +import org.onap.policy.rest.jpa.PrefixList; +import org.onap.policy.rest.jpa.PortList; +import org.onap.policy.rest.jpa.ProtocolList; +import org.onap.policy.rest.jpa.SecurityZone; +import org.onap.policy.rest.jpa.ServiceList; +import org.onap.policy.rest.jpa.TermList; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.rest.jpa.Zone; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + + +@Controller +public class FirewallDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(FirewallDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public FirewallDictionaryController(CommonClassDao commonClassDao){ + FirewallDictionaryController.commonClassDao = commonClassDao; + } + + public FirewallDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + + @RequestMapping(value={"/get_PrefixListDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPrefixListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("prefixListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PrefixList.class, "prefixListName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_PrefixListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPrefixListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("prefixListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PrefixList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_prefixList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PrefixList prefixList; + if (fromAPI) { + prefixList = (PrefixList)mapper.readValue(root.get("dictionaryFields").toString(), PrefixList.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(prefixList.getPrefixListName(), "prefixListName", PrefixList.class); + int id = 0; + PrefixList data = (PrefixList) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + prefixList.setId(1); + } else { + prefixList.setId(id); + } + } + } else { + prefixList = (PrefixList)mapper.readValue(root.get("prefixListDictionaryData").toString(), PrefixList.class); + } + if(prefixList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(prefixList.getPrefixListName(), "prefixListName", PrefixList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(prefixList); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(prefixList); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{prefixListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_PrefixList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PrefixList prefixList = (PrefixList)mapper.readValue(root.get("data").toString(), PrefixList.class); + commonClassDao.delete(prefixList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(PrefixList.class)); + JSONObject j = new JSONObject("{prefixListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/validate_prefixList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView validatePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PrefixList prefixList = (PrefixList)mapper.readValue(root.get("prefixListDictionaryData").toString(), PrefixList.class); + String responseValidation = "success"; + try{ + CIDR.newCIDR(prefixList.getPrefixListValue()); + }catch(UnknownHostException e){ + responseValidation = "error"; + } + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{result: " + responseValidation + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_PortListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPortListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("portListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PortList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_portName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePortListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PortList portList = (PortList)mapper.readValue(root.get("portListDictionaryData").toString(), PortList.class); + if(portList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(portList.getPortName(), "portName", PortList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(portList); + } + }else{ + commonClassDao.update(portList); + } + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PortList.class)); + } + JSONObject j = new JSONObject("{portListDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_PortList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePortListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PortList portList = (PortList)mapper.readValue(root.get("data").toString(), PortList.class); + commonClassDao.delete(portList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(PortList.class)); + JSONObject j = new JSONObject("{portListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_ProtocolListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getProtocolListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("protocolListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ProtocolList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_ProtocolListDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getProtocolListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("protocolListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ProtocolList.class, "protocolName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_protocolList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ProtocolList protocolList; + if (fromAPI) { + protocolList = (ProtocolList)mapper.readValue(root.get("dictionaryFields").toString(), ProtocolList.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(protocolList.getProtocolName(), "protocolName", ProtocolList.class); + int id = 0; + ProtocolList data = (ProtocolList) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + protocolList.setId(1); + } else { + protocolList.setId(id); + } + } + } else { + protocolList = (ProtocolList)mapper.readValue(root.get("protocolListDictionaryData").toString(), ProtocolList.class); + } + if(protocolList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(protocolList.getProtocolName(), "protocolName", ProtocolList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(protocolList); + } + }else{ + if(!isFakeUpdate){ + commonClassDao.update(protocolList); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(ProtocolList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{protocolListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_protocol"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ProtocolList protocolList = (ProtocolList)mapper.readValue(root.get("data").toString(), ProtocolList.class); + commonClassDao.delete(protocolList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(ProtocolList.class)); + JSONObject j = new JSONObject("{protocolListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_AddressGroupDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getAddressGroupDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("addressGroupDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(AddressGroup.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_AddressGroupData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getAddressGroupDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("addressGroupDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(AddressGroup.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_addressGroup"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + AddressGroup addressGroup; + GridData gridData; + if (fromAPI) { + addressGroup = (AddressGroup)mapper.readValue(root.get("dictionaryFields").toString(), AddressGroup.class); + gridData = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class); + + if(!addressGroup.getGroupName().startsWith("Group_")){ + String groupName = "Group_"+addressGroup.getGroupName(); + addressGroup.setGroupName(groupName); + } + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(addressGroup.getGroupName(), "name", AddressGroup.class); + int id = 0; + AddressGroup data = (AddressGroup) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + addressGroup.setId(1); + } else { + addressGroup.setId(id); + } + } + } else { + addressGroup = (AddressGroup)mapper.readValue(root.get("addressGroupDictionaryData").toString(), AddressGroup.class); + gridData = (GridData)mapper.readValue(root.get("addressGroupDictionaryData").toString(), GridData.class); + if(!addressGroup.getGroupName().startsWith("Group_")){ + String groupName = "Group_"+addressGroup.getGroupName(); + addressGroup.setGroupName(groupName); + } + } + String userValue = ""; + int counter = 0; + if(gridData.getAttributes().size() > 0){ + for(Object attribute : gridData.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(counter>0){ + userValue = userValue + ","; + } + userValue = userValue + key ; + counter ++; + } + } + } + addressGroup.setServiceList(userValue); + if(addressGroup.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(addressGroup.getGroupName(), "name", AddressGroup.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(addressGroup); + } + }else{ + if (!isFakeUpdate) { + commonClassDao.update(addressGroup); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(AddressGroup.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{addressGroupDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_AddressGroup"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + AddressGroup addressGroup = (AddressGroup)mapper.readValue(root.get("data").toString(), AddressGroup.class); + commonClassDao.delete(addressGroup); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(AddressGroup.class)); + JSONObject j = new JSONObject("{addressGroupDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_ActionListDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getActionListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + List<Object> list = commonClassDao.getData(ActionList.class); + List<String> dictList = new ArrayList<>(); + for(int i = 0; i < list.size(); i++){ + ActionList dict = (ActionList) list.get(i); + dictList.add(dict.getActionName()); + } + model.put("actionListDictionaryDatas", mapper.writeValueAsString(dictList)); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_ActionListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getActionListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("actionListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ActionList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_ActionList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveActionListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ActionList actionList; + if (fromAPI) { + actionList = (ActionList)mapper.readValue(root.get("dictionaryFields").toString(), ActionList.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(actionList.getActionName(), "actionName", ActionList.class); + int id = 0; + ActionList data = (ActionList) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + actionList.setId(1); + } else { + actionList.setId(id); + } + } + } else { + actionList = (ActionList)mapper.readValue(root.get("actionListDictionaryData").toString(), ActionList.class); + } + if(actionList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(actionList.getActionName(), "actionName", ActionList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(actionList); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(actionList); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(ActionList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{actionListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_ActionList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeActionListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ActionList actionList = (ActionList)mapper.readValue(root.get("data").toString(), ActionList.class); + commonClassDao.delete(actionList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(ActionList.class)); + JSONObject j = new JSONObject("{actionListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_ServiceGroupData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getServiceGroupDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("serviceGroupDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(GroupServiceList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_ServiceGroupDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getServiceGroupDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("serviceGroupDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(GroupServiceList.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_serviceGroup"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + GroupServiceList groupServiceList; + GridData gridData; + if (fromAPI) { + groupServiceList = (GroupServiceList)mapper.readValue(root.get("dictionaryFields").toString(), GroupServiceList.class); + gridData = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class); + + if(!groupServiceList.getGroupName().startsWith("Group_")){ + String groupName = "Group_"+groupServiceList.getGroupName(); + groupServiceList.setGroupName(groupName); + } + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(groupServiceList.getGroupName(), "name", GroupServiceList.class); + int id = 0; + GroupServiceList data = (GroupServiceList) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + groupServiceList.setId(1); + } else { + groupServiceList.setId(id); + } + } + } else { + groupServiceList = (GroupServiceList)mapper.readValue(root.get("serviceGroupDictionaryData").toString(), GroupServiceList.class); + gridData = (GridData)mapper.readValue(root.get("serviceGroupDictionaryData").toString(), GridData.class); + } + if(!groupServiceList.getGroupName().startsWith("Group_")){ + String groupName = "Group_"+groupServiceList.getGroupName(); + groupServiceList.setGroupName(groupName); + } + String userValue = ""; + int counter = 0; + if(gridData.getAttributes().size() > 0){ + for(Object attribute : gridData.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(counter>0){ + userValue = userValue + ","; + } + userValue = userValue + key ; + counter ++; + } + } + } + groupServiceList.setServiceList(userValue); + if(groupServiceList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(groupServiceList.getGroupName(), "name", GroupServiceList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(groupServiceList); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(groupServiceList); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(GroupServiceList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{serviceGroupDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_serviceGroup"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + GroupServiceList groupServiceList = (GroupServiceList)mapper.readValue(root.get("data").toString(), GroupServiceList.class); + commonClassDao.delete(groupServiceList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(GroupServiceList.class)); + JSONObject j = new JSONObject("{serviceGroupDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_SecurityZoneDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getSecurityZoneDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("securityZoneDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(SecurityZone.class, "zoneName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_SecurityZoneData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getSecurityZoneDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("securityZoneDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(SecurityZone.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_securityZone"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + SecurityZone securityZone; + if (fromAPI) { + securityZone = (SecurityZone)mapper.readValue(root.get("dictionaryFields").toString(), SecurityZone.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(securityZone.getZoneName(), "zoneName", SecurityZone.class); + int id = 0; + SecurityZone data = (SecurityZone) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + securityZone.setId(1); + } else { + securityZone.setId(id); + } + } + } else { + securityZone = (SecurityZone)mapper.readValue(root.get("securityZoneDictionaryData").toString(), SecurityZone.class); + } + if(securityZone.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(securityZone.getZoneName(), "zoneName", SecurityZone.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(securityZone); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(securityZone); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(SecurityZone.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{securityZoneDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_securityZone"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + SecurityZone securityZone = (SecurityZone)mapper.readValue(root.get("data").toString(), SecurityZone.class); + commonClassDao.delete(securityZone); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(SecurityZone.class)); + JSONObject j = new JSONObject("{securityZoneDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_ServiceListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getServiceListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("serviceListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(ServiceList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/get_ServiceListDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getServiceListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("serviceListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(ServiceList.class, "serviceName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_serviceList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ServiceList serviceList; + GridData serviceListGridData; + if (fromAPI) { + serviceList = (ServiceList)mapper.readValue(root.get("dictionaryFields").toString(), ServiceList.class); + serviceListGridData = (GridData)mapper.readValue(root.get("dictionaryFields").toString(), GridData.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceList.getServiceName(), "serviceName", ServiceList.class); + int id = 0; + ServiceList data = (ServiceList) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + serviceList.setId(1); + } else { + serviceList.setId(id); + } + } + }else{ + serviceList = (ServiceList)mapper.readValue(root.get("serviceListDictionaryData").toString(), ServiceList.class); + serviceListGridData = (GridData)mapper.readValue(root.get("serviceListDictionaryData").toString(), GridData.class); + } + String tcpValue = ""; + int counter = 0; + if(serviceListGridData.getTransportProtocols().size() > 0){ + for(Object attribute : serviceListGridData.getTransportProtocols()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(counter>0){ + tcpValue = tcpValue + ","; + } + tcpValue = tcpValue + key ; + counter ++; + } + } + } + serviceList.setServiceTransProtocol(tcpValue); + String appValue = ""; + int counter1 = 0; + if(serviceListGridData.getAppProtocols().size() > 0){ + for(Object attribute : serviceListGridData.getAppProtocols()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(counter1>0){ + appValue = appValue + ","; + } + appValue = appValue + key ; + counter1 ++; + } + } + } + serviceList.setServiceAppProtocol(appValue); + serviceList.setServiceType("SERVICE"); + if(serviceList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(serviceList.getServiceName(), "serviceName", ServiceList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(serviceList); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(serviceList); + } + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(ServiceList.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{serviceListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_serviceList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + ServiceList serviceList = (ServiceList)mapper.readValue(root.get("data").toString(), ServiceList.class); + commonClassDao.delete(serviceList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(ServiceList.class)); + JSONObject j = new JSONObject("{serviceListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_ZoneData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getZoneDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("zoneDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(Zone.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_ZoneDictionaryDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getZoneDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("zoneDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(Zone.class, "zoneName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_zoneName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + Zone zone; + if (fromAPI) { + zone = (Zone)mapper.readValue(root.get("dictionaryFields").toString(), Zone.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(zone.getZoneName(), "zoneName", Zone.class); + int id = 0; + Zone data = (Zone) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + zone.setId(1); + } else { + zone.setId(id); + } + } + } else { + zone = (Zone)mapper.readValue(root.get("zoneDictionaryData").toString(), Zone.class); + } + if(zone.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(zone.getZoneName(), "zoneName", Zone.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(zone); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(zone); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(Zone.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{zoneDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_zone"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + Zone zone = (Zone)mapper.readValue(root.get("data").toString(), Zone.class); + commonClassDao.delete(zone); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(Zone.class)); + JSONObject j = new JSONObject("{zoneDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_TermListDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTermListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("termListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(TermList.class, "termName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_TermListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTermListDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("termListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(TermList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_termList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + TermList termList; + TermListData termListDatas; + String userId = null; + if (fromAPI) { + termList = (TermList)mapper.readValue(root.get("dictionaryFields").toString(), TermList.class); + termListDatas = (TermListData)mapper.readValue(root.get("dictionaryFields").toString(), TermListData.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(termList.getTermName(), "termName", TermList.class); + int id = 0; + TermList data = (TermList) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + termList.setId(1); + } else { + termList.setId(id); + } + termList.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + termList = (TermList)mapper.readValue(root.get("termListDictionaryData").toString(), TermList.class); + termListDatas = (TermListData)mapper.readValue(root.get("termListDictionaryData").toString(), TermListData.class); + userId = root.get("userid").textValue(); + } + String fromZoneValue = ""; + int counter = 0; + if(termListDatas.getFromZoneDatas().size() > 0){ + for(Object fromZone : termListDatas.getFromZoneDatas()){ + if(fromZone instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) fromZone).get("option").toString(); + if(counter>0){ + fromZoneValue = fromZoneValue + ","; + } + fromZoneValue = fromZoneValue + key ; + counter ++; + } + } + } + termList.setFromZones(fromZoneValue); + + String toZoneValue = ""; + int toZonecounter = 0; + if(termListDatas.getToZoneDatas().size() > 0){ + for(Object toZone : termListDatas.getToZoneDatas()){ + if(toZone instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) toZone).get("option").toString(); + if(toZonecounter>0){ + toZoneValue = toZoneValue + ","; + } + toZoneValue = toZoneValue + key ; + toZonecounter ++; + } + } + } + termList.setToZones(toZoneValue); + + String srcListValues = ""; + int srcListcounter = 0; + if(termListDatas.getSourceListDatas().size() > 0){ + for(Object srcList : termListDatas.getSourceListDatas()){ + if(srcList instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) srcList).get("option").toString(); + if(srcListcounter>0){ + srcListValues = srcListValues + ","; + } + srcListValues = srcListValues + key ; + srcListcounter ++; + } + } + } + termList.setSrcIPList(srcListValues); + + String desListValues = ""; + int destListcounter = 0; + if(termListDatas.getDestinationListDatas().size() > 0){ + for(Object desList : termListDatas.getDestinationListDatas()){ + if(desList instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) desList).get("option").toString(); + if(destListcounter>0){ + desListValues = desListValues + ","; + } + desListValues = desListValues + key ; + destListcounter ++; + } + } + } + termList.setDestIPList(desListValues); + + String srcSerValue = ""; + int srcSercounter = 0; + if(termListDatas.getSourceServiceDatas().size() > 0){ + for(Object srcSrc : termListDatas.getSourceServiceDatas()){ + if(srcSrc instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) srcSrc).get("option").toString(); + if(srcSercounter>0){ + srcSerValue = srcSerValue + ","; + } + srcSerValue = srcSerValue + key ; + srcSercounter ++; + } + } + } + termList.setSrcPortList(srcSerValue); + + String desSrcValue = ""; + int desSrccounter = 0; + if(termListDatas.getDestinationServiceDatas().size() > 0){ + for(Object desSrc : termListDatas.getDestinationServiceDatas()){ + if(desSrc instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) desSrc).get("option").toString(); + if(desSrccounter>0){ + desSrcValue = desSrcValue + ","; + } + desSrcValue = desSrcValue + key ; + desSrccounter ++; + } + } + } + termList.setDestPortList(desSrcValue); + + String actionValue = ""; + int actioncounter = 0; + if(termListDatas.getActionListDatas().size() > 0){ + for(Object actionList : termListDatas.getActionListDatas()){ + if(actionList instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) actionList).get("option").toString(); + if(actioncounter>0){ + actionValue = actionValue + ","; + } + actionValue = actionValue + key ; + actioncounter ++; + } + } + } + termList.setAction(actionValue); + + if(termList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(termList.getTermName(), "termName", TermList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + termList.setUserCreatedBy(this.getUserInfo(userId)); + termList.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(termList); + } + }else{ + if(!isFakeUpdate) { + termList.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.update(termList); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(TermList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{termListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_termList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + TermList termList = (TermList)mapper.readValue(root.get("data").toString(), TermList.class); + commonClassDao.delete(termList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(TermList.class)); + JSONObject j = new JSONObject("{termListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + //ParentList Dictionary Data + @RequestMapping(value={"/get_FWDictionaryListDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getFWDictListDictionaryEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwDictListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(FirewallDictionaryList.class, "parentItemName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_FWDictionaryListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getFWDictionaryListEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwDictListDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(FirewallDictionaryList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value={"/fw_dictionary/save_FWDictionaryList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveFWDictionaryList(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + FirewallDictionaryList fwDictList = (FirewallDictionaryList)mapper.readValue(root.get("fwDictListDictionaryData").toString(), FirewallDictionaryList.class); + GridData gridData = (GridData)mapper.readValue(root.get("fwDictListDictionaryData").toString(), GridData.class); + String userSLValue = ""; + int slcounter = 0; + if(gridData.getAttributes().size() > 0){ + for(Object attribute : gridData.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(slcounter>0){ + userSLValue = userSLValue + ","; + } + userSLValue = userSLValue + key ; + slcounter ++; + } + } + } + fwDictList.setServiceList(userSLValue); + String userALValue = ""; + int alcounter = 0; + if(gridData.getAlAttributes().size() > 0){ + for(Object attribute : gridData.getAlAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + if(alcounter>0){ + userALValue = userALValue + ","; + } + userALValue = userALValue + key ; + alcounter ++; + } + } + } + fwDictList.setAddressList(userALValue); + if(fwDictList.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(fwDictList.getParentItemName(), "parentItemName", FirewallDictionaryList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(fwDictList); + } + }else{ + commonClassDao.update(fwDictList); + } + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(FirewallDictionaryList.class)); + } + JSONObject j = new JSONObject("{fwDictListDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_FWDictionaryList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeFWDictionaryListy(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + FirewallDictionaryList fwDictList = (FirewallDictionaryList)mapper.readValue(root.get("data").toString(), FirewallDictionaryList.class); + commonClassDao.delete(fwDictList); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(FirewallDictionaryList.class)); + JSONObject j = new JSONObject("{fwDictListDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_TagPickerNameByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTagPickerNameEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwTagPickerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(FWTagPicker.class, "tagPickerName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_TagPickerListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTagPickerDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<String, Object>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwTagPickerDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(FWTagPicker.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_fwTagPicker"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveFirewallTagPickerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + + + FWTagPicker fwTagPicker; + TagGridValues data; + String userId = null; + if (fromAPI) { + fwTagPicker = (FWTagPicker)mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), FWTagPicker.class); + data = (TagGridValues)mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), TagGridValues.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(fwTagPicker.getTagPickerName(), "tagPickerName", FWTagPicker.class); + int id = 0; + FWTagPicker dbdata = (FWTagPicker) duplicateData.get(0); + id = dbdata.getId(); + fwTagPicker.setId(id); + fwTagPicker.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + + fwTagPicker = (FWTagPicker)mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), FWTagPicker.class); + data = (TagGridValues)mapper.readValue(root.get("fwTagPickerDictionaryData").toString(), TagGridValues.class); + userId = root.get("userid").textValue(); + } + + String header = ""; + int counter = 0; + if(data.getTags().size() > 0){ + for(Object attribute : data.getTags()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("option").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("number").toString(); + if(counter>0){ + header = header + "#"; + } + header = header + key + ":"; + header = header + value; + counter ++; + } + } + } + fwTagPicker.setTagValues(header); + if(fwTagPicker.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(fwTagPicker.getTagPickerName(), "tagPickerName", FWTagPicker.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + fwTagPicker.setUserCreatedBy(this.getUserInfo(userId)); + fwTagPicker.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(fwTagPicker); + } + }else{ + fwTagPicker.setUserModifiedBy(this.getUserInfo(userId)); + fwTagPicker.setModifiedDate(new Date()); + commonClassDao.update(fwTagPicker); + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(FWTagPicker.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{fwTagPickerDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_tagPicker"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeFirewallTagPickerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + FWTagPicker fwTagPicker = (FWTagPicker)mapper.readValue(root.get("data").toString(), FWTagPicker.class); + commonClassDao.delete(fwTagPicker); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + String responseString = mapper.writeValueAsString(commonClassDao.getData(FWTagPicker.class)); + JSONObject j = new JSONObject("{fwTagPickerDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_TagNameByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTagNameEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwTagDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(FWTag.class, "fwTagName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/get_TagListData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getTagDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("fwTagDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(FWTag.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + } + + @RequestMapping(value={"/fw_dictionary/save_fwTag"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveFirewallTagDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + + + FWTag fwTag; + TagGridValues tagGridValues; + String userId = null; + if (fromAPI) { + fwTag = (FWTag)mapper.readValue(root.get("fwTagDictionaryDatas").toString(), FWTag.class); + tagGridValues = (TagGridValues)mapper.readValue(root.get("fwTagDictionaryDatas").toString(), TagGridValues.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(fwTag.getFwTagName(), "tagName", FWTag.class); + int id = 0; + FWTag data = (FWTag) duplicateData.get(0); + id = data.getId(); + fwTag.setId(id); + fwTag.setUserCreatedBy(this.getUserInfo(userId)); + + } + } else { + fwTag = (FWTag)mapper.readValue(root.get("fwTagDictionaryData").toString(), FWTag.class); + tagGridValues = (TagGridValues)mapper.readValue(root.get("fwTagDictionaryData").toString(), TagGridValues.class); + userId = root.get("userid").textValue(); + } + + String userValue = ""; + int counter = 0; + if(tagGridValues.getTags().size() > 0){ + for(Object attribute : tagGridValues.getTags()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("tags").toString(); + if(counter>0){ + userValue = userValue + ","; + } + userValue = userValue + key ; + counter ++; + } + } + } + fwTag.setTagValues(userValue); + if(fwTag.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(fwTag.getFwTagName(), "fwTagName", FWTag.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + fwTag.setUserCreatedBy(this.getUserInfo(userId)); + fwTag.setUserModifiedBy(this.getUserInfo(userId)); + commonClassDao.save(fwTag); + } + }else{ + fwTag.setUserModifiedBy(this.getUserInfo(userId)); + fwTag.setModifiedDate(new Date()); + commonClassDao.update(fwTag); + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(FWTag.class)); + } + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{fwTagDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/fw_dictionary/remove_tagList"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeFirewallTagDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + FWTag fwTag = (FWTag)mapper.readValue(root.get("data").toString(), FWTag.class); + commonClassDao.delete(fwTag); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(FWTag.class)); + JSONObject j = new JSONObject("{fwTagDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } +} + +class TagGridValues{ + private ArrayList<Object> tags; + + public ArrayList<Object> getTags() { + return tags; + } + + public void setTags(ArrayList<Object> tags) { + this.tags = tags; + } +} + +class AGGridData{ + private ArrayList<Object> attributes; + + public ArrayList<Object> getAttributes() { + return attributes; + } + + public void setAttributes(ArrayList<Object> attributes) { + this.attributes = attributes; + } +} + +class TermListData{ + private ArrayList<Object> fromZoneDatas; + private ArrayList<Object> toZoneDatas; + private ArrayList<Object> sourceListDatas; + private ArrayList<Object> destinationListDatas; + private ArrayList<Object> sourceServiceDatas; + private ArrayList<Object> destinationServiceDatas; + private ArrayList<Object> actionListDatas; + public ArrayList<Object> getFromZoneDatas() { + return fromZoneDatas; + } + public void setFromZoneDatas(ArrayList<Object> fromZoneDatas) { + this.fromZoneDatas = fromZoneDatas; + } + public ArrayList<Object> getToZoneDatas() { + return toZoneDatas; + } + public void setToZoneDatas(ArrayList<Object> toZoneDatas) { + this.toZoneDatas = toZoneDatas; + } + public ArrayList<Object> getSourceListDatas() { + return sourceListDatas; + } + public void setSourceListDatas(ArrayList<Object> sourceListDatas) { + this.sourceListDatas = sourceListDatas; + } + public ArrayList<Object> getDestinationListDatas() { + return destinationListDatas; + } + public void setDestinationListDatas(ArrayList<Object> destinationListDatas) { + this.destinationListDatas = destinationListDatas; + } + public ArrayList<Object> getSourceServiceDatas() { + return sourceServiceDatas; + } + public void setSourceServiceDatas(ArrayList<Object> sourceServiceDatas) { + this.sourceServiceDatas = sourceServiceDatas; + } + public ArrayList<Object> getDestinationServiceDatas() { + return destinationServiceDatas; + } + public void setDestinationServiceDatas(ArrayList<Object> destinationServiceDatas) { + this.destinationServiceDatas = destinationServiceDatas; + } + public ArrayList<Object> getActionListDatas() { + return actionListDatas; + } + public void setActionListDatas(ArrayList<Object> actionListDatas) { + this.actionListDatas = actionListDatas; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/MicroServiceDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/MicroServiceDictionaryController.java new file mode 100644 index 000000000..621f0c474 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/MicroServiceDictionaryController.java @@ -0,0 +1,1051 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.lang.StringUtils; +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.DCAEuuid; +import org.onap.policy.rest.jpa.MicroServiceAttribute; +import org.onap.policy.rest.jpa.MicroServiceConfigName; +import org.onap.policy.rest.jpa.MicroServiceLocation; +import org.onap.policy.rest.jpa.MicroServiceModels; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.rest.util.MSAttributeObject; +import org.onap.policy.rest.util.MSModelUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.gson.Gson; + +@Controller +public class MicroServiceDictionaryController { + private static final Logger LOGGER = FlexLogger.getLogger(MicroServiceDictionaryController.class); + + private static CommonClassDao commonClassDao; + + public static void setCommonClassDao(CommonClassDao commonClassDao) { + MicroServiceDictionaryController.commonClassDao = commonClassDao; + } + + @Autowired + public MicroServiceDictionaryController(CommonClassDao commonClassDao){ + MicroServiceDictionaryController.commonClassDao = commonClassDao; + } + + public MicroServiceDictionaryController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + private static String SUCCESSKEY= "successMapKey"; + private static String SUCCESS = "success"; + private static String OPERATION = "operation"; + private static String GETDICTIONARY = "getDictionary"; + private static String ERROR = "error"; + private static String DICTIONARYDBQUERY = "dictionaryDBQuery"; + private HashMap<String,MSAttributeObject > classMap; + private List<String> modelList = new ArrayList<>(); + + + + MSModelUtils utils = new MSModelUtils(XACMLPapServlet.getMsOnapName(), XACMLPapServlet.getMsPolicyName()); + private MicroServiceModels newModel; + + + @RequestMapping(value={"/get_DCAEUUIDDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getDCAEUUIDDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("dcaeUUIDDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(DCAEuuid.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e); + } + } + + @RequestMapping(value={"/get_DCAEUUIDData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getDCAEUUIDDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("dcaeUUIDDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/ms_dictionary/save_dcaeUUID"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DCAEuuid dCAEuuid; + if (fromAPI) { + dCAEuuid = (DCAEuuid)mapper.readValue(root.get("dictionaryFields").toString(), DCAEuuid.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter(OPERATION).equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dCAEuuid.getName(), "name", DCAEuuid.class); + int id = 0; + DCAEuuid data = (DCAEuuid) duplicateData.get(0); + id = data.getId(); + if(id==0){ + isFakeUpdate=true; + dCAEuuid.setId(1); + } else { + dCAEuuid.setId(id); + } + } + } else { + dCAEuuid = (DCAEuuid)mapper.readValue(root.get("dcaeUUIDDictionaryData").toString(), DCAEuuid.class); + } + if(dCAEuuid.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(dCAEuuid.getName(), "name", DCAEuuid.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(dCAEuuid); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(dCAEuuid); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{dcaeUUIDDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ms_dictionary/remove_dcaeuuid"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + DCAEuuid dCAEuuid = (DCAEuuid)mapper.readValue(root.get("data").toString(), DCAEuuid.class); + commonClassDao.delete(dCAEuuid); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(DCAEuuid.class)); + JSONObject j = new JSONObject("{dcaeUUIDDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_MicroServiceConfigNameDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceConfigNameByNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceCongigNameDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(MicroServiceConfigName.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e); + } + } + + + + @RequestMapping(value={"/get_MicroServiceConfigNameData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceConfigNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceCongigNameDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/ms_dictionary/save_configName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceConfigName microServiceConfigName; + if (fromAPI) { + microServiceConfigName = (MicroServiceConfigName)mapper.readValue(root.get("dictionaryFields").toString(), MicroServiceConfigName.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter(OPERATION).equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceConfigName.getName(), "name", MicroServiceConfigName.class); + int id = 0; + MicroServiceConfigName data = (MicroServiceConfigName) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + microServiceConfigName.setId(1); + } else { + microServiceConfigName.setId(id); + } + } + } else { + microServiceConfigName = (MicroServiceConfigName)mapper.readValue(root.get("microServiceCongigNameDictionaryData").toString(), MicroServiceConfigName.class); + } + if(microServiceConfigName.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceConfigName.getName(), "name", MicroServiceConfigName.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(microServiceConfigName); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(microServiceConfigName); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{microServiceCongigNameDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ms_dictionary/remove_msConfigName"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceConfigName microServiceConfigName = (MicroServiceConfigName)mapper.readValue(root.get("data").toString(), MicroServiceConfigName.class); + commonClassDao.delete(microServiceConfigName); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceConfigName.class)); + JSONObject j = new JSONObject("{microServiceCongigNameDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_MicroServiceLocationDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceLocationByNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceLocationDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(MicroServiceLocation.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e); + } + } + + @RequestMapping(value={"/get_MicroServiceLocationData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceLocationDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceLocationDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/ms_dictionary/save_location"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceLocation microServiceLocation; + if (fromAPI) { + microServiceLocation = (MicroServiceLocation)mapper.readValue(root.get("dictionaryFields").toString(), MicroServiceLocation.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter(OPERATION).equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceLocation.getName(), "name", MicroServiceLocation.class); + int id = 0; + MicroServiceLocation data = (MicroServiceLocation) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + microServiceLocation.setId(1); + } else { + microServiceLocation.setId(id); + } + } + } else { + microServiceLocation = (MicroServiceLocation)mapper.readValue(root.get("microServiceLocationDictionaryData").toString(), MicroServiceLocation.class); + } + if(microServiceLocation.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(microServiceLocation.getName(), "name", MicroServiceLocation.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(microServiceLocation); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(microServiceLocation); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{microServiceLocationDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ms_dictionary/remove_msLocation"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceLocation microServiceLocation = (MicroServiceLocation)mapper.readValue(root.get("data").toString(), MicroServiceLocation.class); + commonClassDao.delete(microServiceLocation); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceLocation.class)); + JSONObject j = new JSONObject("{microServiceLocationDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_MicroServiceAttributeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceAttributeByNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceAttributeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(MicroServiceAttribute.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/get_MicroServiceAttributeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceAttributeDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceAttributeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/ms_dictionary/save_modelAttribute"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + + MicroServiceAttribute microServiceAttribute; + if (fromAPI) { + microServiceAttribute = (MicroServiceAttribute)mapper.readValue(root.get("dictionaryFields").toString(), MicroServiceAttribute.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter(OPERATION).equals("update")) { + MicroServiceAttribute initialAttribute = (MicroServiceAttribute)mapper.readValue(root.get("initialFields").toString(), MicroServiceAttribute.class); + + String checkValue = initialAttribute.getName() + ":" + initialAttribute.getValue() + ":" + initialAttribute.getModelName(); + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(checkValue, "name:value:modelName", MicroServiceAttribute.class); + int id=0; + for (int i= 0; i<duplicateData.size(); i++){ + MicroServiceAttribute data = (MicroServiceAttribute) duplicateData.get(0); + id = data.getId(); + } + microServiceAttribute.setId(id); + } + } else { + microServiceAttribute = (MicroServiceAttribute)mapper.readValue(root.get("modelAttributeDictionaryData").toString(), MicroServiceAttribute.class); + } + + if(microServiceAttribute.getId() == 0){ + String checkValue = microServiceAttribute.getName() + ":" + microServiceAttribute.getValue() + ":" + microServiceAttribute.getModelName(); + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(checkValue, "name:value:modelName", MicroServiceAttribute.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(microServiceAttribute); + } + }else{ + commonClassDao.update(microServiceAttribute); + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceAttribute.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{microServiceAttributeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + } + catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ms_dictionary/remove_modelAttribute"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeMicroServiceAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceAttribute microServiceAttribute = (MicroServiceAttribute)mapper.readValue(root.get("data").toString(), MicroServiceAttribute.class); + commonClassDao.delete(microServiceAttribute); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(MicroServiceDictionaryController.commonClassDao.getData(MicroServiceAttribute.class)); + JSONObject j = new JSONObject("{microServiceAttributeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + + @RequestMapping(value={"/get_MicroServiceModelsDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceModelsDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceModelsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(MicroServiceModels.class, "modelName"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/get_MicroServiceModelsDataByVersion"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceModelsDictionaryByVersionEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + JsonNode root = mapper.readTree(request.getReader()); + String modelName = null; + if (root.get("microServiceModelsDictionaryData").has("modelName")){ + modelName = root.get("microServiceModelsDictionaryData").get("modelName").asText().replace("\"", ""); + } + if (modelName!=null){ + model.put("microServiceModelsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataById(MicroServiceModels.class, "modelName", modelName))); + } else{ + model.put(ERROR, "No model name given"); + } + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/get_MicroServiceModelsData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceModelsDictionaryEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceModelsDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(MicroServiceModels.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/get_MicroServiceModelsDataServiceVersion"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceModelsDictionaryEntityDataServiceVersion(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + List<String> data = new ArrayList<>(); + List<Object> datas = commonClassDao.getData(MicroServiceModels.class); + for(int i = 0; i < datas.size(); i++){ + MicroServiceModels msmodel = (MicroServiceModels) datas.get(i); + if (!data.contains(msmodel.getModelName())){ + data.add(msmodel.getModelName() + "-v" + msmodel.getVersion()); + } + } + model.put("microServiceModelsDictionaryDatas", mapper.writeValueAsString(data)); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/get_MicroServiceModelsDataByClass"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getMicroServiceModelsDictionaryClassEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("microServiceModelsDictionaryClassDatas", mapper.writeValueAsString(modelList)); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSKEY, SUCCESS); + response.addHeader(OPERATION, GETDICTIONARY); + response.getWriter().write(j.toString()); + + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader(ERROR, DICTIONARYDBQUERY); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value={"/ms_dictionary/save_model"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean fromAPI = false; + this.newModel = new MicroServiceModels(); + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceModels microServiceModels = new MicroServiceModels(); + String userId = null; + + if(root.has("modelType")){ + JsonNode dataType = root.get("modelType"); + String modelType= dataType.toString(); + if(modelType.contains("yml")){ + if (root.has("microServiceModelsDictionaryData")){ + if (root.get("microServiceModelsDictionaryData").has("description")){ + microServiceModels.setDescription(root.get("microServiceModelsDictionaryData").get("description").asText().replace("\"", "")); + } + if (root.get("microServiceModelsDictionaryData").has("modelName")){ + microServiceModels.setModelName(root.get("microServiceModelsDictionaryData").get("modelName").asText().replace("\"", "")); + this.newModel.setModelName(microServiceModels.getModelName()); + } + if (root.get("microServiceModelsDictionaryData").has("version")){ + microServiceModels.setVersion(root.get("microServiceModelsDictionaryData").get("version").asText().replace("\"", "")); + this.newModel.setVersion(microServiceModels.getVersion()); + } + } + + MSAttributeObject mainClass = null; + classMap = new HashMap<>(); + JsonNode data = root.get("classMap"); + ObjectMapper mapper1 = new ObjectMapper(); + String data1 = data.toString().substring(1, data.toString().length()-1); + data1 = data1.replace("\\", ""); + data1=data1.replace("\"{","{"); + data1=data1.replace("}\"","}"); + JSONObject jsonObject = new JSONObject(data1); + Set<String> keys = jsonObject.keySet(); + for(String key : keys){ + String value = jsonObject.get(key).toString(); + MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class); + classMap.put(key, msAttributeObject); + } + + userId = root.get("userid").textValue(); + mainClass = classMap.get(this.newModel.getModelName()); + this.newModel.setDependency("[]"); + String value = new Gson().toJson(mainClass.getSubClass()); + this.newModel.setSub_attributes(value); + String attributes= mainClass.getAttribute().toString().replace("{", "").replace("}", ""); + int equalsIndexForAttributes= attributes.indexOf("="); + String atttributesAfterFirstEquals= attributes.substring(equalsIndexForAttributes+1); + this.newModel.setAttributes(atttributesAfterFirstEquals); + String refAttributes= mainClass.getRefAttribute().toString().replace("{", "").replace("}", ""); + int equalsIndex= refAttributes.indexOf("="); + String refAttributesAfterFirstEquals= refAttributes.substring(equalsIndex+1); + this.newModel.setRef_attributes(refAttributesAfterFirstEquals); + this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", "")); + this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", "")); + + }else{ + if (fromAPI) { + microServiceModels = (MicroServiceModels)mapper.readValue(root.get("dictionaryFields").toString(), MicroServiceModels.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter(OPERATION).equals("update")) { + String checkName = microServiceModels.getModelName() + ":" + microServiceModels.getVersion(); + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(checkName, "modelName:version", MicroServiceModels.class); + int id = 0; + for (int i=0; i< duplicateData.size(); i++){ + MicroServiceModels data = (MicroServiceModels) duplicateData.get(0); + id = data.getId(); + } + microServiceModels.setId(id); + microServiceModels.setUserCreatedBy(this.getUserInfo(userId)); + + } + } else { + if (root.has("microServiceModelsDictionaryData")){ + if (root.get("microServiceModelsDictionaryData").has("description")){ + microServiceModels.setDescription(root.get("microServiceModelsDictionaryData").get("description").asText().replace("\"", "")); + } + if (root.get("microServiceModelsDictionaryData").has("modelName")){ + microServiceModels.setModelName(root.get("microServiceModelsDictionaryData").get("modelName").asText().replace("\"", "")); + this.newModel.setModelName(microServiceModels.getModelName()); + } + if (root.get("microServiceModelsDictionaryData").has("version")){ + microServiceModels.setVersion(root.get("microServiceModelsDictionaryData").get("version").asText().replace("\"", "")); + this.newModel.setVersion(microServiceModels.getVersion()); + } + } + if(root.has("classMap")){ + classMap = new HashMap<>(); + JsonNode data = root.get("classMap"); + ObjectMapper mapper1 = new ObjectMapper(); + String data1 = data.toString().substring(1, data.toString().length()-1); + data1 = data1.replace("\\", ""); + JSONObject jsonObject = new JSONObject(data1); + Set<String> keys = jsonObject.keySet(); + for(String key : keys){ + String value = jsonObject.get(key).toString(); + MSAttributeObject msAttributeObject = mapper1.readValue(value, MSAttributeObject.class); + classMap.put(key, msAttributeObject); + } + } + userId = root.get("userid").textValue(); + addValuesToNewModel(classMap); + } + } + + } + microServiceModels.setAttributes(this.newModel.getAttributes()); + microServiceModels.setRef_attributes(this.newModel.getRef_attributes()); + microServiceModels.setDependency(this.newModel.getDependency()); + microServiceModels.setModelName(this.newModel.getModelName()); + microServiceModels.setSub_attributes(this.newModel.getSub_attributes()); + microServiceModels.setVersion(this.newModel.getVersion()); + microServiceModels.setEnumValues(this.newModel.getEnumValues()); + microServiceModels.setAnnotation(this.newModel.getAnnotation()); + + if(microServiceModels.getId() == 0){ + String checkName = microServiceModels.getModelName() + ":" + microServiceModels.getVersion(); + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(checkName, "modelName:version", MicroServiceModels.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + microServiceModels.setUserCreatedBy(this.getUserInfo(userId)); + commonClassDao.save(microServiceModels); + } + }else{ + commonClassDao.update(microServiceModels); + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceModels.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + responseString = "Success"; + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{microServiceModelsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ms_dictionary/remove_msModel"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removeMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + MicroServiceModels microServiceModels = (MicroServiceModels)mapper.readValue(root.get("data").toString(), MicroServiceModels.class); + commonClassDao.delete(microServiceModels); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(MicroServiceModels.class)); + JSONObject j = new JSONObject("{microServiceModelsDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + LOGGER.error(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + private void addValuesToNewModel(HashMap<String,MSAttributeObject > classMap) { + new MicroServiceModels(); + //Loop through the classmap and pull out the required info for the new file. + MSAttributeObject mainClass = null; + ArrayList<String> dependency = null; + String subAttribute = null; + + mainClass = classMap.get(this.newModel.getModelName()); + + if (mainClass !=null){ + String dependTemp = StringUtils.replaceEach(mainClass.getDependency(), new String[]{"[", "]", " "}, new String[]{"", "", ""}); + dependency = new ArrayList<String>(Arrays.asList(dependTemp.split(","))); + dependency = getFullDependencyList(dependency); + for (String element : dependency){ + MSAttributeObject temp = new MSAttributeObject(); + temp = classMap.get(element); + if (temp!=null){ + mainClass.addAllRefAttribute(temp.getRefAttribute()); + mainClass.addAllAttribute(temp.getAttribute()); + } + } + subAttribute = utils.createSubAttributes(dependency, classMap, this.newModel.getModelName()); + }else{ + subAttribute = "{}"; + this.newModel.setDependency(""); + } + + if (mainClass != null && mainClass.getDependency()==null){ + mainClass.setDependency(""); + } + if(mainClass != null){ + this.newModel.setDependency(mainClass.getDependency()); + this.newModel.setSub_attributes(subAttribute); + this.newModel.setAttributes(mainClass.getAttribute().toString().replace("{", "").replace("}", "")); + this.newModel.setRef_attributes(mainClass.getRefAttribute().toString().replace("{", "").replace("}", "")); + this.newModel.setEnumValues(mainClass.getEnumType().toString().replace("{", "").replace("}", "")); + this.newModel.setAnnotation(mainClass.getMatchingSet().toString().replace("{", "").replace("}", "")); + } + } + + private ArrayList<String> getFullDependencyList(ArrayList<String> dependency) { + ArrayList<String> returnList = new ArrayList<>(); + ArrayList<String> workingList = new ArrayList<>(); + returnList.addAll(dependency); + for (String element : dependency ){ + if (classMap.containsKey(element)){ + MSAttributeObject value = classMap.get(element); + String rawValue = StringUtils.replaceEach(value.getDependency(), new String[]{"[", "]"}, new String[]{"", ""}); + workingList = new ArrayList<String>(Arrays.asList(rawValue.split(","))); + for(String depend : workingList){ + if (!returnList.contains(depend) && !depend.isEmpty()){ + returnList.add(depend.trim()); + //getFullDepedency(workingList) + } + } + } + } + + return returnList; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PolicyScopeDictionaryController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PolicyScopeDictionaryController.java new file mode 100644 index 000000000..c2dcbc651 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PolicyScopeDictionaryController.java @@ -0,0 +1,927 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.lang.StringUtils; +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.GroupPolicyScopeList; +import org.onap.policy.rest.jpa.PolicyScopeClosedLoop; +import org.onap.policy.rest.jpa.PolicyScopeResource; +import org.onap.policy.rest.jpa.PolicyScopeService; +import org.onap.policy.rest.jpa.PolicyScopeType; +import org.onap.policy.rest.jpa.UserInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class PolicyScopeDictionaryController { + + private static final Logger LOGGER = FlexLogger.getLogger(PolicyScopeDictionaryController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public PolicyScopeDictionaryController(CommonClassDao commonClassDao){ + PolicyScopeDictionaryController.commonClassDao = commonClassDao; + } + + public PolicyScopeDictionaryController(){} + + private static String SUCCESSMAPKEY = "successMapKey"; + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + @RequestMapping(value={"/get_GroupPolicyScopeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getGroupPolicyScopeEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("groupPolicyScopeListDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(GroupPolicyScopeList.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_GroupPolicyScopeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getGroupPolicyScopeEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("groupPolicyScopeListDatas", mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSMAPKEY, "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/ps_dictionary/save_psGroupPolicyScope"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean duplicateGroupFlag = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + //GroupPolicyScopeList gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("groupPolicyScopeListData").toString(), GroupPolicyScopeList.class); + GroupPolicyScopeList gpdata = null; + GroupPolicyScope groupData = null; + if (fromAPI) { + gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("dictionaryFields").toString(), GroupPolicyScopeList.class); + try{ + groupData = (GroupPolicyScope)mapper.readValue(root.get("groupPolicyScopeListData1").toString(), GroupPolicyScope.class); + }catch(Exception e){ + groupData = new GroupPolicyScope(); + groupData.setResource(root.get("dictionaryFields").get("resource").toString().replace("\"", "")); + groupData.setClosedloop(root.get("dictionaryFields").get("closedloop").toString().replace("\"", "")); + groupData.setService(root.get("dictionaryFields").get("service").toString().replace("\"", "")); + groupData.setType(root.get("dictionaryFields").get("type").toString().replace("\"", "")); + } + + if(!gpdata.getGroupName().startsWith("PolicyScope")){ + String name = "PolicyScope_" + gpdata.getGroupName(); + gpdata.setGroupName(name); + } + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(gpdata.getGroupName(), "name", GroupPolicyScopeList.class); + int id = 0; + for (int i =0; i< duplicateData.size(); i++){ + GroupPolicyScopeList data = (GroupPolicyScopeList) duplicateData.get(0); + id = data.getId(); + } + + if(id==0){ + isFakeUpdate=true; + gpdata.setId(1); + } else { + gpdata.setId(id); + } + + } + } else { + gpdata = (GroupPolicyScopeList)mapper.readValue(root.get("groupPolicyScopeListData").toString(), GroupPolicyScopeList.class); + + try{ + groupData = (GroupPolicyScope)mapper.readValue(root.get("groupPolicyScopeListData1").toString(), GroupPolicyScope.class); + }catch(Exception e){ + groupData = new GroupPolicyScope(); + groupData.setResource(root.get("groupPolicyScopeListData1").get("resource").toString().replace("\"", "")); + groupData.setClosedloop(root.get("groupPolicyScopeListData1").get("closedloop").toString().replace("\"", "")); + groupData.setService(root.get("groupPolicyScopeListData1").get("service").toString().replace("\"", "")); + groupData.setType(root.get("groupPolicyScopeListData1").get("type").toString().replace("\"", "")); + } + if(!gpdata.getGroupName().startsWith("PolicyScope")){ + String name = "PolicyScope_" + gpdata.getGroupName(); + gpdata.setGroupName(name); + } + + } + ArrayList<String> valueList = new ArrayList<>(); + String list = null; + String resourceValue = groupData.getResource(); + String typeValue = groupData.getType(); + String serviceValue = groupData.getService(); + String closedLoopValue = groupData.getClosedloop(); + valueList.add("resource=" + resourceValue); + valueList.add("service=" + serviceValue); + valueList.add("type=" + typeValue); + valueList.add("closedLoopControlName=" + closedLoopValue); + list = StringUtils.replaceEach(valueList.toString(), new String[]{"[", "]", " "}, new String[]{"", "", ""}); + gpdata.setGroupList(list); + if(!gpdata.getGroupName().startsWith("PolicyScope")){ + String name = "PolicyScope_" + gpdata.getGroupName(); + gpdata.setGroupName(name); + } + if(gpdata.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(gpdata.getGroupName(), "name", GroupPolicyScopeList.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + duplicateData = commonClassDao.checkDuplicateEntry(gpdata.getGroupList(), "groupList", GroupPolicyScopeList.class); + if(!duplicateData.isEmpty()){ + duplicateGroupFlag = true; + }else{ + commonClassDao.save(gpdata); + } + } + }else{ + if(!isFakeUpdate) { + List<Object> duplicateGroupList = commonClassDao.checkExistingGroupListforUpdate(gpdata.getGroupList(), gpdata.getGroupName()); + if(!duplicateGroupList.isEmpty()) { + duplicateGroupFlag = true; + } else { + commonClassDao.update(gpdata); + } + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else if(duplicateGroupFlag){ + responseString = "DuplicateGroup"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate") && !responseString.equals("DuplicateGroup")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{groupPolicyScopeListDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ps_dictionary/remove_GroupPolicyScope"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + GroupPolicyScopeList onapData = (GroupPolicyScopeList)mapper.readValue(root.get("data").toString(), GroupPolicyScopeList.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(GroupPolicyScopeList.class)); + JSONObject j = new JSONObject("{groupPolicyScopeListDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_PSClosedLoopDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSClosedLoopEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psClosedLoopDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeClosedLoop.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_PSClosedLoopData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSClosedLoopEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psClosedLoopDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSMAPKEY, "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/ps_dictionary/save_psClosedLoop"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeClosedLoop onapData; + if (fromAPI) { + onapData = (PolicyScopeClosedLoop)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeClosedLoop.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeClosedLoop.class); + int id = 0; + for (int i =0; i< duplicateData.size(); i++){ + PolicyScopeClosedLoop data = (PolicyScopeClosedLoop) duplicateData.get(0); + id = data.getId(); + } + + if(id==0){ + isFakeUpdate=true; + onapData.setId(1); + } else { + onapData.setId(id); + } + + } + } else { + onapData = (PolicyScopeClosedLoop)mapper.readValue(root.get("psClosedLoopDictionaryData").toString(), PolicyScopeClosedLoop.class); + } + if(onapData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeClosedLoop.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(onapData); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(onapData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{psClosedLoopDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ps_dictionary/remove_PSClosedLoop"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeClosedLoop onapData = (PolicyScopeClosedLoop)mapper.readValue(root.get("data").toString(), PolicyScopeClosedLoop.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeClosedLoop.class)); + JSONObject j = new JSONObject("{psClosedLoopDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_PSServiceDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSServiceEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeService.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_PSServiceData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSServiceEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psServiceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSMAPKEY, "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/ps_dictionary/save_psService"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeService onapData; + if (fromAPI) { + onapData = (PolicyScopeService)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeService.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeService.class); + int id = 0; + for (int i =0; i< duplicateData.size(); i++){ + PolicyScopeService data = (PolicyScopeService) duplicateData.get(0); + id = data.getId(); + } + if(id==0){ + isFakeUpdate=true; + onapData.setId(1); + } else { + onapData.setId(id); + } + } + } else { + onapData = (PolicyScopeService)mapper.readValue(root.get("psServiceDictionaryData").toString(), PolicyScopeService.class); + } + if(onapData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeService.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(onapData); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(onapData); + } + } + + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{psServiceDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ps_dictionary/remove_PSService"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeService onapData = (PolicyScopeService)mapper.readValue(root.get("data").toString(), PolicyScopeService.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeService.class)); + JSONObject j = new JSONObject("{psServiceDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_PSTypeDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSTypeEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeType.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_PSTypeData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSTypeEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader(SUCCESSMAPKEY, "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/ps_dictionary/save_psType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeType onapData; + if (fromAPI) { + onapData = (PolicyScopeType)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeType.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeType.class); + int id = 0; + for (int i =0; i< duplicateData.size(); i++){ + PolicyScopeType data = (PolicyScopeType) duplicateData.get(0); + id = data.getId(); + } + + if(id==0){ + isFakeUpdate=true; + onapData.setId(1); + } else { + onapData.setId(id); + } + + } + } else { + onapData = (PolicyScopeType)mapper.readValue(root.get("psTypeDictionaryData").toString(), PolicyScopeType.class); + } + if(onapData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeType.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(onapData); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(onapData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + + } else { + + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{psTypeDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ps_dictionary/remove_PSType"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeType onapData = (PolicyScopeType)mapper.readValue(root.get("data").toString(), PolicyScopeType.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeType.class)); + JSONObject j = new JSONObject("{psTypeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/get_PSResourceDataByName"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSResourceEntityDataByName(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psResourceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(PolicyScopeResource.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value={"/get_PSResourceData"}, method={org.springframework.web.bind.annotation.RequestMethod.GET} , produces=MediaType.APPLICATION_JSON_VALUE) + public void getPSResourceEntityData(HttpServletRequest request, HttpServletResponse response){ + try{ + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("psResourceDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } + catch (Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e); + } + } + + @RequestMapping(value={"/ps_dictionary/save_psResource"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView savePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeResource onapData; + if (fromAPI) { + onapData = (PolicyScopeResource)mapper.readValue(root.get("dictionaryFields").toString(), PolicyScopeResource.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeResource.class); + int id = 0; + PolicyScopeResource data = (PolicyScopeResource) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + onapData.setId(1); + } else { + onapData.setId(id); + } + } + } else { + onapData = (PolicyScopeResource)mapper.readValue(root.get("psResourceDictionaryData").toString(), PolicyScopeResource.class); + } + if(onapData.getId() == 0){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(onapData.getName(), "name", PolicyScopeResource.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(onapData); + } + }else{ + if(!isFakeUpdate) { + commonClassDao.update(onapData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = "Duplicate"; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals("Duplicate")) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + + } else { + + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{psResourceDictionaryDatas: " + responseString + "}"); + + out.write(j.toString()); + + return null; + } + + }catch (Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value={"/ps_dictionary/remove_PSResource"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView removePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception { + try{ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + PolicyScopeResource onapData = (PolicyScopeResource)mapper.readValue(root.get("data").toString(), PolicyScopeResource.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(PolicyScopeResource.class)); + JSONObject j = new JSONObject("{psResourceDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } + catch (Exception e){ + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } +} + +class GroupPolicyScope{ + String resource; + String type; + String service; + String closedloop; + public String getResource() { + return resource; + } + public void setResource(String resource) { + this.resource = resource; + } + public String getType() { + return type; + } + public void setType(String type) { + this.type = type; + } + public String getService() { + return service; + } + public void setService(String service) { + this.service = service; + } + public String getClosedloop() { + return closedloop; + } + public void setClosedloop(String closedloop) { + this.closedloop = closedloop; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java new file mode 100644 index 000000000..a545bb409 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/PushPolicyController.java @@ -0,0 +1,229 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.io.ObjectOutputStream; +import java.net.URI; +import java.util.List; +import java.util.UUID; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.PolicyEntity; +import org.onap.policy.rest.jpa.PolicyVersion; +import org.onap.policy.xacml.std.pap.StdPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; + +import com.att.research.xacml.api.pap.PAPException; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class PushPolicyController { + private static final Logger LOGGER = FlexLogger.getLogger(PushPolicyController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public PushPolicyController(CommonClassDao commonClassDao){ + PushPolicyController.commonClassDao = commonClassDao; + } + + public PushPolicyController(){} + + @RequestMapping(value="/pushPolicy", method=RequestMethod.POST) + public void pushPolicy(HttpServletRequest request, HttpServletResponse response){ + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + try { + JsonNode root = mapper.readTree(request.getInputStream()); + String policyScope = root.get("policyScope").asText(); + String filePrefix = root.get("filePrefix").asText(); + String policyName = root.get("policyName").asText(); + String pdpGroup = root.get("pdpGroup").asText(); + String requestID = request.getHeader("X-ECOMP-RequestID"); + if(requestID==null){ + requestID = UUID.randomUUID().toString(); + LOGGER.info("No request ID provided, sending generated ID: " + requestID.toString()); + } + LOGGER.info("Push policy Request : " + root.asText()); + String policyVersionName = policyScope.replace(".", File.separator) + File.separator + + filePrefix + policyName; + List<?> policyVersionObject = commonClassDao.getDataById(PolicyVersion.class, "policyName", policyVersionName); + if(policyVersionObject!=null){ + PolicyVersion policyVersion = (PolicyVersion) policyVersionObject.get(0); + String policyID = policyVersionName.replace(File.separator, "."); // This is before adding version. + policyVersionName += "." + policyVersion.getActiveVersion() + ".xml"; + addPolicyToGroup(policyScope, policyID, policyVersionName.replace(File.separator, "."), pdpGroup, response); + }else{ + String message = "Unknown Policy '" + policyName + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + response.addHeader("error", "unknownPolicy"); + response.addHeader("operation", "push"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + return; + } + //safetyChecker(policyName); + } catch (NullPointerException | IOException e) { + LOGGER.error(e); + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + response.addHeader("error", "unknown"); + response.addHeader("operation", "push"); + return; + } + } + + private void addPolicyToGroup(String policyScope, String policyID, String policyName, String pdpGroup, HttpServletResponse response) { + StdPDPGroup selectedPDPGroup = null; + StdPDPPolicy selectedPolicy = null; + //Get the current policies from the Group and Add the new one + //Set<PDPPolicy> currentPoliciesInGroup = null; + try { + selectedPDPGroup = (StdPDPGroup) XACMLPapServlet.getPAPEngine().getGroup(pdpGroup); + } catch (PAPException e1) { + PolicyLogger.error(e1); + } + if(selectedPDPGroup==null){ + String message = "Unknown groupId '" + selectedPDPGroup + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + response.addHeader("error", "unknownGroupId"); + response.addHeader("operation", "push"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + return; + } + //Get PolicyEntity from DB; + EntityManager em = XACMLPapServlet.getEmf().createEntityManager(); + Query createPolicyQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.scope=:scope AND p.policyName=:policyName"); + createPolicyQuery.setParameter("scope", policyScope); + createPolicyQuery.setParameter("policyName", policyName.substring(policyScope.length()+1)); + List<?> createPolicyQueryList = createPolicyQuery.getResultList(); + PolicyEntity policyEntity = null; + if(createPolicyQueryList.size()>0){ + policyEntity = (PolicyEntity)createPolicyQueryList.get(0); + }else{ + PolicyLogger.error("Somehow, more than one policy with the same scope, name, and deleted status were found in the database"); + String message = "Unknown Policy '" + policyName + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + response.addHeader("error", "unknownPolicy"); + response.addHeader("operation", "push"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + return; + } + File temp = new File(policyName); + try { + BufferedWriter bw = new BufferedWriter(new FileWriter(temp)); + bw.write(policyEntity.getPolicyData()); + bw.close(); + URI selectedURI = temp.toURI(); + // Create the policy Object + selectedPolicy = new StdPDPPolicy(policyName, true, policyID, selectedURI); + } catch (IOException e) { + LOGGER.error("Unable to create policy '" + policyName + "': "+ e.getMessage()); + } + try { + new ObjectOutputStream(response.getOutputStream()).writeObject(selectedPolicy); + } catch (IOException e) { + LOGGER.error(e); + response.addHeader("error", "policyCopyError"); + response.addHeader("message", e.getMessage()); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + return; + } + response.addHeader("Content-Type","application/json"); + response.setStatus(HttpServletResponse.SC_ACCEPTED); + response.addHeader("operation", "push"); + response.addHeader("policyId", policyName); + return; + // TODO : Check point to push policies within PAP. + /*PolicyDBDaoTransaction addPolicyToGroupTransaction = XACMLPapServlet.getDbDaoTransaction(); + try{ + if (selectedPolicy != null) { + // Add Current policies from container + currentPoliciesInGroup = selectedPDPGroup.getPolicies(); + // copy policy to PAP + addPolicyToGroupTransaction.addPolicyToGroup(selectedPDPGroup.getId(), policyName,"XACMLPapServlet.pushPolicyController"); + ((StdPDPGroup) selectedPDPGroup).copyPolicyToFile(policyName, policyID, new FileInputStream(temp)); + addPolicyToGroupTransaction.commitTransaction(); + } + }catch (Exception e) { + addPolicyToGroupTransaction.rollbackTransaction(); + String message = "Policy '" + policyName + "' not copied to group '" + pdpGroup +"': " + e; + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " " + message); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.addHeader("error", "policyCopyError"); + response.addHeader("message", message); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + return; + } + //If the selected policy is in the group we must remove it because the name is default + for (PDPPolicy existingPolicy : currentPoliciesInGroup) { + if (existingPolicy.getId().equals(selectedPolicy.getId())) { + selectedPDPGroup.removePolicyFromGroup(existingPolicy); + LOGGER.debug("Removing existing policy: " + existingPolicy); + break; + } + } + //Update the PDP Group after removing old version of policy + //Set<PDPPolicy> updatedPoliciesInGroup = selectedPDPGroup.getPolicies(); + //need to remove the policy with default name from group + for (PDPPolicy updatedPolicy : currentPoliciesInGroup) { + if (updatedPolicy.getName().equalsIgnoreCase("default")) { + selectedPDPGroup.removePolicyFromGroup(updatedPolicy); + } + } + Set<PDPPolicy> policies = selectedPDPGroup.getPolicies(); + policies.add(selectedPolicy); + selectedPDPGroup.setPolicies(policies); + // Update now. + try { + XACMLPapServlet.getPAPEngine().updateGroup(selectedPDPGroup); + } catch (PAPException e) { + // TODO Auto-generated catch block + logger.error("Exception Occured"+e); + } + // policy file copied ok and the Group was updated on the PDP + response.setStatus(HttpServletResponse.SC_NO_CONTENT); + response.addHeader("operation", "push"); + response.addHeader("policyId", policyName); + response.addHeader("groupId", pdpGroup); + return;*/ + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/SafePolicyController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/SafePolicyController.java new file mode 100644 index 000000000..fad6a871f --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/SafePolicyController.java @@ -0,0 +1,385 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.controller; + +import java.io.PrintWriter; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.RiskType; +import org.onap.policy.rest.jpa.SafePolicyWarning; +import org.onap.policy.rest.jpa.UserInfo; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; + +@Controller +public class SafePolicyController { + + private static final Logger LOGGER = FlexLogger.getLogger(SafePolicyController.class); + + private static CommonClassDao commonClassDao; + + @Autowired + public SafePolicyController(CommonClassDao commonClassDao){ + SafePolicyController.commonClassDao = commonClassDao; + } + + public SafePolicyController(){} + + public UserInfo getUserInfo(String loginId){ + UserInfo name = (UserInfo) commonClassDao.getEntityItem(UserInfo.class, "userLoginId", loginId); + return name; + } + + private static String DUPLICATE = "Duplicate"; + + @RequestMapping(value = { "/get_RiskTypeDataByName" }, method = { + org.springframework.web.bind.annotation.RequestMethod.GET }, produces = MediaType.APPLICATION_JSON_VALUE) + public void getRiskTypeDictionaryByNameEntityData(HttpServletRequest request, HttpServletResponse response) { + try { + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("riskTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getDataByColumn(RiskType.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value = { "/get_RiskTypeData" }, method = { + org.springframework.web.bind.annotation.RequestMethod.GET }, produces = MediaType.APPLICATION_JSON_VALUE) + public void getOnapNameDictionaryEntityData(HttpServletRequest request, HttpServletResponse response) { + try { + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("riskTypeDictionaryDatas", mapper.writeValueAsString(commonClassDao.getData(RiskType.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } catch (Exception e) { + LOGGER.error(e.getMessage()); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + } + } + + @RequestMapping(value = { "/sp_dictionary/save_riskType" }, method = { + org.springframework.web.bind.annotation.RequestMethod.POST }) + public ModelAndView saveRiskTypeDictionary(HttpServletRequest request, HttpServletResponse response) + throws Exception { + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + RiskType riskTypeData; + String userId = null; + if (fromAPI) { + riskTypeData = (RiskType) mapper.readValue(root.get("dictionaryFields").toString(), + RiskType.class); + userId = "API"; + + //check if update operation or create, get id for data to be updated and update attributeData + if ("update".equalsIgnoreCase(request.getParameter("operation"))){ + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(riskTypeData.getRiskName(), "name", RiskType.class); + int id = 0; + RiskType data = (RiskType) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + riskTypeData.setId(1); + } else { + riskTypeData.setId(id); + } + + riskTypeData.setUserCreatedBy(this.getUserInfo(userId)); + } + } else { + riskTypeData = (RiskType) mapper.readValue(root.get("riskTypeDictionaryData").toString(), RiskType.class); + userId = root.get("userid").textValue(); + } + + if (riskTypeData.getId() == 0) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(riskTypeData.getRiskName(), "name", RiskType.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + riskTypeData.setUserCreatedBy(getUserInfo(userId)); + riskTypeData.setUserModifiedBy(getUserInfo(userId)); + commonClassDao.save(riskTypeData); + } + } else { + if (!isFakeUpdate) { + riskTypeData.setUserModifiedBy(this.getUserInfo(userId)); + riskTypeData.setModifiedDate(new Date()); + commonClassDao.update(riskTypeData); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = DUPLICATE; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(RiskType.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals(DUPLICATE)) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{riskTypeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + }catch (Exception e) { + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value = { "/sp_dictionary/remove_riskType" }, method = { + org.springframework.web.bind.annotation.RequestMethod.POST }) + public ModelAndView removeOnapDictionary(HttpServletRequest request, HttpServletResponse response) + throws Exception { + try { + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + RiskType onapData = (RiskType) mapper.readValue(root.get("data").toString(), RiskType.class); + commonClassDao.delete(onapData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(RiskType.class)); + JSONObject j = new JSONObject("{riskTypeDictionaryDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } catch (Exception e) { + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value = { "/get_SafePolicyWarningDataByName" }, method = { + org.springframework.web.bind.annotation.RequestMethod.GET }, produces = MediaType.APPLICATION_JSON_VALUE) + public void getSafePolicyWarningEntityDataByName(HttpServletRequest request, HttpServletResponse response) { + try { + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("safePolicyWarningDatas", + mapper.writeValueAsString(commonClassDao.getDataByColumn(SafePolicyWarning.class, "name"))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.getWriter().write(j.toString()); + } catch (Exception e) { + LOGGER.error("Exception Occured"+e); + } + } + + @RequestMapping(value = { "/get_SafePolicyWarningData" }, method = { + org.springframework.web.bind.annotation.RequestMethod.GET }, produces = MediaType.APPLICATION_JSON_VALUE) + public void getSafePolicyWarningeEntityData(HttpServletRequest request, HttpServletResponse response) { + try { + Map<String, Object> model = new HashMap<>(); + ObjectMapper mapper = new ObjectMapper(); + model.put("safePolicyWarningDatas", + mapper.writeValueAsString(commonClassDao.getData(SafePolicyWarning.class))); + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(model)); + JSONObject j = new JSONObject(msg); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getDictionary"); + response.getWriter().write(j.toString()); + } catch (Exception e) { + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + LOGGER.error(e.getMessage()); + } + } + + @RequestMapping(value = { "/sp_dictionary/save_safePolicyWarning" }, method = { + org.springframework.web.bind.annotation.RequestMethod.POST }) + public ModelAndView saveSafePolicyWarningDictionary(HttpServletRequest request, HttpServletResponse response) + throws Exception { + try { + boolean duplicateflag = false; + boolean isFakeUpdate = false; + boolean fromAPI = false; + if (request.getParameter("apiflag")!=null && request.getParameter("apiflag").equalsIgnoreCase("api")) { + fromAPI = true; + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + SafePolicyWarning safePolicyWarning; + if (fromAPI) { + safePolicyWarning = (SafePolicyWarning) mapper + .readValue(root.get("dictionaryFields").toString(), SafePolicyWarning.class); + + //check if update operation or create, get id for data to be updated and update attributeData + if (request.getParameter("operation").equals("update")) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(safePolicyWarning.getName(), "name", SafePolicyWarning.class); + int id = 0; + SafePolicyWarning data = (SafePolicyWarning) duplicateData.get(0); + id = data.getId(); + + if(id==0){ + isFakeUpdate=true; + safePolicyWarning.setId(1); + } else { + safePolicyWarning.setId(id); + } + } + } else { + safePolicyWarning = (SafePolicyWarning) mapper.readValue(root.get("safePolicyWarningData").toString(), SafePolicyWarning.class); + } + + if (safePolicyWarning.getId() == 0) { + List<Object> duplicateData = commonClassDao.checkDuplicateEntry(safePolicyWarning.getName(), "name", SafePolicyWarning.class); + if(!duplicateData.isEmpty()){ + duplicateflag = true; + }else{ + commonClassDao.save(safePolicyWarning); + } + } else { + if(!isFakeUpdate) { + commonClassDao.update(safePolicyWarning); + } + } + String responseString = ""; + if(duplicateflag){ + responseString = DUPLICATE; + }else{ + responseString = mapper.writeValueAsString(commonClassDao.getData(SafePolicyWarning.class)); + } + + if (fromAPI) { + if (responseString!=null && !responseString.equals(DUPLICATE)) { + if(isFakeUpdate){ + responseString = "Exists"; + } else { + responseString = "Success"; + } + } + ModelAndView result = new ModelAndView(); + result.setViewName(responseString); + return result; + } else { + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + JSONObject j = new JSONObject("{safePolicyWarningDatas: " + responseString + "}"); + out.write(j.toString()); + return null; + } + + }catch (Exception e) { + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + @RequestMapping(value = { "/sp_dictionary/remove_SafePolicyWarning" }, method = { + org.springframework.web.bind.annotation.RequestMethod.POST }) + public ModelAndView removeSafePolicyWarningDictionary(HttpServletRequest request, HttpServletResponse response) + throws Exception { + try { + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + SafePolicyWarning safePolicyWarningData = (SafePolicyWarning) mapper.readValue(root.get("data").toString(), + SafePolicyWarning.class); + commonClassDao.delete(safePolicyWarningData); + response.setCharacterEncoding("UTF-8"); + response.setContentType("application / json"); + request.setCharacterEncoding("UTF-8"); + + PrintWriter out = response.getWriter(); + + String responseString = mapper.writeValueAsString(commonClassDao.getData(SafePolicyWarning.class)); + JSONObject j = new JSONObject("{groupPolicyScopeListDatas: " + responseString + "}"); + out.write(j.toString()); + + return null; + } catch (Exception e) { + System.out.println(e); + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/package-info.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/package-info.java new file mode 100644 index 000000000..bb42fb6aa --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/controller/package-info.java @@ -0,0 +1,22 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + + +package org.onap.policy.pap.xacml.rest.controller; diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/daoimpl/CommonClassDaoImpl.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/daoimpl/CommonClassDaoImpl.java new file mode 100644 index 000000000..2cc211701 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/daoimpl/CommonClassDaoImpl.java @@ -0,0 +1,443 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.daoimpl; + +import java.util.List; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.hibernate.Criteria; +import org.hibernate.Query; +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.Transaction; +import org.hibernate.criterion.Conjunction; +import org.hibernate.criterion.Criterion; +import org.hibernate.criterion.Disjunction; +import org.hibernate.criterion.Projections; +import org.hibernate.criterion.Restrictions; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ClosedLoops; +import org.onap.policy.rest.jpa.GroupPolicyScopeList; +import org.onap.policy.rest.jpa.PolicyRoles; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service("CommonClassDao") +public class CommonClassDaoImpl implements CommonClassDao{ + + private static final Log LOGGER = LogFactory.getLog(CommonClassDaoImpl.class); + + + private static SessionFactory sessionFactory; + + @Autowired + private CommonClassDaoImpl(SessionFactory sessionFactory){ + CommonClassDaoImpl.sessionFactory = sessionFactory; + } + + public CommonClassDaoImpl(){ + //Default Constructor + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public List<Object> getData(Class className) { + Session session = sessionFactory.openSession(); + List<Object> data = null; + try{ + Criteria cr = session.createCriteria(className); + data = cr.list(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e); + } + } + return data; + } + + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public List<Object> getDataById(Class className, String columnName, String key) { + Session session = sessionFactory.openSession(); + List<Object> data = null; + try { + Criteria cr = session.createCriteria(className); + if(columnName.contains(":") && key.contains(":")){ + String[] columns = columnName.split(":"); + String[] keys = key.split(":"); + for(int i=0; i < columns.length; i++){ + cr.add(Restrictions.eq(columns[i], keys[i])); + } + }else{ + cr.add(Restrictions.eq(columnName, key)); + } + data = cr.list(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return data; + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public List<String> getDataByColumn(Class className, String columnName) { + Session session = sessionFactory.openSession(); + List<String> data = null; + try{ + Criteria cr = session.createCriteria(className); + cr.setProjection(Projections.property(columnName)); + data = cr.list(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e); + } + } + return data; + } + + @Override + public void save(Object entity) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + try { + session.persist(entity); + tx.commit(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving data to Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + + } + + @Override + public void delete(Object entity) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + try { + session.delete(entity); + tx.commit(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + + } + + + @Override + public void update(Object entity) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + try { + session.update(entity); + tx.commit(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + + } + + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public List<Object> checkDuplicateEntry(String value, String columnName, Class className) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + List<Object> data = null; + + String[] columnNames = null; + if(columnName != null && columnName.contains(":")){ + columnNames = columnName.split(":"); + } + String[] values = null; + if(value != null && value.contains(":")){ + values = value.split(":"); + } + try { + Criteria cr = session.createCriteria(className); + if(columnNames != null && values != null && columnNames.length == values.length){ + for (int i = 0; i < columnNames.length; i++){ + cr.add(Restrictions.eq(columnNames[i],values[i])); + } + }else{ + cr.add(Restrictions.eq(columnName,value)); + } + + data = cr.list(); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"+e + className); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return data; + } + + + @SuppressWarnings("unchecked") + @Override + public List<Object> getDataByQuery(String query) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + List<Object> data = null; + try { + Query hbquery = session.createQuery(query); + data = hbquery.list(); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return data; + } + + + @Override + public void updateQuery(String query) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + try { + Query hbquery = session.createQuery(query); + hbquery.executeUpdate(); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + } + + + @SuppressWarnings("rawtypes") + @Override + public Object getEntityItem(Class className, String columnName, String key) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + Object data = null; + try { + Criteria cr = session.createCriteria(className); + if(columnName.contains(":") && key.contains(":")){ + String[] columns = columnName.split(":"); + String[] keys = key.split(":"); + for(int i=0; i < columns.length; i++){ + cr.add(Restrictions.eq(columns[i], keys[i])); + } + }else{ + cr.add(Restrictions.eq(columnName, key)); + } + data = cr.list().get(0); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return data; + } + + + @SuppressWarnings("unchecked") + @Override + public List<PolicyRoles> getUserRoles() { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + List<PolicyRoles> rolesData = null; + try { + Criteria cr = session.createCriteria(PolicyRoles.class); + Disjunction disjunction = Restrictions.disjunction(); + Conjunction conjunction1 = Restrictions.conjunction(); + conjunction1.add(Restrictions.eq("role", "admin")); + Conjunction conjunction2 = Restrictions.conjunction(); + conjunction2.add(Restrictions.eq("role", "editor")); + Conjunction conjunction3 = Restrictions.conjunction(); + conjunction3.add(Restrictions.eq("role", "guest")); + disjunction.add(conjunction1); + disjunction.add(conjunction2); + disjunction.add(conjunction3); + rolesData = cr.add(disjunction).list(); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return rolesData; + } + + + @SuppressWarnings("unchecked") + @Override + public void updateClAlarms(String clName, String alarms) { + Session session = sessionFactory.openSession(); + List<ClosedLoops> closedloopsdata = null; + Transaction tx = session.beginTransaction(); + try { + Criteria cr = session.createCriteria(ClosedLoops.class); + cr.add(Restrictions.eq("closedLoopControlName",clName)); + closedloopsdata = cr.list(); + ClosedLoops closedloop = closedloopsdata.get(0); + closedloop.setAlarmConditions(alarms); + session.update(closedloop); + tx.commit(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table"+e); + }finally{ + session.close(); + } + } + + + @SuppressWarnings("unchecked") + @Override + public void updateClYaml(String clName, String yaml) { + Session session = sessionFactory.openSession(); + List<ClosedLoops> closedloopsdata = null; + Transaction tx = session.beginTransaction(); + try { + Criteria cr = session.createCriteria(ClosedLoops.class); + cr.add(Restrictions.eq("closedLoopControlName",clName)); + closedloopsdata = cr.list(); + ClosedLoops closedloop = closedloopsdata.get(0); + closedloop.setYaml(yaml); + session.update(closedloop); + tx.commit(); + }catch(Exception e){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table"+e); + }finally{ + session.close(); + } + } + + + @SuppressWarnings("unchecked") + @Override + public void deleteAll() { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + List<ClosedLoops> closedloopsdata = null; + try { + Criteria cr = session.createCriteria(ClosedLoops.class); + closedloopsdata = cr.list(); + + if(closedloopsdata!=null && !closedloopsdata.isEmpty()) { + LOGGER.info("ClosedLoops exist in the database, we need to delete them in our first step to buildCache()."); + for(int i=0; i < closedloopsdata.size(); i++) { + ClosedLoops cl = closedloopsdata.get(i); + session.delete(cl); + } + } else { + LOGGER.info("No ClosedLoops exist in the database, no need to delete."); + } + + tx.commit(); + }catch(Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while deleting ClosedLoops from the table"+e); + }finally{ + session.close(); + } + } + + @SuppressWarnings({ "unchecked"}) + @Override + public List<Object> checkExistingGroupListforUpdate(String groupListValue, String groupNameValue) { + Session session = sessionFactory.openSession(); + Transaction tx = session.beginTransaction(); + List<Object> data = null; + try { + Criteria cr = session.createCriteria(GroupPolicyScopeList.class); + cr.add(Restrictions.eq("groupList",groupListValue)); + Criterion expression = Restrictions.eq("name", groupNameValue); + cr.add(Restrictions.not(expression)); + data = cr.list(); + tx.commit(); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for GroupPolicyScopeList Table"+e); + }finally{ + try{ + session.close(); + }catch(Exception e1){ + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1); + } + } + return data; + } + + + @Override + public List<Object> getMultipleDataOnAddingConjunction(@SuppressWarnings("rawtypes") Class className, String columnName, List<String> data) { + return null; + } + +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElasticSearchPolicyUpdate.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElasticSearchPolicyUpdate.java new file mode 100644 index 000000000..dcd44f84f --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElasticSearchPolicyUpdate.java @@ -0,0 +1,311 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Policy Engine + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + +import java.io.FileInputStream; +import java.io.InputStream; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Properties; + +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; + +import com.google.gson.Gson; + +import io.searchbox.client.JestClientFactory; +import io.searchbox.client.config.HttpClientConfig; +import io.searchbox.client.http.JestHttpClient; +import io.searchbox.core.Bulk; +import io.searchbox.core.Bulk.Builder; +import io.searchbox.core.BulkResult; +import io.searchbox.core.Index; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AllOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AnyOfType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeValueType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.MatchType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.PolicyType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.TargetType; + + + +/** + * This code will deals with parsing the XACML content on reading from + * database(PolicyEntity, ConfigurationDataEntity and ActionBodyEntity tables) + * and convert the data into json to do bulk operation on putting to elastic search database. + * Which is used to support Elastic Search in Policy Application GUI to search policies. + * + * + * + * properties should be configured in policyelk.properties + * + */ +public class ElasticSearchPolicyUpdate { + + private static final Logger LOGGER = FlexLogger.getLogger(ElasticSearchPolicyUpdate.class); + protected final static JestClientFactory jestFactory = new JestClientFactory(); + + public static void main(String[] args) { + + String elkURL = null; + String databseUrl = null; + String userName = null; + String password = null; + String databaseDriver = null; + + String propertyFile = System.getProperty("PROPERTY_FILE"); + Properties config = new Properties(); + Path file = Paths.get(propertyFile); + if(Files.notExists(file)){ + LOGGER.error("Config File doesn't Exist in the specified Path " + file.toString()); + }else{ + if(file.toString().endsWith(".properties")){ + try { + InputStream in = new FileInputStream(file.toFile()); + config.load(in); + elkURL = config.getProperty("policy.elk.url"); + databseUrl = config.getProperty("policy.database.url"); + userName = config.getProperty("policy.database.username"); + password = config.getProperty("policy.database.password"); + databaseDriver = config.getProperty("policy.database.driver"); + if(elkURL == null || databseUrl == null || userName == null || password == null || databaseDriver == null){ + LOGGER.error("One of the Property is null in policyelk.properties = elkurl:databaseurl:username:password:databasedriver " + + elkURL + ":"+ databseUrl + ":"+ userName + ":"+ password + ":"+ databaseDriver + ":"); + } + } catch (Exception e) { + LOGGER.error("Config File doesn't Exist in the specified Path " + file.toString()); + } + } + } + + Builder bulk = null; + + HttpClientConfig httpClientConfig = new HttpClientConfig.Builder(elkURL).multiThreaded(true).build(); + jestFactory.setHttpClientConfig(httpClientConfig); + JestHttpClient client = (JestHttpClient) jestFactory.getObject(); + + Connection conn = null; + Statement stmt = null; + + List<Index> listIndex = new ArrayList<Index>(); + + try { + Class.forName(databaseDriver); + conn = DriverManager.getConnection(databseUrl, userName, password); + stmt = conn.createStatement(); + + String policyEntityQuery = "Select * from PolicyEntity"; + ResultSet result = stmt.executeQuery(policyEntityQuery); + + while(result.next()){ + StringBuilder policyDataString = new StringBuilder("{"); + String scope = result.getString("scope"); + String policyName = result.getString("policyName"); + if(policyName != null){ + policyDataString.append("\"policyName\":\""+scope+"."+policyName+"\","); + } + String description = result.getString("description"); + if(description != null){ + policyDataString.append("\"policyDescription\":\""+description+"\","); + } + Object policyData = result.getString("policydata"); + + if(scope != null){ + policyDataString.append("\"scope\":\""+scope+"\","); + } + String actionbodyid = result.getString("actionbodyid"); + String configurationdataid = result.getString("configurationdataid"); + + + String policyWithScopeName = scope + "." + policyName; + String _type = null; + + if(policyWithScopeName.contains(".Config_")){ + policyDataString.append("\"policyType\":\"Config\","); + if(policyWithScopeName.contains(".Config_Fault_")){ + _type = "closedloop"; + policyDataString.append("\"configPolicyType\":\"ClosedLoop_Fault\","); + }else if(policyWithScopeName.contains(".Config_PM_")){ + _type = "closedloop"; + policyDataString.append("\"configPolicyType\":\"ClosedLoop_PM\","); + }else{ + _type = "config"; + policyDataString.append("\"configPolicyType\":\"Base\","); + } + }else if(policyWithScopeName.contains(".Action_")){ + _type = "action"; + policyDataString.append("\"policyType\":\"Action\","); + }else if(policyWithScopeName.contains(".Decision_")){ + _type = "decision"; + policyDataString.append("\"policyType\":\"Decision\","); + } + + if(!"decision".equals(_type)){ + if(configurationdataid != null){ + String configEntityQuery = "Select * from ConfigurationDataEntity where configurationDataId = "+configurationdataid+""; + Statement configstmt = conn.createStatement(); + ResultSet configResult = configstmt.executeQuery(configEntityQuery); + while(configResult.next()){ + String configBody = configResult.getString("configbody"); + String configType = configResult.getString("configtype"); + if("JSON".equalsIgnoreCase(configType)){ + policyDataString.append("\"jsonBodyData\":"+configBody+",\"configType\":\""+configType+"\","); + }else if("OTHER".equalsIgnoreCase(configType)){ + if(configBody!=null){ + configBody= configBody.replaceAll("\"", ""); + policyDataString.append("\"jsonBodyData\":\""+configBody+"\",\"configType\":\""+configType+"\","); + } + } + } + configResult.close(); + } + + if(actionbodyid != null){ + String actionEntityQuery = "Select * from ActionBodyEntity where actionBodyId = "+actionbodyid+""; + Statement actionstmt = conn.createStatement(); + ResultSet actionResult = actionstmt.executeQuery(actionEntityQuery); + while(actionResult.next()){ + String actionBody = actionResult.getString("actionbody"); + policyDataString.append("\"jsonBodyData\":"+actionBody+","); + } + actionResult.close(); + } + } + + String _id = policyWithScopeName; + + policyDataString.append(constructPolicyData(policyData, policyDataString)); + + String dataString = policyDataString.toString(); + dataString = dataString.substring(0, dataString.length()-1); + dataString = dataString.trim().replace(System.getProperty("line.separator"), "") + "}"; + dataString = dataString.replace("null", "\"\""); + dataString = dataString.replaceAll(" ", "").replaceAll("\n", ""); + + try{ + Gson gson = new Gson(); + gson.fromJson(dataString, Object.class); + }catch(Exception e){ + continue; + } + + if("config".equals(_type)){ + listIndex.add(new Index.Builder(dataString).index("policy").type("config").id(_id).build()); + }else if("closedloop".equals(_type)){ + listIndex.add(new Index.Builder(dataString).index("policy").type("closedloop").id(_id).build()); + }else if("action".equals(_type)){ + listIndex.add(new Index.Builder(dataString).index("policy").type("action").id(_id).build()); + }else if("decision".equals(_type)){ + listIndex.add(new Index.Builder(dataString).index("policy").type("decision").id(_id).build()); + } + } + + result.close(); + bulk = new Bulk.Builder(); + for(int i =0; i < listIndex.size(); i++){ + bulk.addAction(listIndex.get(i)); + } + BulkResult searchResult = client.execute(bulk.build()); + if(searchResult.isSucceeded()){ + LOGGER.debug("Success"); + }else{ + LOGGER.error("Failure"); + } + } catch (Exception e) { + LOGGER.error("Exception Occured while performing database Operation for Elastic Search Policy Upgrade"+e); + }finally{ + if(conn != null){ + try { + conn.close(); + } catch (Exception e) { + LOGGER.error("Exception Occured while closing the connection"+e); + } + } + } + } + + private static String constructPolicyData(Object policyData, StringBuilder policyDataString){ + if(policyData instanceof PolicyType){ + PolicyType policy = (PolicyType) policyData; + TargetType target = policy.getTarget(); + if (target != null) { + // Under target we have AnyOFType + List<AnyOfType> anyOfList = target.getAnyOf(); + if (anyOfList != null) { + Iterator<AnyOfType> iterAnyOf = anyOfList.iterator(); + while (iterAnyOf.hasNext()) { + AnyOfType anyOf = iterAnyOf.next(); + // Under AnyOFType we have AllOFType + List<AllOfType> allOfList = anyOf.getAllOf(); + if (allOfList != null) { + Iterator<AllOfType> iterAllOf = allOfList.iterator(); + while (iterAllOf.hasNext()) { + AllOfType allOf = iterAllOf.next(); + // Under AllOFType we have Match + List<MatchType> matchList = allOf.getMatch(); + if (matchList != null) { + Iterator<MatchType> iterMatch = matchList.iterator(); + while (iterMatch.hasNext()) { + MatchType match = iterMatch.next(); + // + // Under the match we have attribute value and + // attributeDesignator. So,finally down to the actual attribute. + // + AttributeValueType attributeValue = match.getAttributeValue(); + String value = (String) attributeValue.getContent().get(0); + AttributeDesignatorType designator = match.getAttributeDesignator(); + String attributeId = designator.getAttributeId(); + // First match in the target is OnapName, so set that value. + if ("ONAPName".equals(attributeId)) { + policyDataString.append("\"onapName\":\""+value+"\","); + } + if ("RiskType".equals(attributeId)){ + policyDataString.append("\"riskType\":\""+value+"\","); + } + if ("RiskLevel".equals(attributeId)){ + policyDataString.append("\"riskLevel\":\""+value+"\","); + } + if ("guard".equals(attributeId)){ + policyDataString.append("\"guard\":\""+value+"\","); + } + if ("ConfigName".equals(attributeId)){ + policyDataString.append("\"configName\":\""+value+"\","); + } + } + } + } + } + } + } + } + } + return policyDataString.toString(); + } + +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnector.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnector.java new file mode 100644 index 000000000..1dea5dd4b --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnector.java @@ -0,0 +1,101 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + + +import java.util.Map; + +import org.onap.policy.rest.adapter.PolicyRestAdapter; + +import io.searchbox.client.JestResult; + +public interface ElkConnector { + + public static final String ELK_URL = "http://localhost:9200"; + public static final String ELK_INDEX_POLICY = "policy"; + + public enum PolicyIndexType { + config, + action, + decision, + closedloop, + all, + } + + public enum PolicyType { + Config, + Action, + Decision, + Config_Fault, + Config_PM, + Config_FW, + Config_MS, + none, + } + + public enum PolicyBodyType { + json, + xml, + properties, + txt, + none, + } + + public boolean delete(PolicyRestAdapter policyData) + throws IllegalStateException; + + public JestResult search(PolicyIndexType type, String text) + throws IllegalStateException, IllegalArgumentException; + + public JestResult search(PolicyIndexType type, String text, + Map<String, String> searchKeyValue) + throws IllegalStateException, IllegalArgumentException; + + public boolean update(PolicyRestAdapter policyData) throws IllegalStateException; + + public ElkConnector singleton = new ElkConnectorImpl(); + + public static PolicyIndexType toPolicyIndexType(String policyName) + throws IllegalArgumentException { + if (policyName == null) + throw new IllegalArgumentException("Unsupported NULL policy name conversion"); + + if (policyName.startsWith("Config_Fault")) { + return PolicyIndexType.closedloop; + } else if (policyName.startsWith("Config_PM")) { + return PolicyIndexType.closedloop; + } else if (policyName.startsWith("Config_FW")) { + return PolicyIndexType.config; + } else if (policyName.startsWith("Config_MS")) { + return PolicyIndexType.config; + }else if (policyName.startsWith("Action")) { + return PolicyIndexType.action; + } else if (policyName.startsWith("Decision")) { + return PolicyIndexType.decision; + } else if (policyName.startsWith("Config")) { + return PolicyIndexType.config; + } else { + throw new IllegalArgumentException + ("Unsupported policy name conversion to index: " + + policyName); + } + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnectorImpl.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnectorImpl.java new file mode 100644 index 000000000..8868db3bc --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/ElkConnectorImpl.java @@ -0,0 +1,418 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + +import java.io.IOException; +import java.util.Map; +import java.util.Map.Entry; + +import org.elasticsearch.index.query.QueryBuilders; +import org.elasticsearch.index.query.QueryStringQueryBuilder; +import org.elasticsearch.search.builder.SearchSourceBuilder; +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.xacml.api.XACMLErrorConstants; + +import io.searchbox.action.Action; +import io.searchbox.client.JestClient; +import io.searchbox.client.JestClientFactory; +import io.searchbox.client.JestResult; +import io.searchbox.client.config.HttpClientConfig; +import io.searchbox.core.Delete; +import io.searchbox.core.Index; +import io.searchbox.core.Search; +import io.searchbox.core.Search.Builder; +import io.searchbox.indices.IndicesExists; +import io.searchbox.indices.type.TypeExist; +import io.searchbox.params.Parameters; + +public class ElkConnectorImpl implements ElkConnector{ + + private static final Logger LOGGER = FlexLogger.getLogger(ElkConnector.class); + + protected final JestClientFactory jestFactory = new JestClientFactory(); + protected final JestClient jestClient; + protected static int QUERY_MAXRECORDS = 1000; + + public ElkConnectorImpl() { + if (LOGGER.isDebugEnabled()){ + LOGGER.debug("ENTER: -"); + } + HttpClientConfig jestClientConfig = new HttpClientConfig.Builder(ELK_URL).multiThreaded(true).build(); + jestFactory.setHttpClientConfig(jestClientConfig); + jestClient = jestFactory.getObject(); + } + + protected boolean isType(PolicyIndexType type) throws IOException { + if (LOGGER.isDebugEnabled()){ + LOGGER.debug("ENTER: -"); + } + + try { + Action<JestResult> typeQuery = new TypeExist.Builder(ELK_INDEX_POLICY).addType(type.toString()).build(); + JestResult result = jestClient.execute(typeQuery); + + if (LOGGER.isInfoEnabled()) { + LOGGER.info("JSON:" + result.getJsonString()); + LOGGER.info("ERROR:" + result.getErrorMessage()); + LOGGER.info("PATH:" + result.getPathToResult()); + LOGGER.info(result.getJsonObject()); + } + return result.isSucceeded(); + } catch (IOException e) { + LOGGER.warn("Error checking type existance of " + type.toString() + ": " + e.getMessage(), e); + throw e; + } + } + + protected boolean isIndex() throws IOException { + try { + Action<JestResult> indexQuery = new IndicesExists.Builder(ELK_INDEX_POLICY).build(); + + JestResult result = jestClient.execute(indexQuery); + if (LOGGER.isInfoEnabled()) { + LOGGER.info("JSON:" + result.getJsonString()); + LOGGER.info("ERROR:" + result.getErrorMessage()); + LOGGER.info("PATH:" + result.getPathToResult()); + LOGGER.info(result.getJsonObject()); + } + return result.isSucceeded(); + } catch (IOException e) { + LOGGER.warn("Error checking index existance of " + ELK_INDEX_POLICY + ": " + e.getMessage(), e); + throw e; + } + } + + @Override + public JestResult search(PolicyIndexType type, String text) throws IllegalStateException, IllegalArgumentException { + if (LOGGER.isTraceEnabled()){ + LOGGER.trace("ENTER: " + text); + } + + if (text == null || text.isEmpty()) { + throw new IllegalArgumentException("No search string provided"); + } + + QueryStringQueryBuilder mQ = QueryBuilders.queryStringQuery("*"+text+"*"); + SearchSourceBuilder searchSourceBuilder = + new SearchSourceBuilder().query(mQ); + + Builder searchBuilder = new Search.Builder(searchSourceBuilder.toString()). + addIndex(ELK_INDEX_POLICY). + setParameter(Parameters.SIZE, ElkConnectorImpl.QUERY_MAXRECORDS); + + if (type == null || type == PolicyIndexType.all) { + for (PolicyIndexType pT: PolicyIndexType.values()) { + if (pT != PolicyIndexType.all) { + searchBuilder.addType(pT.toString()); + } + } + } else { + searchBuilder.addType(type.toString()); + } + + Search search = searchBuilder.build(); + JestResult result; + try { + result = jestClient.execute(search); + } catch (IOException ioe) { + LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + ":" + + search + ": " + ioe.getMessage(), ioe); + throw new IllegalStateException(ioe); + } + + if (result.isSucceeded()) { + if (LOGGER.isInfoEnabled()){ + LOGGER.info("OK:" + result.getResponseCode() + ":" + search + ": " + + result.getPathToResult() + ":" + System.lineSeparator() + + result.getJsonString()); + } + } else { + /* Unsuccessful search */ + if (LOGGER.isWarnEnabled()){ + LOGGER.warn(XACMLErrorConstants.ERROR_PROCESS_FLOW + ":" + + result.getResponseCode() + ": " + + search.getURI() + ":" + + result.getPathToResult() + ":" + + result.getJsonString() + ":" + + result.getErrorMessage()); + } + + String errorMessage = result.getErrorMessage(); + if (errorMessage != null && !errorMessage.isEmpty()) { + String xMessage = errorMessage; + if (errorMessage.contains("TokenMgrError")) { + int indexError = errorMessage.lastIndexOf("TokenMgrError"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("QueryParsingException")) { + int indexError = errorMessage.lastIndexOf("QueryParsingException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("JsonParseException")) { + int indexError = errorMessage.lastIndexOf("JsonParseException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("Parse Failure")) { + int indexError = errorMessage.lastIndexOf("Parse Failure"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("SearchParseException")) { + int indexError = errorMessage.lastIndexOf("SearchParseException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else { + xMessage = result.getErrorMessage(); + } + throw new IllegalStateException(xMessage); + } + } + + return result; + } + + + @Override + public JestResult search(PolicyIndexType type, String text, + Map<String, String> filter_s) + throws IllegalStateException, IllegalArgumentException { + if (LOGGER.isTraceEnabled()){ + LOGGER.trace("ENTER: " + text); + } + + if (filter_s == null || filter_s.size() == 0) { + return search(type, text); + } + + String matches_s = ""; + matches_s = "{\n" + + " \"size\" : "+ ElkConnectorImpl.QUERY_MAXRECORDS + ",\n" + + " \"query\": {\n" + + " \"bool\" : {\n" + + " \"must\" : ["; + + String match_params = ""; + boolean first = true; + for(Entry<String, String> entry : filter_s.entrySet()){ + String key = entry.getKey(); + String value = entry.getValue(); + if(first){ + match_params = "\"match\" : {\""+key+"\" : \""+value+"\" }},"; + first = false; + }else{ + match_params = match_params + "{\"match\" : { \""+key+"\" : \""+value+"\" } },"; + } + } + if(match_params.endsWith(",")){ + match_params = match_params.substring(0, match_params.length()-2); + } + + matches_s = matches_s + "{\n" + match_params + "\n}" ; + + boolean query = false; + String query_String = ""; + if(text != null){ + query = true; + query_String = "{\n \"query_string\" : {\n \"query\" : \"*"+text+"*\"\n} \n}"; + } + + if(query){ + matches_s = matches_s + "," + query_String + "]\n}\n}\n}"; + }else{ + matches_s = matches_s + "]\n}\n}\n}"; + } + + Builder searchBuilder = new Search.Builder(matches_s).addIndex(ELK_INDEX_POLICY); + + if (type == null || type == PolicyIndexType.all) { + for (PolicyIndexType pT: PolicyIndexType.values()) { + if (pT != PolicyIndexType.all) { + searchBuilder.addType(pT.toString()); + } + } + } else { + searchBuilder.addType(type.toString()); + } + + Search search = searchBuilder.build(); + + JestResult result; + try { + result = jestClient.execute(search); + } catch (IOException ioe) { + LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + ":" + + search + ": " + ioe.getMessage(), ioe); + throw new IllegalStateException(ioe); + } + + if (result.isSucceeded()) { + if (LOGGER.isInfoEnabled()){ + LOGGER.info("OK:" + result.getResponseCode() + ":" + search + ": " + + result.getPathToResult() + ":" + System.lineSeparator() + + result.getJsonString()); + } + } else { + /* Unsuccessful search */ + if (LOGGER.isWarnEnabled()){ + LOGGER.warn(XACMLErrorConstants.ERROR_PROCESS_FLOW + ":" + + result.getResponseCode() + ": " + + search.getURI() + ":" + + result.getPathToResult() + ":" + + result.getJsonString() + ":" + + result.getErrorMessage()); + } + + String errorMessage = result.getErrorMessage(); + if (errorMessage != null && !errorMessage.isEmpty()) { + String xMessage = errorMessage; + if (errorMessage.contains("TokenMgrError")) { + int indexError = errorMessage.lastIndexOf("TokenMgrError"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("QueryParsingException")) { + int indexError = errorMessage.lastIndexOf("QueryParsingException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("JsonParseException")) { + int indexError = errorMessage.lastIndexOf("JsonParseException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("Parse Failure")) { + int indexError = errorMessage.lastIndexOf("Parse Failure"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else if (errorMessage.contains("SearchParseException")) { + int indexError = errorMessage.lastIndexOf("SearchParseException"); + xMessage = "Invalid Search Expression. Details: " + errorMessage.substring(indexError); + } else { + xMessage = result.getErrorMessage(); + } + throw new IllegalStateException(xMessage); + } + } + + return result; + } + + public boolean put(PolicyRestAdapter policyData) + throws IOException, IllegalStateException { + if (LOGGER.isTraceEnabled()) LOGGER.trace("ENTER"); + + PolicyIndexType indexType; + try { + String policyName = policyData.getNewFileName(); + if(policyName.contains("Config_")){ + policyName = policyName.replace(".Config_", ":Config_"); + }else if(policyName.contains("Action_")){ + policyName = policyName.replace(".Action_", ":Action_"); + }else if(policyName.contains("Decision_")){ + policyName = policyName.replace(".Decision_", ":Decision_"); + } + + String[] splitPolicyName = policyName.split(":"); + indexType = ElkConnector.toPolicyIndexType(splitPolicyName[1]); + } catch (IllegalArgumentException e) { + throw new IllegalStateException("ELK: Index: " + ELK_INDEX_POLICY + e.getMessage()); + } + PolicyElasticData elasticData = new PolicyElasticData(policyData); + JSONObject jsonObj = new JSONObject(elasticData); + Index elkPut = new Index.Builder(jsonObj.toString()). + index(ELK_INDEX_POLICY). + type(indexType.name()). + id(elasticData.getPolicyName()). + refresh(true). + build(); + + JestResult result = jestClient.execute(elkPut); + + if (result.isSucceeded()) { + if (LOGGER.isInfoEnabled()) + LOGGER.info("OK: PUT operation of " + "->" + ": " + + "success=" + result.isSucceeded() + "[" + result.getResponseCode() + ":" + + result.getPathToResult() + "]" + System.lineSeparator() + + result.getJsonString()); + } else { + if (LOGGER.isWarnEnabled()) + LOGGER.warn("FAILURE: PUT operation of "+ "->" + ": " + + "success=" + result.isSucceeded() + "[" + result.getResponseCode() + ":" + + result.getPathToResult() + "]" + System.lineSeparator() + + result.getJsonString()); + + } + + return result.isSucceeded(); + } + + @Override + public boolean delete(PolicyRestAdapter policyData) throws IllegalStateException { + PolicyIndexType indexType = null; + JestResult result; + try { + String policyName = policyData.getNewFileName(); + if(policyName.contains("Config_")){ + policyName = policyName.replace(".Config_", ":Config_"); + }else if(policyName.contains("Action_")){ + policyName = policyName.replace(".Action_", ":Action_"); + }else if(policyName.contains("Decision_")){ + policyName = policyName.replace(".Decision_", ":Decision_"); + } + + String[] splitPolicyName = policyName.split(":"); + indexType = ElkConnector.toPolicyIndexType(splitPolicyName[1]); + if (!isType(indexType)) { + throw new IllegalStateException("ELK: Index: " + ELK_INDEX_POLICY + + " Type: " + indexType + + " is not configured"); + } + PolicyElasticData elasticData = new PolicyElasticData(policyData); + Delete deleteRequest = new Delete.Builder(elasticData.getPolicyName()).index(ELK_INDEX_POLICY). + type(indexType.name()).build(); + result = jestClient.execute(deleteRequest); + } catch (IllegalArgumentException | IOException e) { + LOGGER.warn(XACMLErrorConstants.ERROR_SYSTEM_ERROR + ": delete:" + + indexType + ": null" + ":" + policyData.getNewFileName() + ": " + + e.getMessage(), e); + throw new IllegalStateException(e); + } + + if (result.isSucceeded()) { + if (LOGGER.isInfoEnabled()) + LOGGER.info("OK: DELETE operation of " + indexType + ":" + policyData.getNewFileName() + ": " + + "success=" + result.isSucceeded() + "[" + result.getResponseCode() + ":" + + result.getPathToResult() + "]" + System.lineSeparator() + + result.getJsonString()); + } else { + if (LOGGER.isWarnEnabled()) + LOGGER.warn("FAILURE: DELETE operation of " + indexType + ":" + policyData.getNewFileName() + ": " + + "success=" + result.isSucceeded() + "[" + result.getResponseCode() + ":" + + result.getPathToResult() + "]" + System.lineSeparator() + + result.getJsonString()); + } + + return result.isSucceeded(); + } + + @Override + public boolean update(PolicyRestAdapter policyData) throws IllegalStateException { + if (LOGGER.isDebugEnabled()){ + LOGGER.debug("ENTER"); + } + try { + boolean success = put(policyData); + return success; + } catch (Exception e) { + LOGGER.warn(XACMLErrorConstants.ERROR_UNKNOWN + ":" + "cannot test and update", e); + throw new IllegalStateException(e); + } + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/Pair.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/Pair.java new file mode 100644 index 000000000..2b0c94bf3 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/Pair.java @@ -0,0 +1,33 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + +public class Pair<L,R> { + private L left; + private R right; + public Pair(L l, R r){ + this.left = l; + this.right = r; + } + public L left(){ return left; } + public R right(){ return right; } + public void left(L l){ this.left = l; } + public void right(R r){ this.right = r; } +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticData.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticData.java new file mode 100644 index 000000000..3e065ff05 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticData.java @@ -0,0 +1,623 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + +import java.util.ArrayList; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.adapter.YAMLParams; + +public class PolicyElasticData { + + private String scope; + private String policyType; + private String configPolicyType; + private String configBodyData; + private String policyName; + private String policyDescription; + private String onapName; + private String configName; + private String configType; + private String jsonBody; + private Object jsonBodyData; + + private LinkedHashMap<?, ?> serviceTypePolicyName; + private LinkedHashMap<?, ?> verticaMetrics; + private LinkedHashMap<?, ?> description; + private LinkedHashMap<?, ?> attributeFields; + + //Safe Policy + private String policyScope; + private String providerComboBox; + private String riskType; + private String riskLevel; + private String guard; + private String ttlDate; + private Map<String,String> matching; + + private ArrayList<Object> triggerSignatures; + private ArrayList<Object> symptomSignatures; + private String logicalConnector; + private String policyStatus; + public String gocServerScope; + private String supressionType; + + //MicroSerice + private String serviceType; + private String uuid; + private String location; + private String priority; + private String msLocation; + + //BRMS Policies + private String ruleName; + private Map<String,String> brmsParamBody; + private String brmsController; + private ArrayList<String> brmsDependency; + private LinkedHashMap<?, ?> ruleData; + private LinkedHashMap<?,?> ruleListData; + private Map<String,String> drlRuleAndUIParams; + + //ClosedLoop + private String clearTimeOut; + private String trapMaxAge; + private String verificationclearTimeOut; + public Map<String , String> dynamicLayoutMap; + + //FireWall + private String fwPolicyType; + private ArrayList<Object> fwattributes; + private String parentForChild; + private String securityZone; + + //Action & Decision + private String ruleCombiningAlgId; + private Map<String,String> dynamicFieldConfigAttributes; + private Map<String,String> dynamicSettingsMap; + private Map<String,String> dropDownMap; + private String actionPerformer; + private String actionAttribute; + private List<String> dynamicRuleAlgorithmLabels; + private List<String> dynamicRuleAlgorithmCombo; + private List<String> dynamicRuleAlgorithmField1; + private List<String> dynamicRuleAlgorithmField2; + private List<Object> dynamicVariableList; + private List<String> dataTypeList; + private String actionAttributeValue; + private String ruleProvider; + private String actionBody; + private String actionDictHeader; + private String actionDictType; + private String actionDictUrl; + private String actionDictMethod; + private YAMLParams yamlparams; + + public PolicyElasticData(PolicyRestAdapter policyData) { + this.scope = policyData.getDomain(); + this.policyType = policyData.getPolicyType(); + this.configPolicyType = policyData.getConfigPolicyType(); + this.configBodyData = policyData.getConfigBodyData(); + this.policyName = policyData.getNewFileName(); + this.policyDescription = policyData.getPolicyDescription(); + this.onapName = policyData.getOnapName(); + this.configName = policyData.getConfigName(); + this.configType = policyData.getConfigType(); + this.jsonBody = policyData.getJsonBody(); + if(configPolicyType.startsWith("ClosedLoop")){ + this.jsonBodyData = jsonBody; + }else{ + this.jsonBodyData = policyData.getJsonBodyData(); + } + + this.serviceTypePolicyName = policyData.getServiceTypePolicyName(); + this.verticaMetrics = policyData.getVerticaMetrics(); + this.description = policyData.getDescription(); + this.attributeFields = policyData.getAttributeFields(); + + //Safe Policy + this.policyScope = policyData.getPolicyScope(); + this.providerComboBox = policyData.getProviderComboBox(); + this.riskType = policyData.getRiskType(); + this.riskLevel = policyData.getRiskLevel(); + this.guard = policyData.getGuard(); + this.ttlDate = policyData.getTtlDate(); + this.matching = policyData.getMatching(); + + this.triggerSignatures = policyData.getTriggerSignatures(); + this.symptomSignatures = policyData.getSymptomSignatures(); + this.logicalConnector = policyData.getLogicalConnector(); + this.policyStatus = policyData.getPolicyStatus(); + this.gocServerScope = policyData.getGocServerScope(); + this.supressionType = policyData.getSupressionType(); + + //MicroSerice + this.serviceType = policyData.getServiceType(); + this.uuid = policyData.getUuid(); + this.location = policyData.getLocation(); + this.priority = policyData.getPriority(); + this.msLocation = policyData.getMsLocation(); + + //BRMS Policies + this.ruleName = policyData.getRuleName(); + this.brmsParamBody = policyData.getBrmsParamBody(); + this.brmsController = policyData.getBrmsController(); + this.brmsDependency = policyData.getBrmsDependency(); + this.ruleData = policyData.getRuleData(); + this.ruleListData = policyData.getRuleListData(); + this.drlRuleAndUIParams = policyData.getDrlRuleAndUIParams(); + + //ClosedLoop + this.clearTimeOut = policyData.getClearTimeOut(); + this.trapMaxAge = policyData.getTrapMaxAge(); + this.verificationclearTimeOut = policyData.getVerificationclearTimeOut(); + this.dynamicLayoutMap = policyData.getDynamicLayoutMap(); + + //FireWall + this.fwPolicyType = policyData.getFwPolicyType(); + this.fwattributes = policyData.getFwattributes(); + this.parentForChild = policyData.getParentForChild(); + this.securityZone = policyData.getSecurityZone(); + + //Action & Decision + this.ruleCombiningAlgId = policyData.getRuleCombiningAlgId(); + this.dynamicFieldConfigAttributes = policyData.getDynamicFieldConfigAttributes(); + this.dynamicSettingsMap = policyData.getDynamicSettingsMap(); + this.dropDownMap = policyData.getDropDownMap(); + this.actionPerformer = policyData.getActionPerformer(); + this.actionAttribute = policyData.getActionAttribute(); + this.dynamicRuleAlgorithmLabels = policyData.getDynamicRuleAlgorithmLabels(); + this.dynamicRuleAlgorithmCombo = policyData.getDynamicRuleAlgorithmCombo(); + this.dynamicRuleAlgorithmField1 = policyData.getDynamicRuleAlgorithmField1(); + this.dynamicRuleAlgorithmField2 = policyData.getDynamicRuleAlgorithmField2(); + this.dynamicVariableList = policyData.getDynamicVariableList(); + this.dataTypeList = policyData.getDataTypeList(); + this.actionAttributeValue = policyData.getActionAttributeValue(); + this.ruleProvider = policyData.getRuleProvider(); + this.actionBody = policyData.getActionBody(); + this.actionDictHeader = policyData.getActionDictHeader(); + this.actionDictType = policyData.getActionDictType(); + this.actionDictUrl = policyData.getActionDictUrl(); + this.actionDictMethod = policyData.getActionDictMethod(); + this.yamlparams = policyData.getYamlparams(); + } + + public String getScope() { + return scope; + } + public void setScope(String scope) { + this.scope = scope; + } + public String getPolicyType() { + return policyType; + } + public void setPolicyType(String policyType) { + this.policyType = policyType; + } + public String getConfigPolicyType() { + return configPolicyType; + } + public void setConfigPolicyType(String configPolicyType) { + this.configPolicyType = configPolicyType; + } + public String getConfigBodyData() { + return configBodyData; + } + + public void setConfigBodyData(String configBodyData) { + this.configBodyData = configBodyData; + } + public String getPolicyName() { + return policyName; + } + public void setPolicyName(String policyName) { + this.policyName = policyName; + } + public String getPolicyDescription() { + return policyDescription; + } + public void setPolicyDescription(String policyDescription) { + this.policyDescription = policyDescription; + } + public String getOnapName() { + return onapName; + } + public void setOnapName(String onapName) { + this.onapName = onapName; + } + public String getConfigName() { + return configName; + } + public void setConfigName(String configName) { + this.configName = configName; + } + public String getConfigType() { + return configType; + } + public void setConfigType(String configType) { + this.configType = configType; + } + public String getJsonBody() { + return jsonBody; + } + public void setJsonBody(String jsonBody) { + this.jsonBody = jsonBody; + } + public LinkedHashMap<?, ?> getServiceTypePolicyName() { + return serviceTypePolicyName; + } + + public void setServiceTypePolicyName(LinkedHashMap<?, ?> serviceTypePolicyName) { + this.serviceTypePolicyName = serviceTypePolicyName; + } + + public LinkedHashMap<?, ?> getVerticaMetrics() { + return verticaMetrics; + } + + public void setVerticaMetrics(LinkedHashMap<?, ?> verticaMetrics) { + this.verticaMetrics = verticaMetrics; + } + + public LinkedHashMap<?, ?> getDescription() { + return description; + } + + public void setDescription(LinkedHashMap<?, ?> description) { + this.description = description; + } + + public LinkedHashMap<?, ?> getAttributeFields() { + return attributeFields; + } + + public void setAttributeFields(LinkedHashMap<?, ?> attributeFields) { + this.attributeFields = attributeFields; + } + public String getPolicyScope() { + return policyScope; + } + public void setPolicyScope(String policyScope) { + this.policyScope = policyScope; + } + public String getProviderComboBox() { + return providerComboBox; + } + public void setProviderComboBox(String providerComboBox) { + this.providerComboBox = providerComboBox; + } + public String getRiskType() { + return riskType; + } + public void setRiskType(String riskType) { + this.riskType = riskType; + } + public String getRiskLevel() { + return riskLevel; + } + public void setRiskLevel(String riskLevel) { + this.riskLevel = riskLevel; + } + public String getGuard() { + return guard; + } + public void setGuard(String guard) { + this.guard = guard; + } + public String getTtlDate() { + return ttlDate; + } + public void setTtlDate(String ttlDate) { + this.ttlDate = ttlDate; + } + public Map<String, String> getMatching() { + return matching; + } + public void setMatching(Map<String, String> matching) { + this.matching = matching; + } + public ArrayList<Object> getTriggerSignatures() { + return triggerSignatures; + } + public void setTriggerSignatures(ArrayList<Object> triggerSignatures) { + this.triggerSignatures = triggerSignatures; + } + public ArrayList<Object> getSymptomSignatures() { + return symptomSignatures; + } + public void setSymptomSignatures(ArrayList<Object> symptomSignatures) { + this.symptomSignatures = symptomSignatures; + } + public String getLogicalConnector() { + return logicalConnector; + } + public void setLogicalConnector(String logicalConnector) { + this.logicalConnector = logicalConnector; + } + public String getPolicyStatus() { + return policyStatus; + } + public void setPolicyStatus(String policyStatus) { + this.policyStatus = policyStatus; + } + public String getGocServerScope() { + return gocServerScope; + } + public void setGocServerScope(String gocServerScope) { + this.gocServerScope = gocServerScope; + } + public String getSupressionType() { + return supressionType; + } + public void setSupressionType(String supressionType) { + this.supressionType = supressionType; + } + public String getServiceType() { + return serviceType; + } + public void setServiceType(String serviceType) { + this.serviceType = serviceType; + } + public String getUuid() { + return uuid; + } + public void setUuid(String uuid) { + this.uuid = uuid; + } + public String getLocation() { + return location; + } + public void setLocation(String location) { + this.location = location; + } + public String getPriority() { + return priority; + } + public void setPriority(String priority) { + this.priority = priority; + } + public String getMsLocation() { + return msLocation; + } + public void setMsLocation(String msLocation) { + this.msLocation = msLocation; + } + public String getRuleName() { + return ruleName; + } + public void setRuleName(String ruleName) { + this.ruleName = ruleName; + } + public Map<String, String> getBrmsParamBody() { + return brmsParamBody; + } + public void setBrmsParamBody(Map<String, String> brmsParamBody) { + this.brmsParamBody = brmsParamBody; + } + public String getBrmsController() { + return brmsController; + } + public void setBrmsController(String brmsController) { + this.brmsController = brmsController; + } + public ArrayList<String> getBrmsDependency() { + return brmsDependency; + } + public void setBrmsDependency(ArrayList<String> brmsDependency) { + this.brmsDependency = brmsDependency; + } + public LinkedHashMap<?, ?> getRuleData() { + return ruleData; + } + public void setRuleData(LinkedHashMap<?, ?> ruleData) { + this.ruleData = ruleData; + } + public LinkedHashMap<?, ?> getRuleListData() { + return ruleListData; + } + public void setRuleListData(LinkedHashMap<?, ?> ruleListData) { + this.ruleListData = ruleListData; + } + public Map<String, String> getDrlRuleAndUIParams() { + return drlRuleAndUIParams; + } + public void setDrlRuleAndUIParams(Map<String, String> drlRuleAndUIParams) { + this.drlRuleAndUIParams = drlRuleAndUIParams; + } + public String getClearTimeOut() { + return clearTimeOut; + } + public void setClearTimeOut(String clearTimeOut) { + this.clearTimeOut = clearTimeOut; + } + public String getTrapMaxAge() { + return trapMaxAge; + } + public void setTrapMaxAge(String trapMaxAge) { + this.trapMaxAge = trapMaxAge; + } + public String getVerificationclearTimeOut() { + return verificationclearTimeOut; + } + public void setVerificationclearTimeOut(String verificationclearTimeOut) { + this.verificationclearTimeOut = verificationclearTimeOut; + } + public Map<String, String> getDynamicLayoutMap() { + return dynamicLayoutMap; + } + public void setDynamicLayoutMap(Map<String, String> dynamicLayoutMap) { + this.dynamicLayoutMap = dynamicLayoutMap; + } + public String getFwPolicyType() { + return fwPolicyType; + } + public void setFwPolicyType(String fwPolicyType) { + this.fwPolicyType = fwPolicyType; + } + public ArrayList<Object> getFwattributes() { + return fwattributes; + } + public void setFwattributes(ArrayList<Object> fwattributes) { + this.fwattributes = fwattributes; + } + public String getParentForChild() { + return parentForChild; + } + public void setParentForChild(String parentForChild) { + this.parentForChild = parentForChild; + } + public String getSecurityZone() { + return securityZone; + } + public void setSecurityZone(String securityZone) { + this.securityZone = securityZone; + } + public String getRuleCombiningAlgId() { + return ruleCombiningAlgId; + } + public void setRuleCombiningAlgId(String ruleCombiningAlgId) { + this.ruleCombiningAlgId = ruleCombiningAlgId; + } + public Map<String, String> getDynamicFieldConfigAttributes() { + return dynamicFieldConfigAttributes; + } + public void setDynamicFieldConfigAttributes(Map<String, String> dynamicFieldConfigAttributes) { + this.dynamicFieldConfigAttributes = dynamicFieldConfigAttributes; + } + public Map<String, String> getDynamicSettingsMap() { + return dynamicSettingsMap; + } + public void setDynamicSettingsMap(Map<String, String> dynamicSettingsMap) { + this.dynamicSettingsMap = dynamicSettingsMap; + } + public Map<String, String> getDropDownMap() { + return dropDownMap; + } + public void setDropDownMap(Map<String, String> dropDownMap) { + this.dropDownMap = dropDownMap; + } + public String getActionPerformer() { + return actionPerformer; + } + public void setActionPerformer(String actionPerformer) { + this.actionPerformer = actionPerformer; + } + public String getActionAttribute() { + return actionAttribute; + } + public void setActionAttribute(String actionAttribute) { + this.actionAttribute = actionAttribute; + } + public List<String> getDynamicRuleAlgorithmLabels() { + return dynamicRuleAlgorithmLabels; + } + public void setDynamicRuleAlgorithmLabels(List<String> dynamicRuleAlgorithmLabels) { + this.dynamicRuleAlgorithmLabels = dynamicRuleAlgorithmLabels; + } + public List<String> getDynamicRuleAlgorithmCombo() { + return dynamicRuleAlgorithmCombo; + } + public void setDynamicRuleAlgorithmCombo(List<String> dynamicRuleAlgorithmCombo) { + this.dynamicRuleAlgorithmCombo = dynamicRuleAlgorithmCombo; + } + public List<String> getDynamicRuleAlgorithmField1() { + return dynamicRuleAlgorithmField1; + } + public void setDynamicRuleAlgorithmField1(List<String> dynamicRuleAlgorithmField1) { + this.dynamicRuleAlgorithmField1 = dynamicRuleAlgorithmField1; + } + public List<String> getDynamicRuleAlgorithmField2() { + return dynamicRuleAlgorithmField2; + } + public void setDynamicRuleAlgorithmField2(List<String> dynamicRuleAlgorithmField2) { + this.dynamicRuleAlgorithmField2 = dynamicRuleAlgorithmField2; + } + public List<Object> getDynamicVariableList() { + return dynamicVariableList; + } + public void setDynamicVariableList(List<Object> dynamicVariableList) { + this.dynamicVariableList = dynamicVariableList; + } + public List<String> getDataTypeList() { + return dataTypeList; + } + public void setDataTypeList(List<String> dataTypeList) { + this.dataTypeList = dataTypeList; + } + public String getActionAttributeValue() { + return actionAttributeValue; + } + public void setActionAttributeValue(String actionAttributeValue) { + this.actionAttributeValue = actionAttributeValue; + } + public String getRuleProvider() { + return ruleProvider; + } + public void setRuleProvider(String ruleProvider) { + this.ruleProvider = ruleProvider; + } + public String getActionBody() { + return actionBody; + } + public void setActionBody(String actionBody) { + this.actionBody = actionBody; + } + public String getActionDictHeader() { + return actionDictHeader; + } + public void setActionDictHeader(String actionDictHeader) { + this.actionDictHeader = actionDictHeader; + } + public String getActionDictType() { + return actionDictType; + } + public void setActionDictType(String actionDictType) { + this.actionDictType = actionDictType; + } + public String getActionDictUrl() { + return actionDictUrl; + } + public void setActionDictUrl(String actionDictUrl) { + this.actionDictUrl = actionDictUrl; + } + public String getActionDictMethod() { + return actionDictMethod; + } + public void setActionDictMethod(String actionDictMethod) { + this.actionDictMethod = actionDictMethod; + } + public YAMLParams getYamlparams() { + return yamlparams; + } + + public void setYamlparams(YAMLParams yamlparams) { + this.yamlparams = yamlparams; + } + + public Object getJsonBodyData() { + return jsonBodyData; + } + + public void setJsonBodyData(Object jsonBodyData) { + this.jsonBodyData = jsonBodyData; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticSearchController.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticSearchController.java new file mode 100644 index 000000000..2f4dc59cf --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyElasticSearchController.java @@ -0,0 +1,563 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + + +import java.io.PrintWriter; +import java.security.KeyManagementException; +import java.security.NoSuchAlgorithmException; +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.net.ssl.HostnameVerifier; +import javax.net.ssl.HttpsURLConnection; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLSession; +import javax.net.ssl.TrustManager; +import javax.net.ssl.X509TrustManager; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.elk.client.ElkConnector.PolicyIndexType; +import org.onap.policy.pap.xacml.rest.util.JsonMessage; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ActionPolicyDict; +import org.onap.policy.rest.jpa.Attribute; +import org.onap.policy.rest.jpa.BRMSParamTemplate; +import org.onap.policy.rest.jpa.ClosedLoopD2Services; +import org.onap.policy.rest.jpa.ClosedLoopSite; +import org.onap.policy.rest.jpa.DCAEuuid; +import org.onap.policy.rest.jpa.DecisionSettings; +import org.onap.policy.rest.jpa.DescriptiveScope; +import org.onap.policy.rest.jpa.OnapName; +import org.onap.policy.rest.jpa.GroupPolicyScopeList; +import org.onap.policy.rest.jpa.MicroServiceLocation; +import org.onap.policy.rest.jpa.MicroServiceModels; +import org.onap.policy.rest.jpa.PEPOptions; +import org.onap.policy.rest.jpa.RiskType; +import org.onap.policy.rest.jpa.SafePolicyWarning; +import org.onap.policy.rest.jpa.TermList; +import org.onap.policy.rest.jpa.VNFType; +import org.onap.policy.rest.jpa.VSCLAction; +import org.onap.policy.rest.jpa.VarbindDictionary; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.servlet.ModelAndView; + +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.gson.JsonArray; + +import io.searchbox.client.JestResult; + +@Controller +@RequestMapping({"/"}) +public class PolicyElasticSearchController{ + + private static final Logger LOGGER = FlexLogger.getLogger(PolicyElasticSearchController.class); + + enum Mode{ + attribute, onapName, actionPolicy, brmsParam, pepOptions, + clSite, clService, clVarbind, clVnf, clVSCL, decision, + fwTerm, msDCAEUUID, msConfigName, msLocation, msModels, + psGroupPolicy, safeRisk, safePolicyWarning + } + + public static final HashMap<String, String> name2jsonPath = new HashMap<String, String>() { + private static final long serialVersionUID = 1L; + }; + + public static CommonClassDao commonClassDao; + + @Autowired + public PolicyElasticSearchController(CommonClassDao commonClassDao) { + PolicyElasticSearchController.commonClassDao = commonClassDao; + } + + public PolicyElasticSearchController() {} + + public static void TurnOffCertsCheck() { + // Create a trust manager that does not validate certificate chains + TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() { + public java.security.cert.X509Certificate[] getAcceptedIssuers() { + return null; + } + public void checkClientTrusted(X509Certificate[] certs, + String authType) { + } + public void checkServerTrusted(X509Certificate[] certs, + String authType) { + } + } }; + + // Install all-trusting trust manager + SSLContext ctx; + try { + ctx = SSLContext.getInstance("SSL"); + ctx.init(null, trustAllCerts, new java.security.SecureRandom()); + HttpsURLConnection.setDefaultSSLSocketFactory(ctx + .getSocketFactory()); + } catch (NoSuchAlgorithmException | KeyManagementException e) { + LOGGER.error("SSL Security Error: " + e); + } + + // Create all-trusting host name verifier + HostnameVerifier allHostsValid = new HostnameVerifier() { + public boolean verify(String hostname, SSLSession session) { + return true; + } + }; + + // Install the all-trusting host verifier + HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid); + } + + + + + public ElkConnector.PolicyIndexType toPolicyIndexType(String type) throws IllegalArgumentException { + if (type == null || type.isEmpty()){ + return PolicyIndexType.all; + } + return PolicyIndexType.valueOf(type); + } + + public boolean updateElk(PolicyRestAdapter policyData) { + boolean success = true; + try { + success = ElkConnector.singleton.update(policyData); + if (!success) { + if (LOGGER.isWarnEnabled()) { + LOGGER.warn("FAILURE to create ELK record created for " + policyData.getNewFileName()); + } + } else { + if (LOGGER.isInfoEnabled()) { + LOGGER.warn("SUCCESS creating ELK record created for " + policyData.getNewFileName()); + } + } + } catch (Exception e) { + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + ": " + e.getMessage(), e); + success = false; + } + return success; + } + + public boolean deleteElk(PolicyRestAdapter policyData) { + boolean success = true; + try { + success = ElkConnector.singleton.delete(policyData); + if (!success) { + if (LOGGER.isWarnEnabled()) { + LOGGER.warn("FAILURE to delete ELK record created for " + policyData.getNewFileName()); + } + } else { + if (LOGGER.isInfoEnabled()) { + LOGGER.warn("SUCCESS deleting ELK record created for " + policyData.getNewFileName()); + } + } + } catch (Exception e) { + LOGGER.warn(XACMLErrorConstants.ERROR_DATA_ISSUE + ": " + e.getMessage(), e); + success = false; + } + return success; + } + + + @RequestMapping(value="/searchPolicy", method= RequestMethod.POST) + public void searchPolicy(HttpServletRequest request, HttpServletResponse response) { + try{ + boolean result = false; + boolean policyResult = false; + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + PolicyElasticSearchController controller = new PolicyElasticSearchController(); + Map<String, String> searchKeyValue = new HashMap<>(); + List<String> policyList = new ArrayList<>(); + if(request.getParameter("policyName") != null){ + String policyName = request.getParameter("policyName"); + policyData.setNewFileName(policyName); + if("delete".equalsIgnoreCase(request.getParameter("action"))){ + result = controller.deleteElk(policyData); + }else{ + result = controller.updateElk(policyData); + } + } + if("search".equalsIgnoreCase(request.getParameter("action"))){ + try { + JsonNode root = mapper.readTree(request.getReader()); + SearchData searchData = (SearchData)mapper.readValue(root.get("searchdata").toString(), SearchData.class); + + String policyType = searchData.getPolicyType(); + + String searchText = searchData.getQuery(); + String descriptivevalue = searchData.getDescriptiveScope(); + if(descriptivevalue != null){ + DescriptiveScope dsSearch = (DescriptiveScope) commonClassDao.getEntityItem(DescriptiveScope.class, "descriptiveScopeName", descriptivevalue); + if(dsSearch != null){ + String[] descriptiveList = dsSearch.getSearch().split("AND"); + for(String keyValue : descriptiveList){ + String[] entry = keyValue.split(":"); + if(searchData.getPolicyType() != null && "closedLoop".equals(searchData.getPolicyType())){ + searchKeyValue.put("jsonBodyData", "*" +entry[1] +"*"); + }else{ + searchKeyValue.put(entry[0], entry[1]); + } + } + } + } + + if(searchData.getClosedLooppolicyType() != null){ + String closedLoopType; + if("Config_Fault".equalsIgnoreCase(searchData.getClosedLooppolicyType())){ + closedLoopType = "ClosedLoop_Fault"; + }else{ + closedLoopType = "ClosedLoop_PM"; + } + searchKeyValue.put("configPolicyType", closedLoopType); + } + if(searchData.getOnapName() != null){ + searchKeyValue.put("onapName", searchData.getOnapName()); + } + if(searchData.getD2Service() != null){ + String d2Service = searchData.getD2Service().trim(); + if(d2Service.equalsIgnoreCase("Hosted Voice (Trinity)")){ + d2Service = "trinity"; + }else if(d2Service.equalsIgnoreCase("vUSP")){ + d2Service = "vUSP"; + }else if(d2Service.equalsIgnoreCase("MCR")){ + d2Service = "mcr"; + }else if(d2Service.equalsIgnoreCase("Gamma")){ + d2Service = "gamma"; + }else if(d2Service.equalsIgnoreCase("vDNS")){ + d2Service = "vDNS"; + } + searchKeyValue.put("jsonBodyData."+d2Service+"", "true"); + } + if(searchData.getVnfType() != null){ + searchKeyValue.put("jsonBodyData", "*" +searchData.getVnfType() +"*"); + } + if(searchData.getPolicyStatus() != null){ + searchKeyValue.put("jsonBodyData", "*" +searchData.getPolicyStatus()+"*"); + } + if(searchData.getVproAction() != null){ + searchKeyValue.put("jsonBodyData", "*" +searchData.getVproAction()+"*"); + } + if(searchData.getServiceType() != null){ + searchKeyValue.put("serviceType", searchData.getServiceType()); + } + if(searchData.getBindTextSearch() != null){ + searchKeyValue.put(searchData.getBindTextSearch(), searchText); + searchText = null; + } + PolicyIndexType type = null; + if(policyType != null){ + if(policyType.equalsIgnoreCase("action")){ + type = ElkConnector.PolicyIndexType.action; + }else if(policyType.equalsIgnoreCase("decision")){ + type = ElkConnector.PolicyIndexType.decision; + }else if(policyType.equalsIgnoreCase("config")){ + type = ElkConnector.PolicyIndexType.config; + }else { + type = ElkConnector.PolicyIndexType.closedloop; + } + }else{ + type = ElkConnector.PolicyIndexType.all; + } + JestResult policyResultList = controller.search(type, searchText, searchKeyValue); + if(policyResultList.isSucceeded()){ + result = true; + policyResult = true; + JsonArray resultObject = policyResultList.getJsonObject().get("hits").getAsJsonObject().get("hits").getAsJsonArray(); + for(int i =0; i < resultObject.size(); i++){ + String policyName = resultObject.get(i).getAsJsonObject().get("_id").toString(); + policyList.add(policyName); + } + }else{ + LOGGER.error("Exception Occured While Searching for Data in Elastic Search Server, Check the Logs"); + } + }catch(Exception e){ + LOGGER.error("Exception Occured While Searching for Data in Elastic Search Server" + e); + } + } + String message=""; + if(result){ + message = "Elastic Server Transaction is success"; + }else{ + message = "Elastic Server Transaction is failed, please check the logs"; + } + JsonMessage msg = new JsonMessage(mapper.writeValueAsString(message)); + JSONObject j = new JSONObject(msg); + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("success", "success"); + if(policyResult){ + JSONObject k = new JSONObject("{policyresult: " + policyList + "}"); + response.getWriter().write(k.toString()); + }else{ + response.getWriter().write(j.toString()); + } + }catch(Exception e){ + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "Exception Occured While Performing Elastic Transaction"); + LOGGER.error("Exception Occured While Performing Elastic Transaction"+e.getMessage()); + } + } + + @RequestMapping(value={"/searchDictionary"}, method={org.springframework.web.bind.annotation.RequestMethod.POST}) + public ModelAndView searchDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + try{ + PolicyIndexType config = PolicyIndexType.config; + PolicyIndexType closedloop = PolicyIndexType.closedloop; + PolicyIndexType action = PolicyIndexType.action; + PolicyIndexType decision = PolicyIndexType.decision; + PolicyIndexType all = PolicyIndexType.all; + + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + JsonNode root = mapper.readTree(request.getReader()); + String dictionaryType = root.get("type").textValue(); + Mode mode = Mode.valueOf(dictionaryType); + String value; + List<String> policyList = new ArrayList<>(); + switch (mode){ + case attribute : + Attribute attributedata = (Attribute)mapper.readValue(root.get("data").toString(), Attribute.class); + value = attributedata.getXacmlId(); + policyList = searchElkDatabase(all, "pholder",value); + break; + case onapName : + OnapName onapName = (OnapName)mapper.readValue(root.get("data").toString(), OnapName.class); + value = onapName.getOnapName(); + policyList = searchElkDatabase(all, "onapName",value); + break; + case actionPolicy : + ActionPolicyDict actionPolicyDict = (ActionPolicyDict)mapper.readValue(root.get("data").toString(), ActionPolicyDict.class); + value = actionPolicyDict.getAttributeName(); + policyList = searchElkDatabase(action, "actionAttributeValue",value); + break; + case brmsParam : + BRMSParamTemplate bRMSParamTemplate = (BRMSParamTemplate)mapper.readValue(root.get("data").toString(), BRMSParamTemplate.class); + value = bRMSParamTemplate.getRuleName(); + policyList = searchElkDatabase(config, "ruleName",value); + break; + case pepOptions : + PEPOptions pEPOptions = (PEPOptions)mapper.readValue(root.get("data").toString(), PEPOptions.class); + value = pEPOptions.getPepName(); + policyList = searchElkDatabase(closedloop,"jsonBodyData.pepName",value); + break; + case clSite : + ClosedLoopSite closedLoopSite = (ClosedLoopSite)mapper.readValue(root.get("data").toString(), ClosedLoopSite.class); + value = closedLoopSite.getSiteName(); + policyList = searchElkDatabase(closedloop,"siteNames",value); + break; + case clService : + ClosedLoopD2Services closedLoopD2Services = (ClosedLoopD2Services)mapper.readValue(root.get("data").toString(), ClosedLoopD2Services.class); + value = closedLoopD2Services.getServiceName(); + policyList = searchElkDatabase(closedloop, "pholder",value); + break; + case clVarbind : + VarbindDictionary varbindDictionary = (VarbindDictionary)mapper.readValue(root.get("data").toString(), VarbindDictionary.class); + value = varbindDictionary.getVarbindName(); + policyList = searchElkDatabase(closedloop, "jsonBodyData.triggerSignaturesUsedForUI.signatures",value); + break; + case clVnf : + VNFType vNFType = (VNFType)mapper.readValue(root.get("data").toString(), VNFType.class); + value = vNFType.getVnftype(); + policyList = searchElkDatabase(closedloop, "jsonBodyData.vnfType",value); + break; + case clVSCL : + VSCLAction vsclAction = (VSCLAction)mapper.readValue(root.get("data").toString(), VSCLAction.class); + value = vsclAction.getVsclaction(); + policyList = searchElkDatabase(closedloop, "jsonBodyData.actions",value); + break; + case decision : + DecisionSettings decisionSettings = (DecisionSettings)mapper.readValue(root.get("data").toString(), DecisionSettings.class); + value = decisionSettings.getXacmlId(); + policyList = searchElkDatabase(decision,"pholder",value); + break; + case fwTerm : + TermList term = (TermList)mapper.readValue(root.get("data").toString(), TermList.class); + value = term.getTermName(); + policyList = searchElkDatabase(config, "pholder",value); + break; + case msDCAEUUID : + DCAEuuid dcaeUUID = (DCAEuuid)mapper.readValue(root.get("data").toString(), DCAEuuid.class); + value = dcaeUUID.getName(); + policyList = searchElkDatabase(config, "uuid",value); + break; + case msLocation : + MicroServiceLocation mslocation = (MicroServiceLocation)mapper.readValue(root.get("data").toString(), MicroServiceLocation.class); + value = mslocation.getName(); + policyList = searchElkDatabase(config, "location",value); + break; + case msModels : + MicroServiceModels msModels = (MicroServiceModels)mapper.readValue(root.get("data").toString(), MicroServiceModels.class); + value = msModels.getModelName(); + policyList = searchElkDatabase(config, "serviceType",value); + break; + case psGroupPolicy : + GroupPolicyScopeList groupPoilicy = (GroupPolicyScopeList)mapper.readValue(root.get("data").toString(), GroupPolicyScopeList.class); + value = groupPoilicy.getGroupName(); + policyList = searchElkDatabase(config, "pholder",value); + break; + case safeRisk : + RiskType riskType= (RiskType)mapper.readValue(root.get("data").toString(), RiskType.class); + value = riskType.getRiskName(); + policyList = searchElkDatabase(config, "riskType",value); + break; + case safePolicyWarning : + SafePolicyWarning safePolicy = (SafePolicyWarning)mapper.readValue(root.get("data").toString(), SafePolicyWarning.class); + value = safePolicy.getName(); + policyList = searchElkDatabase(config, "pholder",value); + break; + default: + } + + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("success", "success"); + JSONObject k = new JSONObject("{policyresult: " + policyList + "}"); + response.getWriter().write(k.toString()); + }catch(Exception e){ + response.setCharacterEncoding("UTF-8"); + request.setCharacterEncoding("UTF-8"); + PrintWriter out = response.getWriter(); + out.write(e.getMessage()); + } + return null; + } + + //Search the Elk database + public List<String> searchElkDatabase(PolicyIndexType type, String key, String value){ + PolicyElasticSearchController controller = new PolicyElasticSearchController(); + Map<String, String> searchKeyValue = new HashMap<>(); + if(!"pholder".equals(key)){ + searchKeyValue.put(key, value); + } + + List<String> policyList = new ArrayList<>(); + JestResult policyResultList = controller.search(type, value, searchKeyValue); + if(policyResultList.isSucceeded()){ + JsonArray resultObject = policyResultList.getJsonObject().get("hits").getAsJsonObject().get("hits").getAsJsonArray(); + for(int i =0; i < resultObject.size(); i++){ + String policyName = resultObject.get(i).getAsJsonObject().get("_id").toString(); + policyList.add(policyName); + } + }else{ + LOGGER.error("Exception Occured While Searching for Data in Elastic Search Server, Check the Logs"); + } + return policyList; + } + + public JestResult search(PolicyIndexType type, String text, Map<String, String> searchKeyValue) { + return ElkConnector.singleton.search(type, text, searchKeyValue); + } + +} + +class SearchData{ + private String query; + private String policyType; + private String descriptiveScope; + private String closedLooppolicyType; + private String onapName; + private String d2Service; + private String vnfType; + private String policyStatus; + private String vproAction; + private String serviceType; + private String bindTextSearch; + public String getQuery() { + return query; + } + public void setQuery(String query) { + this.query = query; + } + public String getPolicyType() { + return policyType; + } + public void setPolicyType(String policyType) { + this.policyType = policyType; + } + public String getDescriptiveScope() { + return descriptiveScope; + } + public void setDescriptiveScope(String descriptiveScope) { + this.descriptiveScope = descriptiveScope; + } + public String getClosedLooppolicyType() { + return closedLooppolicyType; + } + public void setClosedLooppolicyType(String closedLooppolicyType) { + this.closedLooppolicyType = closedLooppolicyType; + } + public String getOnapName() { + return onapName; + } + public void setOnapName(String onapName) { + this.onapName = onapName; + } + public String getD2Service() { + return d2Service; + } + public void setD2Service(String d2Service) { + this.d2Service = d2Service; + } + public String getVnfType() { + return vnfType; + } + public void setVnfType(String vnfType) { + this.vnfType = vnfType; + } + public String getPolicyStatus() { + return policyStatus; + } + public void setPolicyStatus(String policyStatus) { + this.policyStatus = policyStatus; + } + public String getVproAction() { + return vproAction; + } + public void setVproAction(String vproAction) { + this.vproAction = vproAction; + } + public String getServiceType() { + return serviceType; + } + public void setServiceType(String serviceType) { + this.serviceType = serviceType; + } + public String getBindTextSearch() { + return bindTextSearch; + } + public void setBindTextSearch(String bindTextSearch) { + this.bindTextSearch = bindTextSearch; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyLocator.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyLocator.java new file mode 100644 index 000000000..58c89f781 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/elk/client/PolicyLocator.java @@ -0,0 +1,51 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.elk.client; + +public class PolicyLocator { + public final String policyType; + public final String policyName; + public final String owner; + public final String scope; + public final String policyId; + public final String version; + + public PolicyLocator(String policyType, String policyName, + String owner, String scope, String policyId, + String version) { + this.policyType = policyType; + this.policyName= policyName; + this.owner = owner; + this.scope = scope; + this.policyId = policyId; + this.version = version; + } + + public String toString() { + return "[" + + this.owner + "|" + + this.scope + "|" + + this.policyType + "|" + + this.policyName + "|" + + this.policyId + "|" + + "v" + this.version + "|" + "]"; + + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/APIRequestHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/APIRequestHandler.java new file mode 100644 index 000000000..36d7c29ef --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/APIRequestHandler.java @@ -0,0 +1,96 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import java.io.IOException; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.ONAPLoggingContext; +import org.onap.policy.pap.xacml.rest.service.ImportService; +import org.onap.policy.pap.xacml.rest.service.MetricService; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; + +public class APIRequestHandler { + + private OnapPDPGroup newGroup; + + public void doGet(HttpServletRequest request, HttpServletResponse response, String apiflag) throws IOException{ + // Request from the API to get Dictionary Items + if ("api".equalsIgnoreCase(apiflag)) { + DictionaryHandler dictionaryHandler = DictionaryHandler.getInstance(); + dictionaryHandler.doDictionaryAPIGet(request, response); + return; + } + // Request from the API to get the ActiveVersion from the PolicyVersion table + if ("version".equalsIgnoreCase(apiflag)){ + PushPolicyHandler pushHandler = new PushPolicyHandler(); + pushHandler.getActiveVersion(request, response); + return; + } + // Request from the API to get the URI from the gitpath + if ("uri".equalsIgnoreCase(apiflag)){ + PushPolicyHandler pushHandler = new PushPolicyHandler(); + pushHandler.getSelectedURI(request, response); + return; + } + if ("getMetrics".equalsIgnoreCase(apiflag)){ + MetricService.doGetPolicyMetrics(request, response); + return; + } + } + + public void doPut(HttpServletRequest request, HttpServletResponse response, String service) throws IOException { + if ("MICROSERVICE".equalsIgnoreCase(service) || "BRMSPARAM".equalsIgnoreCase(service)){ + ImportService importService = new ImportService(); + importService.doImportMicroServicePut(request, response); + return; + } + if ("dictionaryItem".equalsIgnoreCase(service)) { + DictionaryHandler dictionaryHandler = DictionaryHandler.getInstance(); + dictionaryHandler.doDictionaryAPIPut(request, response); + return; + } else { + SavePolicyHandler savePolicy = SavePolicyHandler.getInstance(); + savePolicy.doPolicyAPIPut(request, response); + } + } + + public void doDelete(HttpServletRequest request, HttpServletResponse response, ONAPLoggingContext loggingContext, String apiflag) throws Exception { + DeleteHandler deleteHandler = DeleteHandler.getInstance(); + if ("deletePapApi".equalsIgnoreCase(apiflag)) { + deleteHandler.doAPIDeleteFromPAP(request, response, loggingContext); + return; + } else if ("deletePdpApi".equalsIgnoreCase(apiflag)) { + deleteHandler.doAPIDeleteFromPDP(request, response, loggingContext); + setNewGroup(deleteHandler.getDeletedGroup()); + return; + } + } + + private void setNewGroup(OnapPDPGroup newGroup) { + this.newGroup = newGroup; + } + + public OnapPDPGroup getNewGroup() { + return newGroup; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java new file mode 100644 index 000000000..17fd2c12b --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DeleteHandler.java @@ -0,0 +1,477 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import java.io.File; +import java.io.IOException; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.List; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.ONAPLoggingContext; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction; +import org.onap.policy.pap.xacml.rest.elk.client.PolicyElasticSearchController; +import org.onap.policy.pap.xacml.rest.model.RemoveGroupPolicy; +import org.onap.policy.pap.xacml.rest.util.JPAUtils; +import org.onap.policy.rest.XACMLRestProperties; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.jpa.PolicyEntity; +import org.onap.policy.rest.jpa.PolicyVersion; +import org.onap.policy.utils.PolicyUtils; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; +import org.onap.policy.xacml.std.pap.StdPAPPolicy; +import org.onap.policy.xacml.std.pap.StdPDPGroup; + +import com.att.research.xacml.api.pap.PAPException; +import com.att.research.xacml.api.pap.PDPPolicy; +import com.att.research.xacml.util.XACMLProperties; + +public class DeleteHandler { + + private OnapPDPGroup newgroup; + + private static String papDbDriver = null; + private static String papDbUrl = null; + private static String papDbUser = null; + private static String papDbPassword = null; + + public void doAPIDeleteFromPAP(HttpServletRequest request, HttpServletResponse response, ONAPLoggingContext loggingContext) throws Exception { + // get the request content into a String + String json = null; + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + PolicyLogger.info("JSON request from API: " + json); + // convert Object sent as JSON into local object + StdPAPPolicy policy = PolicyUtils.jsonStringToObject(json, StdPAPPolicy.class); + String policyName = policy.getPolicyName(); + Boolean policyVersionDeleted = false; + String removeXMLExtension; + int currentVersion; + String removeVersionExtension; + String splitPolicyName = null; + String[] split = null; + String status = "error"; + PolicyEntity policyEntity = null; + JPAUtils jpaUtils = null; + + papDbDriver = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_DRIVER); + papDbUrl = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_URL); + papDbUser = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_USER); + papDbPassword = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_DB_PASSWORD); + Connection con = null; + + try { + jpaUtils = JPAUtils.getJPAUtilsInstance(XACMLPapServlet.getEmf()); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " Could not create JPAUtils instance on the PAP"); + response.addHeader("error", "jpautils"); + response.addHeader("operation", "delete"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + return; + } + if (jpaUtils.dbLockdownIgnoreErrors()) { + PolicyLogger.warn("Policies are locked down"); + response.addHeader("operation", "delete"); + response.addHeader("lockdown", "true"); + response.setStatus(HttpServletResponse.SC_ACCEPTED); + return; + } + EntityManager em = (EntityManager) XACMLPapServlet.getEmf().createEntityManager(); + Query policyEntityQuery = null; + try{ + if(policyName.endsWith(".xml")){ + removeXMLExtension = policyName.replace(".xml", ""); + currentVersion = Integer.parseInt(removeXMLExtension.substring(removeXMLExtension.lastIndexOf(".")+1)); + removeVersionExtension = removeXMLExtension.substring(0, removeXMLExtension.lastIndexOf(".")); + boolean queryCheck = true; + if(policy.getDeleteCondition().equalsIgnoreCase("All Versions")){ + if(policyName.contains("Config_")){ + splitPolicyName = removeVersionExtension.replace(".Config_", ":Config_"); + }else if(policyName.contains("Action_")){ + splitPolicyName = removeVersionExtension.replace(".Action_", ":Action_"); + }else if(policyName.contains("Decision_")){ + splitPolicyName = removeVersionExtension.replace(".Decision_", ":Decision_"); + } + if(splitPolicyName != null){ + split = splitPolicyName.split(":"); + }else{ + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN + "Failed to delete the policy. Please, provide the valid policyname."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + } + policyEntityQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName LIKE :pName and p.scope=:pScope"); + }else if(policy.getDeleteCondition().equalsIgnoreCase("Current Version")) { + if(policyName.contains("Config_")){ + splitPolicyName = policyName.replace(".Config_", ":Config_"); + }else if(policyName.contains("Action_")){ + splitPolicyName = policyName.replace(".Action_", ":Action_"); + }else if(policyName.contains("Decision_")){ + splitPolicyName = policyName.replace(".Decision_", ":Decision_"); + } + split = splitPolicyName.split(":"); + queryCheck = false; + policyEntityQuery = em.createQuery("SELECT p FROM PolicyEntity p WHERE p.policyName=:pName and p.scope=:pScope"); + } + + if(queryCheck){ + policyEntityQuery.setParameter("pName", "%"+split[1]+"%"); + }else{ + policyEntityQuery.setParameter("pName", split[1]); + } + + policyEntityQuery.setParameter("pScope", split[0]); + List<?> peResult = policyEntityQuery.getResultList(); + if(!peResult.isEmpty()){ + Query getPolicyVersion = em.createQuery("Select p from PolicyVersion p where p.policyName=:pname"); + getPolicyVersion.setParameter("pname", removeVersionExtension.replace(".", File.separator)); + List<?> pvResult = getPolicyVersion.getResultList(); + PolicyVersion pVersion = (PolicyVersion) pvResult.get(0); + int newVersion = 0; + em.getTransaction().begin(); + Class.forName(papDbDriver); + con = DriverManager.getConnection(papDbUrl,papDbUser,papDbPassword); + + if(policy.getDeleteCondition().equalsIgnoreCase("All Versions")){ + boolean groupCheck = checkPolicyGroupEntity(em, con, peResult); + if(!groupCheck){ + for(Object peData : peResult){ + policyEntity = (PolicyEntity) peData; + status = deletePolicyEntityData(em, policyEntity); + } + }else{ + status = "PolicyInPDP"; + } + if(status.equals("error")){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Exception Occured while deleting the Entity from Database."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + }else if(status.equals("PolicyInPDP")){ + PolicyLogger.error(MessageCodes.GENERAL_WARNING + "Policy can't be deleted, it is active in PDP Groups."); + response.addHeader("error", "PolicyInPDP"); + response.setStatus(HttpServletResponse.SC_CONFLICT); + return; + }else{ + try{ + policyVersionDeleted = true; + em.remove(pVersion); + }catch(Exception e){ + policyVersionDeleted = false; + } + } + }else if(policy.getDeleteCondition().equalsIgnoreCase("Current Version")){ + boolean groupCheck = checkPolicyGroupEntity(em, con, peResult); + if(!groupCheck){ + policyEntity = (PolicyEntity) peResult.get(0); + status = deletePolicyEntityData(em, policyEntity); + }else{ + status = "PolicyInPDP"; + } + + if(status.equals("error")){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "Exception Occured while deleting the Entity from Database."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + }else if(status.equals("PolicyInPDP")){ + PolicyLogger.error(MessageCodes.GENERAL_WARNING + "Policy can't be deleted, it is active in PDP Groups."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_CONFLICT); + return; + }else{ + if(currentVersion > 1){ + if(!peResult.isEmpty()){ + for(Object object : peResult){ + policyEntity = (PolicyEntity) object; + String policyEntityName = policyEntity.getPolicyName().replace(".xml", ""); + int policyEntityVersion = Integer.parseInt(policyEntityName.substring(policyEntityName.lastIndexOf(".")+1)); + if(policyEntityVersion > newVersion){ + newVersion = policyEntityVersion-1; + } + } + } + pVersion.setActiveVersion(newVersion); + pVersion.setHigherVersion(newVersion); + try{ + policyVersionDeleted = true; + em.persist(pVersion); + }catch(Exception e){ + policyVersionDeleted = false; + } + }else{ + try{ + policyVersionDeleted = true; + em.remove(pVersion); + }catch(Exception e){ + policyVersionDeleted = false; + } + } + } + } + }else{ + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN + "Failed to delete the policy for an unknown reason. Check the file system and other logs for further information."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + } + } + em.getTransaction().commit(); + }catch(Exception e){ + em.getTransaction().rollback(); + PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, "XACMLPapServlet", " ERROR"); + response.addHeader("error", "deleteDB"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + return; + } finally { + em.close(); + if(con != null){ + con.close(); + } + } + + if (policyVersionDeleted) { + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "delete"); + return; + } else { + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN + "Failed to delete the policy for an unknown reason. Check the file system and other logs for further information."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + } + } + + public String deletePolicyEntityData(EntityManager em, PolicyEntity policyEntity) throws SQLException{ + PolicyElasticSearchController controller = new PolicyElasticSearchController(); + PolicyRestAdapter policyData = new PolicyRestAdapter(); + String policyName = policyEntity.getPolicyName(); + try{ + if(policyName.contains("Config_")){ + em.remove(policyEntity.getConfigurationData()); + }else if(policyName.contains("Action_")){ + em.remove(policyEntity.getActionBodyEntity()); + } + String searchPolicyName = policyEntity.getScope() + "." + policyEntity.getPolicyName(); + policyData.setNewFileName(searchPolicyName); + controller.deleteElk(policyData); + em.remove(policyEntity); + }catch(Exception e){ + return "error"; + } + return "success"; + } + + public boolean checkPolicyGroupEntity(EntityManager em, Connection con, List<?> peResult) throws SQLException{ + for(Object peData : peResult){ + PolicyEntity policyEntity = (PolicyEntity) peData; + Statement st = null; + ResultSet rs = null; + try{ + st = con.createStatement(); + rs = st.executeQuery("Select * from PolicyGroupEntity where policyid = '"+policyEntity.getPolicyId()+"'"); + boolean gEntityList = rs.next(); + rs.close(); + if(gEntityList){ + return true; + } + }finally{ + if(st != null){ + st.close(); + } + } + } + return false; + } + + public void doAPIDeleteFromPDP(HttpServletRequest request, HttpServletResponse response, ONAPLoggingContext loggingContext) throws IOException { + String policyName = request.getParameter("policyName"); + String groupId = request.getParameter("groupId"); + String responseString = null; + // for PUT operations the group may or may not need to exist before the operation can be done + OnapPDPGroup group = null; + try { + group = XACMLPapServlet.getPAPEngine().getGroup(groupId); + } catch (PAPException e) { + PolicyLogger.error("Exception occured While PUT operation is performing for PDP Group"+e); + } + if (group == null) { + String message = "Unknown groupId '" + groupId + "'"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " " + message); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response.addHeader("error", "UnknownGroup"); + response.sendError(HttpServletResponse.SC_NOT_FOUND, message); + return; + } else { + loggingContext.setServiceName("API:PAP.deletPolicyFromPDPGroup"); + if (policyName.contains("xml")) { + PolicyLogger.debug("The full file name including the extension was provided for policyName.. continue."); + } else { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid policyName... " + + "policyName must be the full name of the file to be deleted including version and extension"; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Invalid policyName... " + + "policyName must be the full name of the file to be deleted including version and extension"); + response.addHeader("error", message); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + return; + } + RemoveGroupPolicy removePolicy = new RemoveGroupPolicy((StdPDPGroup) group); + PDPPolicy policy = group.getPolicy(policyName); + if (policy != null) { + + if ((policy.getId().contains("Config_MS_")) || (policy.getId().contains("BRMS_Param"))) { + if (preSafetyCheck(policy)) { + PolicyLogger.debug("Precheck Successful."); + } + } + + removePolicy.prepareToRemove(policy); + OnapPDPGroup updatedGroup = removePolicy.getUpdatedObject(); + responseString = deletePolicyFromPDPGroup(updatedGroup, loggingContext); + } else { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Policy does not exist on the PDP."; + PolicyLogger.error(message); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Policy does not exist on the PDP."); + response.addHeader("error", message); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + return; + } + } + if (responseString.equals("success")) { + PolicyLogger.info("Policy successfully deleted!"); + PolicyLogger.audit("Policy successfully deleted!"); + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "delete"); + return; + } else if (responseString.equals("No Group")) { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Group update had bad input."; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Group update had bad input."); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "groupUpdate"); + response.addHeader("message", message); + return; + } else if (responseString.equals("DB Error")) { + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW + " Error while updating group in the database"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "deleteDB"); + return; + } else { + PolicyLogger.error(MessageCodes.ERROR_UNKNOWN + " Failed to delete the policy for an unknown reason. Check the file system and other logs for further information."); + response.addHeader("error", "unknown"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR ); + return; + } + } + + private String deletePolicyFromPDPGroup (OnapPDPGroup group, ONAPLoggingContext loggingContext){ + PolicyDBDaoTransaction acPutTransaction = XACMLPapServlet.getDbDaoTransaction(); + String response = null; + loggingContext.setServiceName("API:PAP.DeleteHandler"); + OnapPDPGroup existingGroup = null; + try { + existingGroup = XACMLPapServlet.getPAPEngine().getGroup(group.getId()); + } catch (PAPException e1) { + PolicyLogger.error("Exception occured While Deleting Policy From PDP Group"+e1); + } + if (group == null || ! (group instanceof StdPDPGroup) || existingGroup == null || ! (group.getId().equals(existingGroup.getId()))) { + String existingID = null; + if(existingGroup != null){ + existingID = existingGroup.getId(); + } + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Group update had bad input. id=" + existingID + " objectFromJSON="+group); + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Failed - See Error.log"); + response = "No Group"; + return response; + } + // The Path on the PAP side is not carried on the RESTful interface with the AC + // (because it is local to the PAP) + // so we need to fill that in before submitting the group for update + ((StdPDPGroup)group).setDirectory(((StdPDPGroup)existingGroup).getDirectory()); + try{ + acPutTransaction.updateGroup(group, "XACMLPapServlet.doAPIDelete"); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, "XACMLPapServlet", " Error while updating group in the database: " + +"group="+existingGroup.getId()); + response = "DB Error"; + return response; + } + try { + XACMLPapServlet.getPAPEngine().updateGroup(group); + } catch (PAPException e) { + PolicyLogger.error("Exception occured While Updating PDP Groups"+e); + response = "error in updateGroup method"; + } + PolicyLogger.debug("Group '" + group.getId() + "' updated"); + acPutTransaction.commitTransaction(); + // Group changed, which might include changing the policies + try { + newgroup = existingGroup; + } catch (Exception e) { + PolicyLogger.error("Exception occured in Group Change Method"+e); + response = "error in groupChanged method"; + } + if (response==null){ + response = "success"; + PolicyLogger.audit("Policy successfully deleted!"); + PolicyLogger.audit("Transaction Ended Successfully"); + } + loggingContext.transactionEnded(); + PolicyLogger.audit("Transaction Ended"); + return response; + } + + public OnapPDPGroup getDeletedGroup(){ + return newgroup; + } + + public boolean preSafetyCheck(PDPPolicy policy) { + return true; + } + + public static DeleteHandler getInstance() { + try { + Class<?> deleteHandler = Class.forName(XACMLProperties.getProperty("deletePolicy.impl.className", DeleteHandler.class.getName())); + DeleteHandler instance = (DeleteHandler) deleteHandler.newInstance(); + return instance; + } catch (Exception e) { + PolicyLogger.error(e.getMessage()); + } + return null; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandler.java new file mode 100644 index 000000000..4fe126fd9 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandler.java @@ -0,0 +1,63 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.eelf.PolicyLogger; + +import com.att.research.xacml.util.XACMLProperties; + +public interface DictionaryHandler { + String DICTIONARY_DEFAULT_CLASS = DictionaryHandlerImpl.class.getName(); + + /* + * Get Instance + */ + public static DictionaryHandler getInstance(){ + try { + Class<?> dictionaryHandler = Class.forName(XACMLProperties.getProperty("dictionary.impl.className", DICTIONARY_DEFAULT_CLASS)); + DictionaryHandler instance = (DictionaryHandler) dictionaryHandler.newInstance(); + return instance; + } catch (Exception e) { + PolicyLogger.error(e.getMessage()); + } + return null; + } + + /* + * Get Equivalent for Dictionary Services. + */ + public void doDictionaryAPIGet(HttpServletRequest request, HttpServletResponse response); + /* + * Put Equivalent for Dictionary Services. + */ + public void doDictionaryAPIPut(HttpServletRequest request, HttpServletResponse response); + + /** + * Can be used to extend the services. + * + * getflag=true indicates Get Request. + * getflag=false indicates Put Request. + * @return + */ + public String extendedOptions(String dictionaryType, HttpServletRequest request, HttpServletResponse response, boolean getflag); +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandlerImpl.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandlerImpl.java new file mode 100644 index 000000000..e0304d079 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/DictionaryHandlerImpl.java @@ -0,0 +1,323 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.service.DictionaryService; +import org.onap.policy.xacml.api.XACMLErrorConstants; + +public class DictionaryHandlerImpl implements DictionaryHandler{ + /* + * Get Equivalent for Dictionary Services. + */ + public void doDictionaryAPIGet(HttpServletRequest request, HttpServletResponse response) { + String dictionaryType = request.getParameter("dictionaryType"); + try { + DictionaryService dictionary = new DictionaryService(); + switch (dictionaryType) { + case "OnapName": + dictionary.getOnapDictionary(request, response); + break; + case "Attribute": + dictionary.getAttributeDictionary(request, response); + break; + case "Action": + dictionary.getActionPolicyDictionary(request, response); + break; + case "BRMSParamTemplate": + dictionary.getBRMSParamDictionary(request, response); + break; + case "VSCLAction": + dictionary.getVSCLAction(request, response); + break; + case "VNFType": + dictionary.getVnfType(request, response); + break; + case "PEPOptions": + dictionary.getPEPOptions(request, response); + break; + case "Varbind": + dictionary.getVarbind(request, response); + break; + case "Service": + dictionary.getServiceType(request, response); + break; + case "Site": + dictionary.getSiteType(request, response); + break; + case "Settings": + dictionary.getSettingsDictionary(request, response); + break; + case "DescriptiveScope": + dictionary.getDescriptiveDictionary(request, response); + break; + case "Enforcer": + dictionary.getEnforcerDictionary(request, response); + break; + case "ActionList": + dictionary.getActionListDictionary(request, response); + break; + case "ProtocolList": + dictionary.getProtocolListDictionary(request, response); + break; + case "Zone": + dictionary.getZoneDictionary(request, response); + break; + case "SecurityZone": + dictionary.getSecurityZoneDictionary(request, response); + break; + case "PrefixList": + dictionary.getPrefixListDictionary(request, response); + break; + case "AddressGroup": + dictionary.getAddressGroupDictionary(request, response); + break; + case "ServiceGroup": + dictionary.getServiceGroupDictionary(request, response); + break; + case "ServiceList": + dictionary.getServiceListDictionary(request, response); + break; + case "TermList": + case "RuleList": + case "FirewallRuleList": + case "Term": + dictionary.getTermListDictionary(request, response); + break; + case "MicroServiceLocation": + dictionary.getMicroServiceLocationDictionary(request, response); + break; + case "MicroServiceConfigName": + dictionary.getMicroServiceConfigNameDictionary(request, response); + break; + case "DCAEUUID": + dictionary.getDCAEUUIDDictionary(request, response); + break; + case "MicroServiceModels": + dictionary.getMicroServiceModelsDictionary(request, response); + break; + case "PolicyScopeService": + dictionary.getPSServiceDictionary(request, response); + break; + case "PolicyScopeResource": + dictionary.getPSResourceDictionary(request, response); + break; + case "PolicyScopeType": + dictionary.getPSTypeDictionary(request, response); + break; + case "PolicyScopeClosedLoop": + dictionary.getPSClosedLoopDictionary(request, response); + break; + case "GroupPolicyScopeList": + dictionary.getPSGroupScopeDictionary(request, response); + break; + case "RiskType": + dictionary.getRiskTypeDictionary(request, response); + break; + case "SafePolicyWarning": + dictionary.getSafePolicyWarningDictionary(request, response); + break; + case "MicroServiceDictionary": + dictionary.getMicroServiceDictionary(request, response); + break; + default: + extendedOptions(dictionaryType, request, response, true); + return; + } + } catch (Exception e) { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Error Querying the Database: " + e.getMessage(); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "DictionaryHandler", " Error Querying the Database."); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "dictionaryDBQuery"); + response.addHeader("error", message); + return; + } + } + + /** + * Can be used to extend the services. + * + * getflag=true indicates Get Request. + * getflag=false indicates Put Request. + * @return + */ + public String extendedOptions(String dictionaryType, HttpServletRequest request, HttpServletResponse response, boolean getflag) { + // Default code + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Invalid Dictionary in Request."; + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, "DictionaryHandler", " Invalid Dictionary in Request."); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.setHeader("error", "dictionary"); + response.addHeader("error", message); + return null; + } + + public void doDictionaryAPIPut(HttpServletRequest request, HttpServletResponse response) { + String result = null; + String dictionaryType = request.getParameter("dictionaryType"); + String operation = request.getParameter("operation"); + try { + DictionaryService dictionary = new DictionaryService(); + switch (dictionaryType) { + case "OnapName": + result = dictionary.saveOnapDictionary(request, response); + break; + case "Attribute": + result = dictionary.saveAttributeDictionary(request, response); + break; + case "Action": + result = dictionary.saveActionPolicyDictionary(request, response); + break; + case "BRMSParamTemplate": + result = dictionary.saveBRMSParamDictionary(request, response); + break; + case "VSCLAction": + result = dictionary.saveVSCLAction(request, response); + break; + case "VNFType": + result = dictionary.saveVnfType(request, response); + break; + case "PEPOptions": + result = dictionary.savePEPOptions(request, response); + break; + case "Varbind": + result = dictionary.saveVarbind(request, response); + break; + case "Service": + result = dictionary.saveServiceType(request, response); + break; + case "Site": + result = dictionary.saveSiteType(request, response); + break; + case "Settings": + result = dictionary.saveSettingsDictionary(request, response); + break; + case "DescriptiveScope": + result = dictionary.saveDescriptiveDictionary(request, response); + break; + case "Enforcer": + result = dictionary.saveEnforcerDictionary(request, response); + break; + case "ActionList": + result = dictionary.saveActionListDictionary(request, response); + break; + case "ProtocolList": + result = dictionary.saveProtocolListDictionary(request, response); + break; + case "Zone": + result = dictionary.saveZoneDictionary(request, response); + break; + case "SecurityZone": + result = dictionary.saveSecurityZoneDictionary(request, response); + break; + case "PrefixList": + result = dictionary.savePrefixListDictionary(request, response); + break; + case "AddressGroup": + result = dictionary.saveAddressGroupDictionary(request, response); + break; + case "ServiceGroup": + result = dictionary.saveServiceGroupDictionary(request, response); + break; + case "ServiceList": + result = dictionary.saveServiceListDictionary(request, response); + break; + case "TermList": + case "RuleList": + case "FirewallRuleList": + case "Term": + result = dictionary.saveTermListDictionary(request, response); + break; + case "MicroServiceLocation": + result = dictionary.saveMicroServiceLocationDictionary(request, response); + break; + case "MicroServiceConfigName": + result = dictionary.saveMicroServiceConfigNameDictionary(request, response); + break; + case "DCAEUUID": + result = dictionary.saveDCAEUUIDDictionary(request, response); + break; + case "MicroServiceModels": + result = dictionary.saveMicroServiceModelsDictionary(request, response); + break; + case "PolicyScopeService": + result = dictionary.savePSServiceDictionary(request, response); + break; + case "PolicyScopeResource": + result = dictionary.savePSResourceDictionary(request, response); + break; + case "PolicyScopeType": + result = dictionary.savePSTypeDictionary(request, response); + break; + case "PolicyScopeClosedLoop": + result = dictionary.savePSClosedLoopDictionary(request, response); + break; + case "GroupPolicyScopeList": + result = dictionary.savePSGroupScopeDictionary(request, response); + break; + case "RiskType": + result = dictionary.saveRiskTypeDictionary(request, response); + break; + case "SafePolicyWarning": + result = dictionary.saveSafePolicyWarningDictionary(request, response); + break; + case "MicroServiceDictionary": + result = dictionary.saveMicroServiceDictionary(request, response); + break; + default: + result = extendedOptions(dictionaryType, request, response, false); + if(result==null){ + return; + }else{ + break; + } + } + } catch (Exception e) { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Error Updating the Database: " + e.getMessage(); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " Error Updating the Database."); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + return; + } + if (result.equalsIgnoreCase("Success")) { + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + if (operation.equalsIgnoreCase("update")) { + response.addHeader("operation", "updateDictionary"); + } else { + response.addHeader("operation", "createDictionary"); + } + } else if (result.equalsIgnoreCase("Duplicate")) { + response.setStatus(HttpServletResponse.SC_CONFLICT); + response.addHeader("error", "dictionaryItemExists"); + } else if (result.equalsIgnoreCase("DuplicateGroup")) { + response.setStatus(HttpServletResponse.SC_CONFLICT); + response.addHeader("error", "duplicateGroup"); + } else { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Error Updating the Database."; + PolicyLogger.error(message); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + } + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java new file mode 100644 index 000000000..9ef0e6f1e --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/PushPolicyHandler.java @@ -0,0 +1,123 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import java.io.File; +import java.net.URI; +import java.util.List; + +import javax.persistence.EntityManager; +import javax.persistence.Query; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.rest.jpa.PolicyVersion; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; + +import com.att.research.xacml.util.XACMLProperties; + +public class PushPolicyHandler { + + /* + * Get Active Version. + */ + public void getActiveVersion(HttpServletRequest request, HttpServletResponse response) { + EntityManager em = null; + if(XACMLPapServlet.getEmf()!=null){ + em = (EntityManager) XACMLPapServlet.getEmf().createEntityManager(); + } + if (em==null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Error creating entity manager with persistence unit: " + XACMLPapServlet.getPersistenceUnit()); + return; + } + String policyScope = request.getParameter("policyScope"); + String filePrefix = request.getParameter("filePrefix"); + String policyName = request.getParameter("policyName"); + + String pvName = policyScope + File.separator + filePrefix + policyName; + int activeVersion = 0; + + //Get the Active Version to use in the ID + em.getTransaction().begin(); + Query query = em.createQuery("Select p from PolicyVersion p where p.policyName=:pname"); + query.setParameter("pname", pvName); + + @SuppressWarnings("rawtypes") + List result = query.getResultList(); + PolicyVersion versionEntity = null; + if (!result.isEmpty()) { + versionEntity = (PolicyVersion) result.get(0); + em.persist(versionEntity); + activeVersion = versionEntity.getActiveVersion(); + em.getTransaction().commit(); + } else { + PolicyLogger.debug("No PolicyVersion using policyName found"); + } + + //clean up connection + em.close(); + if (String.valueOf(activeVersion)!=null || !String.valueOf(activeVersion).equalsIgnoreCase("")) { + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("version", String.valueOf(activeVersion)); + } else { + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + } + } + + /* + * Get Selected URI path. + */ + public void getSelectedURI(HttpServletRequest request, HttpServletResponse response) { + String gitPath = request.getParameter("gitPath"); + File file = new File(gitPath); + PolicyLogger.debug("The fileItem is : " + file.toString()); + URI selectedURI = file.toURI(); + String uri = selectedURI.toString(); + if (!uri.equalsIgnoreCase("")) { + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("selectedURI", uri); + } else { + response.setStatus(HttpServletResponse.SC_NOT_FOUND); + } + } + + public boolean preSafetyCheck(StdPDPPolicy policy, String configHome){ + return true; + } + + public boolean preSafetyCheck(OnapPDPGroup policy, String configHome){ + return true; + } + + public static PushPolicyHandler getInstance() { + try { + Class<?> pushPolicyHandler = Class.forName(XACMLProperties.getProperty("pushPolicy.impl.className", PushPolicyHandler.class.getName())); + PushPolicyHandler instance = (PushPolicyHandler) pushPolicyHandler.newInstance(); + return instance; + } catch (Exception e) { + PolicyLogger.error(e.getMessage()); + } + return null; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java new file mode 100644 index 000000000..d88aee0cb --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/handler/SavePolicyHandler.java @@ -0,0 +1,157 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.handler; + +import java.io.IOException; +import java.util.HashMap; + +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import javax.xml.parsers.ParserConfigurationException; + +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.policycontroller.PolicyCreation; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.utils.PolicyUtils; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.std.pap.StdPAPPolicy; +import org.xml.sax.SAXException; + +import com.att.research.xacml.util.XACMLProperties; + +public class SavePolicyHandler { + private HashMap<String, String> ErrorHeaders = null; + + public void doPolicyAPIPut(HttpServletRequest request, HttpServletResponse response) throws IOException { + String operation = request.getParameter("operation"); + String policyType = request.getParameter("policyType"); + String apiflag = request.getParameter("apiflag"); + PolicyCreation creation = new PolicyCreation(); + if ( policyType != null ) { + PolicyRestAdapter policyAdapter = new PolicyRestAdapter(); + if("update".equalsIgnoreCase(operation)){ + policyAdapter.setEditPolicy(true); + }else{ + policyAdapter.setEditPolicy(false); + } + + // get the request content into a String + String json = null; + // read the inputStream into a buffer (trick found online scans entire input looking for end-of-file) + java.util.Scanner scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + json = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + PolicyLogger.info("JSON request from API: " + json); + // convert Object sent as JSON into local object + StdPAPPolicy policy = PolicyUtils.jsonStringToObject(json, StdPAPPolicy.class); + //Set policyAdapter values including parentPath (Common to all policy types) + try { + policyAdapter = setDataToPolicyAdapter(policy, policyType, apiflag); + + if(!extendedPolicyOptions(policyAdapter, response)){ + creation.savePolicy(policyAdapter, response); + } + if ("update".equalsIgnoreCase(operation)) { + response.addHeader("operation", "update"); + } else { + response.addHeader("operation", "create"); + } + } catch (Exception e1) { + PolicyLogger.error(XACMLErrorConstants.ERROR_UNKNOWN + + "Could not set data to policy adapter "+ e1.getMessage()); + } + } + } + + private PolicyRestAdapter setDataToPolicyAdapter(StdPAPPolicy policy, String policyType, String apiflag) throws ParserConfigurationException, ServletException, SAXException, IOException{ + PolicyRestAdapter policyAdapter = new PolicyRestAdapter(); + policyAdapter.setApiflag(apiflag); + /* + * set policy adapter values for Building JSON object containing policy data + */ + //Common among policy types + policyAdapter.setPolicyName(policy.getPolicyName()); + policyAdapter.setPolicyDescription(policy.getPolicyDescription()); + policyAdapter.setOnapName(policy.getOnapName()); //Config Base and Decision Policies + policyAdapter.setRuleCombiningAlgId("urn:oasis:names:tc:xacml:3.0:rule-combining-algorithm:permit-overrides"); + + policyAdapter.setPolicyType(policyType); + policyAdapter.setDynamicFieldConfigAttributes(policy.getDynamicFieldConfigAttributes()); + policyAdapter.setEditPolicy(policy.isEditPolicy()); + policyAdapter.setEntityManagerFactory(XACMLPapServlet.getEmf()); + //Config Specific + policyAdapter.setConfigName(policy.getConfigName()); //Base and Firewall + policyAdapter.setConfigBodyData(policy.getConfigBodyData()); //Base + policyAdapter.setConfigType((policy.getConfigType()!=null) ? policy.getConfigType().toUpperCase(): null); //Base + policyAdapter.setJsonBody(policy.getJsonBody()); //Firewall, ClosedLoop + policyAdapter.setConfigPolicyType(policy.getConfigPolicyType()); + policyAdapter.setDraft(policy.isDraft()); //ClosedLoop_Fault + policyAdapter.setServiceType(policy.getServiceType()); //ClosedLoop_PM + policyAdapter.setUuid(policy.getUuid()); //Micro Service + policyAdapter.setLocation(policy.getMsLocation()); //Micro Service + policyAdapter.setPriority(policy.getPriority()); //Micro Service + policyAdapter.setPolicyScope(policy.getDomainDir()); + policyAdapter.setRiskType(policy.getRiskType()); //Safe Policy Attributes + policyAdapter.setRiskLevel(policy.getRiskLevel());//Safe Policy Attributes + policyAdapter.setGuard(policy.getGuard());//Safe Policy Attributes + policyAdapter.setTtlDate(policy.getTTLDate());//Safe Policy Attributes + policyAdapter.setBrmsParamBody(policy.getDrlRuleAndUIParams()); + policyAdapter.setBrmsDependency(policy.getBrmsDependency()); // BRMS Policies. + policyAdapter.setBrmsController(policy.getBrmsController()); // BRMS Policies. + //Action Policy Specific + policyAdapter.setActionAttribute(policy.getActionAttribute()); //comboDictValue + policyAdapter.setActionPerformer(policy.getActionPerformer()); + policyAdapter.setDynamicRuleAlgorithmLabels(policy.getDynamicRuleAlgorithmLabels()); + policyAdapter.setDynamicRuleAlgorithmCombo(policy.getDynamicRuleAlgorithmCombo()); + policyAdapter.setDynamicRuleAlgorithmField1(policy.getDynamicRuleAlgorithmField1()); + policyAdapter.setDynamicRuleAlgorithmField2(policy.getDynamicRuleAlgorithmField2()); + //Decision Policy Specific + policyAdapter.setDynamicSettingsMap(policy.getDynamicSettingsMap()); + policyAdapter.setRuleProvider(policy.getProviderComboBox()); + policyAdapter.setDomainDir(policyAdapter.getPolicyScope()); + policyAdapter.setDomain(policyAdapter.getPolicyScope()); + return policyAdapter; + } + + public boolean extendedPolicyOptions(PolicyRestAdapter policyAdapter, HttpServletResponse response){ + return false; + } + + public void addErrorHeader(String key, String value){ + if(ErrorHeaders==null){ + ErrorHeaders= new HashMap<>(); + } + ErrorHeaders.put(key, value); + } + + public static SavePolicyHandler getInstance() { + try { + Class<?> savePolicyHandler = Class.forName(XACMLProperties.getProperty("savePolicy.impl.className", SavePolicyHandler.class.getName())); + SavePolicyHandler instance = (SavePolicyHandler) savePolicyHandler.newInstance(); + return instance; + } catch (Exception e) { + PolicyLogger.error(e.getMessage()); + } + return null; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/PDPPolicyContainer.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/PDPPolicyContainer.java new file mode 100644 index 000000000..cbcb7e04b --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/PDPPolicyContainer.java @@ -0,0 +1,348 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.model; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Set; + +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.util.PolicyContainer; +import org.onap.policy.pap.xacml.rest.util.PolicyItemSetChangeNotifier; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.std.pap.StdPDPPolicy; + +import com.att.research.xacml.api.pap.PDP; +import com.att.research.xacml.api.pap.PDPGroup; +import com.att.research.xacml.api.pap.PDPPolicy; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.ObjectMapper; + +public class PDPPolicyContainer extends PolicyItemSetChangeNotifier implements PolicyContainer.Indexed { + private static final long serialVersionUID = 1L; + private static Logger logger = FlexLogger.getLogger(PDPPolicyContainer.class); + + /** + * String identifier of a file's "Id" property. + */ + public static String PROPERTY_ID = "Id"; + + /** + * String identifier of a file's "name" property. + */ + public static String PROPERTY_NAME = "Name"; + + /** + * String identifier of a file's "name" property. + */ + public static String PROPERTY_VERSION = "Version"; + + /** + * String identifier of a file's "Description" property. + */ + public static String PROPERTY_DESCRIPTION = "Description"; + + /** + * String identifier of a file's "IsRoot" property. + */ + public static String PROPERTY_ISROOT = "Root"; + + /** + * List of the string identifiers for the available properties. + */ + public static Collection<String> PDPPOLICY_PROPERTIES; + + private final Object data; + private List<PDPPolicy> policies; + + @SuppressWarnings("unchecked") + public PDPPolicyContainer(Object data) { + super(); + this.data = data; + if (this.data instanceof PDPGroup) { + policies = new ArrayList<PDPPolicy> (((PDPGroup) this.data).getPolicies()); + } + if (this.data instanceof PDP) { + policies = new ArrayList<PDPPolicy> (((PDP) this.data).getPolicies()); + } + if (this.data instanceof Set) { + policies = new ArrayList<PDPPolicy> ((Set<PDPPolicy>)data); + } + if (this.policies == null) { + logger.info("NULL policies"); + throw new NullPointerException("PDPPolicyContainer created with unexpected Object type '" + data.getClass().getName() + "'"); + } + this.setContainer(this); + } + + @Override + public Object nextItemId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("nextItemId: " + itemId); + } + int index = this.policies.indexOf(itemId); + if (index == -1 || ((index + 1) >= this.policies.size())) { + return null; + } + return new PDPPolicyItem(this.policies.get(index + 1)); + } + + @Override + public Object prevItemId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("prevItemId: " + itemId); + } + int index = this.policies.indexOf(itemId); + if (index <= 0) { + return null; + } + return new PDPPolicyItem(this.policies.get(index - 1)); + } + + @Override + public Object firstItemId() { + if (logger.isTraceEnabled()) { + logger.trace("firstItemId: "); + } + if (this.policies.isEmpty()) { + return null; + } + return new PDPPolicyItem(this.policies.get(0)); + } + + @Override + public Object lastItemId() { + if (logger.isTraceEnabled()) { + logger.trace("lastItemid: "); + } + if (this.policies.isEmpty()) { + return null; + } + return new PDPPolicyItem(this.policies.get(this.policies.size() - 1)); + } + + @Override + public boolean isFirstId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("isFirstId: " + itemId); + } + if (this.policies.isEmpty()) { + return false; + } + return (itemId.equals(this.policies.get(0))); + } + + @Override + public boolean isLastId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("isLastId: " + itemId); + } + if (this.policies.isEmpty()) { + return false; + } + return (itemId.equals(this.policies.get(this.policies.size() - 1))); + } + + @Override + public Object addItemAfter(Object previousItemId) + throws UnsupportedOperationException { + return null; + } + + @Override + public Collection<?> getContainerPropertyIds() { + return PDPPOLICY_PROPERTIES; + } + + @Override + public Collection<?> getItemIds() { + final Collection<Object> items = new ArrayList<>(); + items.addAll(this.policies); + return Collections.unmodifiableCollection(items); + } + + + @Override + public Class<?> getType(Object propertyId) { + if (propertyId.equals(PROPERTY_ID)) { + return String.class; + } + if (propertyId.equals(PROPERTY_NAME)) { + return String.class; + } + if (propertyId.equals(PROPERTY_VERSION)) { + return String.class; + } + if (propertyId.equals(PROPERTY_DESCRIPTION)) { + return String.class; + } + if (propertyId.equals(PROPERTY_ISROOT)) { + return Boolean.class; + } + return null; + } + + @Override + public int size() { + if (logger.isTraceEnabled()) { + logger.trace("size: " + this.policies.size()); + } + return this.policies.size(); + } + + @Override + public boolean containsId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("containsId: " + itemId); + } + return this.policies.contains(itemId); + } + + @Override + public Object addItem() throws UnsupportedOperationException { + throw new UnsupportedOperationException("Cannot add an empty policy."); + } + + @Override + public boolean removeItem(Object itemId) + throws UnsupportedOperationException { + if (logger.isTraceEnabled()) { + logger.trace("removeItem: " + itemId); + } + ObjectMapper mapper = new ObjectMapper(); + mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); + StdPDPPolicy pdpPolicy = null; + try { + pdpPolicy = mapper.readValue(itemId.toString() , StdPDPPolicy.class); + for(int i = 0; i< policies.size(); i++){ + if(policies.get(i).getId().equalsIgnoreCase(pdpPolicy.getId())){ + return this.policies.remove(this.policies.get(i)); + } + } + } catch (Exception e) { + logger.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Exception Occured While Mapping the Removing Policy from PDP Group to Std Policy"+e); + } + return this.policies.remove(itemId); + } + + @Override + public boolean addContainerProperty(Object propertyId, Class<?> type, + Object defaultValue) throws UnsupportedOperationException { + return false; + } + + @Override + public boolean removeContainerProperty(Object propertyId) + throws UnsupportedOperationException { + return false; + } + + @Override + public boolean removeAllItems() throws UnsupportedOperationException { + return false; + } + + @Override + public int indexOfId(Object itemId) { + if (logger.isTraceEnabled()) { + logger.trace("indexOfId: " + itemId); + } + return this.policies.indexOf(itemId); + } + + @Override + public Object getIdByIndex(int index) { + if (logger.isTraceEnabled()) { + logger.trace("getIdByIndex: " + index); + } + return this.policies.get(index); + } + + @Override + public List<?> getItemIds(int startIndex, int numberOfItems) { + if (logger.isTraceEnabled()) { + logger.trace("getItemIds: " + startIndex + " " + numberOfItems); + } + if (numberOfItems < 0) { + throw new IllegalArgumentException(); + } + return this.policies.subList(startIndex, startIndex + numberOfItems); + } + + @Override + public Object addItemAt(int index) throws UnsupportedOperationException { + if (logger.isTraceEnabled()) { + logger.trace("addItemAt: " + index); + } + return null; + } + + public class PDPPolicyItem { + private final PDPPolicy policy; + + public PDPPolicyItem(PDPPolicy itemId) { + this.policy = itemId; + } + + public String getId() { + if (logger.isTraceEnabled()) { + logger.trace("getId: " + this.policy); + } + return this.policy.getId(); + } + + public String getName() { + if (logger.isTraceEnabled()) { + logger.trace("getName: " + this.policy); + } + return this.policy.getName(); + } + + public String getVersion() { + if (logger.isTraceEnabled()) { + logger.trace("getVersion: " + this.policy); + } + return this.policy.getVersion(); + } + + public String getDescription() { + if (logger.isTraceEnabled()) { + logger.trace("getDescription: " + this.policy); + } + return this.policy.getDescription(); + } + + public boolean getRoot() { + if (logger.isTraceEnabled()) { + logger.trace("isRoot: " + this.policy); + } + return this.policy.isRoot(); + } + + public void setRoot(Boolean root) { + ((StdPDPPolicy)this.policy).setRoot(root); + } + + } +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/RemoveGroupPolicy.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/RemoveGroupPolicy.java new file mode 100644 index 000000000..7645535b0 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/RemoveGroupPolicy.java @@ -0,0 +1,102 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.model; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; + +import org.onap.policy.xacml.api.pap.OnapPDPGroup; +import org.onap.policy.xacml.std.pap.StdPDPGroup; + +import com.att.research.xacml.api.pap.PDPPolicy; + +public class RemoveGroupPolicy { + + + //Container from where we are fetching the policies + private static PDPPolicyContainer policyContainer; + + private final RemoveGroupPolicy self = this; + private StdPDPGroup updatedObject; + private final StdPDPGroup group; + private boolean isSaved = false; + + public RemoveGroupPolicy(StdPDPGroup group) { + + this.group = group; + + } + + public void prepareToRemove(PDPPolicy policy) { + + if (this.group == null) { + return; + } + + RemoveGroupPolicy.policyContainer = new PDPPolicyContainer(group); + + RemoveGroupPolicy.policyContainer.removeItem(policy); + + self.doSave(); + + self.isSaved = true; + + } + + @SuppressWarnings("unchecked") + protected void doSave() { + if (this.group == null) { + return; + } + + //StdPDPGroup pdpGroup = (StdPDPGroup) group; + StdPDPGroup updatedGroupObject = new StdPDPGroup( + group.getId(), + group.isDefaultGroup(), + group.getName(), + group.getDescription(), + null); + + // replace the original set of Policies with the set from the container (possibly modified by the user) + Set<PDPPolicy> changedPolicies = new HashSet<>(); + changedPolicies.addAll((Collection<PDPPolicy>) RemoveGroupPolicy.policyContainer.getItemIds()); + updatedGroupObject.setPolicies(changedPolicies); + updatedGroupObject.setOnapPdps(this.group.getOnapPdps()); + + // replace the original set of PIP Configs with the set from the container + updatedGroupObject.setPipConfigs(this.group.getPipConfigs()); + + // copy those things that the user cannot change from the original to the new object + updatedGroupObject.setStatus(this.group.getStatus()); + + this.updatedObject = updatedGroupObject; + } + + public boolean isRemoved() { + return this.isSaved; + } + + public OnapPDPGroup getUpdatedObject() { + return this.updatedObject; + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/package-info.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/package-info.java new file mode 100644 index 000000000..51d988887 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/model/package-info.java @@ -0,0 +1,20 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.model; diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java new file mode 100644 index 000000000..80657fcd6 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/PolicyCreation.java @@ -0,0 +1,550 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.policycontroller; + +import java.io.File; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.lang.StringUtils; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.pap.xacml.rest.components.ActionPolicy; +import org.onap.policy.pap.xacml.rest.components.ClosedLoopPolicy; +import org.onap.policy.pap.xacml.rest.components.ConfigPolicy; +import org.onap.policy.pap.xacml.rest.components.CreateBrmsParamPolicy; +import org.onap.policy.pap.xacml.rest.components.CreateBrmsRawPolicy; +import org.onap.policy.pap.xacml.rest.components.CreateClosedLoopPerformanceMetrics; +import org.onap.policy.pap.xacml.rest.components.DecisionPolicy; +import org.onap.policy.pap.xacml.rest.components.FirewallConfigPolicy; +import org.onap.policy.pap.xacml.rest.components.MicroServiceConfigPolicy; +import org.onap.policy.pap.xacml.rest.components.Policy; +import org.onap.policy.pap.xacml.rest.components.PolicyDBDao; +import org.onap.policy.pap.xacml.rest.components.PolicyDBDaoTransaction; +import org.onap.policy.pap.xacml.rest.elk.client.PolicyElasticSearchController; +import org.onap.policy.pap.xacml.rest.util.AbstractPolicyCreation; +import org.onap.policy.rest.adapter.PolicyRestAdapter; +import org.onap.policy.rest.dao.CommonClassDao; +import org.onap.policy.rest.jpa.ActionPolicyDict; +import org.onap.policy.rest.jpa.BRMSParamTemplate; +import org.onap.policy.rest.jpa.PolicyEditorScopes; +import org.onap.policy.rest.jpa.PolicyVersion; +import org.onap.policy.rest.jpa.UserInfo; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.http.converter.HttpMessageNotReadableException; +import org.springframework.web.bind.annotation.ExceptionHandler; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.ResponseBody; +import org.springframework.web.bind.annotation.RestController; + +import com.fasterxml.jackson.databind.ObjectMapper; + + +@RestController +@RequestMapping("/") +public class PolicyCreation extends AbstractPolicyCreation{ + + private static final Logger LOGGER = FlexLogger.getLogger(PolicyCreation.class); + + private String ruleID = ""; + private PolicyDBDao policyDBDao; + String CLName = null; + + private static CommonClassDao commonClassDao; + + public static CommonClassDao getCommonClassDao() { + return commonClassDao; + } + + public static void setCommonClassDao(CommonClassDao commonClassDao) { + PolicyCreation.commonClassDao = commonClassDao; + } + + @Autowired + public PolicyCreation(CommonClassDao commonClassDao){ + PolicyCreation.commonClassDao = commonClassDao; + } + + public PolicyCreation(){} + + @RequestMapping(value="/policycreation/save_policy", method = RequestMethod.POST) + @ResponseBody + public ResponseEntity<String> savePolicy(@RequestBody PolicyRestAdapter policyData, HttpServletResponse response) throws Exception{ + String body = null; + HttpStatus status = HttpStatus.BAD_REQUEST; + Map<String, String> successMap = new HashMap<>(); + Map<String, String> attributeMap = new HashMap<>(); + PolicyVersion policyVersionDao; + try { + + Policy newPolicy = null; + String policyConfigType = null; + String userId = policyData.getUserId(); + + if (policyData.getTtlDate()==null){ + policyData.setTtlDate("NA"); + }else{ + String dateTTL = policyData.getTtlDate(); + String newDate = convertDate(dateTTL, false); + policyData.setTtlDate(newDate); + } + + String policyType = policyData.getPolicyType(); + + String filePrefix = null; + if (policyType.equalsIgnoreCase("Config")) { + policyConfigType = policyData.getConfigPolicyType(); + if (policyConfigType.equalsIgnoreCase("Firewall Config")) { + filePrefix = "Config_FW_"; + }else if (policyConfigType.equalsIgnoreCase("ClosedLoop_Fault")) { + filePrefix = "Config_Fault_"; + }else if (policyConfigType.equalsIgnoreCase("ClosedLoop_PM")) { + filePrefix = "Config_PM_"; + }else if (policyConfigType.equalsIgnoreCase("Micro Service")) { + filePrefix = "Config_MS_"; + }else if (policyConfigType.equalsIgnoreCase("BRMS_Raw")) { + filePrefix = "Config_BRMS_Raw_"; + }else if (policyConfigType.equalsIgnoreCase("BRMS_Param")) { + filePrefix = "Config_BRMS_Param_"; + }else { + filePrefix = "Config_"; + } + } else if (policyType.equalsIgnoreCase("Action")) { + filePrefix = "Action_"; + } else if (policyType.equalsIgnoreCase("Decision")) { + filePrefix = "Decision_"; + } + + int version = 0; + int highestVersion = 0; + String createdBy = ""; + String modifiedBy = userId; + String scopeCheck = policyData.getDomainDir().replace(".", File.separator); + PolicyEditorScopes policyEditorScope = (PolicyEditorScopes) commonClassDao.getEntityItem(PolicyEditorScopes.class, "scopeName", scopeCheck); + if(policyEditorScope == null){ + UserInfo userInfo = new UserInfo(); + userInfo.setUserName("API"); + userInfo.setUserLoginId("API"); + PolicyEditorScopes editorScope = new PolicyEditorScopes(); + editorScope.setScopeName(scopeCheck); + editorScope.setUserCreatedBy(userInfo); + editorScope.setUserModifiedBy(userInfo); + commonClassDao.save(editorScope); + } + //get the highest version of policy from policy version table. + String dbCheckPolicyName = policyData.getDomainDir() + File.separator + filePrefix + policyData.getPolicyName(); + PolicyVersion policyVersion = getPolicyVersionData(dbCheckPolicyName); + if(policyVersion == null){ + highestVersion = 0; + }else{ + highestVersion = policyVersion.getHigherVersion(); + } + + if(highestVersion != 0 && policyVersion != null){ + if(policyData.isEditPolicy()){ + version = highestVersion +1; + if(userId ==null){ + modifiedBy = "API"; + }else{ + modifiedBy = userId; + } + policyData.setUserId("API"); + createdBy = policyVersion.getCreatedBy(); + policyVersionDao = policyVersion; + policyVersionDao.setActiveVersion(version); + policyVersionDao.setHigherVersion(version); + policyVersionDao.setModifiedBy(modifiedBy); + }else{ + body = "policyExists"; + status = HttpStatus.CONFLICT; + response.setStatus(HttpServletResponse.SC_CONFLICT); + response.addHeader("error", "policyExists"); + response.addHeader("policyName", policyData.getPolicyName()); + return new ResponseEntity<String>(body, status); + } + }else{ + version = 1; + if(userId == null){ + createdBy = "API"; + modifiedBy = "API"; + policyData.setUserId("API"); + }else{ + createdBy = userId; + modifiedBy = userId; + policyData.setUserId("API"); + } + policyVersionDao = new PolicyVersion(); + policyVersionDao.setPolicyName(dbCheckPolicyName); + policyVersionDao.setActiveVersion(version); + policyVersionDao.setHigherVersion(version); + policyVersionDao.setCreatedBy(createdBy); + policyVersionDao.setModifiedBy(modifiedBy); + } + + policyData.setPolicyID(newPolicyID()); + policyData.setRuleID(ruleID); + + String policyFileName = dbCheckPolicyName.replace(File.separator, ".")+ "." + version + ".xml"; + policyData.setNewFileName(policyFileName); + policyData.setPolicyDescription(policyData.getPolicyDescription()+ "@CreatedBy:" +createdBy + "@CreatedBy:" + "@ModifiedBy:" +modifiedBy + "@ModifiedBy:"); + policyData.setRuleCombiningAlgId("urn:oasis:names:tc:xacml:3.0:rule-combining-algorithm:permit-overrides"); + if(policyData.getApiflag() == null){ + //set the Rule Combining Algorithm Id to be sent to PAP-REST via JSON + if(policyData.getAttributes() != null){ + if(policyData.getAttributes().size() > 0){ + for(Object attribute : policyData.getAttributes()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) attribute).get("key").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("value").toString(); + attributeMap.put(key, value); + } + } + } + } + policyData.setDynamicFieldConfigAttributes(attributeMap); + } + + policyData.setVersion(String.valueOf(version)); + policyData.setHighestVersion(version); + + // Calling Component class per policy type + if (policyType.equalsIgnoreCase("Config")) { + if (policyConfigType.equalsIgnoreCase("Firewall Config")) { + newPolicy = new FirewallConfigPolicy(policyData); + }else if (policyConfigType.equalsIgnoreCase("BRMS_Raw")) { + policyData.setOnapName("DROOLS"); + policyData.setConfigName("BRMS_RAW_RULE"); + newPolicy = new CreateBrmsRawPolicy(policyData); + }else if (policyConfigType.equalsIgnoreCase("BRMS_Param")) { + policyData.setOnapName("DROOLS"); + policyData.setConfigName("BRMS_PARAM_RULE"); + Map<String, String> drlRuleAndUIParams = new HashMap<>(); + if(policyData.getApiflag() == null){ + // If there is any dynamic field create the matches here + String key="templateName"; + String value=(String) policyData.getRuleName(); + drlRuleAndUIParams.put(key, value); + if(policyData.getRuleData().size() > 0){ + for(Object keyValue: policyData.getRuleData().keySet()){ + drlRuleAndUIParams.put(keyValue.toString(), policyData.getRuleData().get(keyValue).toString()); + } + } + policyData.setBrmsParamBody(drlRuleAndUIParams); + }else{ + drlRuleAndUIParams=policyData.getBrmsParamBody(); + String modelName= drlRuleAndUIParams.get("templateName"); + PolicyLogger.info("Template name from API is: "+modelName); + + BRMSParamTemplate template = (BRMSParamTemplate) commonClassDao.getEntityItem(BRMSParamTemplate.class, "ruleName", modelName); + if(template == null){ + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid Template. The template name, " + + modelName + " was not found in the dictionary."; + body = message; + status = HttpStatus.BAD_REQUEST; + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + response.addHeader("modelName", modelName); + return new ResponseEntity<String>(body, status); + } + } + newPolicy = new CreateBrmsParamPolicy(policyData); + }else if (policyConfigType.equalsIgnoreCase("Base")) { + newPolicy = new ConfigPolicy(policyData); + }else if (policyConfigType.equalsIgnoreCase("ClosedLoop_Fault")) { + newPolicy = new ClosedLoopPolicy(policyData); + }else if (policyConfigType.equalsIgnoreCase("ClosedLoop_PM")) { + if(policyData.getApiflag() == null){ + policyData.setServiceType(policyData.getServiceTypePolicyName().get("serviceTypePolicyName").toString()); + ObjectMapper jsonMapper = new ObjectMapper(); + String jsonBody = jsonMapper.writeValueAsString(policyData.getJsonBodyData()); + jsonBody = jsonBody.replaceFirst("\\{", "\\{\"serviceTypePolicyName\": \"serviceTypeFieldValue\","); + jsonBody = jsonBody.replace("serviceTypeFieldValue", policyData.getServiceType()); + policyData.setJsonBody(jsonBody); + } + newPolicy = new CreateClosedLoopPerformanceMetrics(policyData); + }else if (policyConfigType.equalsIgnoreCase("Micro Service")) { + newPolicy = new MicroServiceConfigPolicy(policyData); + } + }else if(policyType.equalsIgnoreCase("Action")) { + if(policyData.getApiflag() == null){ + List<String> dynamicRuleAlgorithmLabels = new LinkedList<>(); + List<String> dynamicRuleAlgorithmCombo = new LinkedList<>(); + List<String> dynamicRuleAlgorithmField1 = new LinkedList<>(); + List<String> dynamicRuleAlgorithmField2 = new LinkedList<>(); + + + if(policyData.getRuleAlgorithmschoices().size() > 0){ + for(Object attribute : policyData.getRuleAlgorithmschoices()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String label = ((LinkedHashMap<?, ?>) attribute).get("id").toString(); + String key = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField1").toString(); + String rule = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmCombo").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField2").toString(); + dynamicRuleAlgorithmLabels.add(label); + dynamicRuleAlgorithmField1.add(key); + dynamicRuleAlgorithmCombo.add(rule); + dynamicRuleAlgorithmField2.add(value); + } + } + } + + String actionDictValue = policyData.getActionAttributeValue(); + ActionPolicyDict jsonData = ((ActionPolicyDict) commonClassDao.getEntityItem(ActionPolicyDict.class, "attributeName", actionDictValue)); + String actionBodyString = jsonData.getBody(); + String actionDictHeader = jsonData.getHeader(); + String actionDictType = jsonData.getType(); + String actionDictUrl = jsonData.getUrl(); + String actionDictMethod = jsonData.getMethod(); + policyData.setActionDictHeader(actionDictHeader); + policyData.setActionDictType(actionDictType); + policyData.setActionDictUrl(actionDictUrl); + policyData.setActionDictMethod(actionDictMethod); + policyData.setActionAttribute(actionDictValue); + policyData.setDynamicRuleAlgorithmLabels(dynamicRuleAlgorithmLabels); + policyData.setDynamicRuleAlgorithmCombo(dynamicRuleAlgorithmCombo); + policyData.setDynamicRuleAlgorithmField1(dynamicRuleAlgorithmField1); + policyData.setDynamicRuleAlgorithmField2(dynamicRuleAlgorithmField2); + if (actionBodyString != null) { + policyData.setActionBody(actionBodyString); + } + } + newPolicy = new ActionPolicy(policyData); + } else if (policyType.equalsIgnoreCase("Decision")) { + if(policyData.getApiflag() == null){ + Map<String, String> settingsMap = new HashMap<>(); + Map<String, String> treatmentMap = new HashMap<>(); + List<String> dynamicRuleAlgorithmLabels = new LinkedList<>(); + List<String> dynamicRuleAlgorithmCombo = new LinkedList<>(); + List<String> dynamicRuleAlgorithmField1 = new LinkedList<>(); + List<String> dynamicRuleAlgorithmField2 = new LinkedList<>(); + List<Object> dynamicVariableList = new LinkedList<>(); + List<String> dataTypeList = new LinkedList<>(); + List<String> errorCodeList = new LinkedList<>(); + List<String> treatmentList = new LinkedList<>(); + + if(policyData.getSettings().size() > 0){ + for(Object settingsData : policyData.getSettings()){ + if(settingsData instanceof LinkedHashMap<?, ?>){ + String key = ((LinkedHashMap<?, ?>) settingsData).get("key").toString(); + String value = ((LinkedHashMap<?, ?>) settingsData).get("value").toString(); + settingsMap.put(key, value); + } + } + } + if(policyData.getRuleAlgorithmschoices()!=null && policyData.getRuleAlgorithmschoices().size() > 0){ + for(Object attribute : policyData.getRuleAlgorithmschoices()){ + if(attribute instanceof LinkedHashMap<?, ?>){ + String label = ((LinkedHashMap<?, ?>) attribute).get("id").toString(); + String key = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField1").toString(); + String rule = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmCombo").toString(); + String value = ((LinkedHashMap<?, ?>) attribute).get("dynamicRuleAlgorithmField2").toString(); + dynamicRuleAlgorithmLabels.add(label); + dynamicRuleAlgorithmField1.add(key); + dynamicRuleAlgorithmCombo.add(rule); + dynamicRuleAlgorithmField2.add(value); + } + } + } + if(policyData.getRuleProvider()!=null && (policyData.getRuleProvider().equals(DecisionPolicy.GUARD_YAML)|| policyData.getRuleProvider().equals(DecisionPolicy.GUARD_BL_YAML)) + && policyData.getYamlparams()!=null){ + attributeMap.put("actor", policyData.getYamlparams().getActor()); + attributeMap.put("recipe", policyData.getYamlparams().getRecipe()); + attributeMap.put("clname", policyData.getYamlparams().getClname()); + attributeMap.put("limit", policyData.getYamlparams().getLimit()); + attributeMap.put("timeWindow", policyData.getYamlparams().getTimeWindow()); + attributeMap.put("timeUnits", policyData.getYamlparams().getTimeUnits()); + attributeMap.put("guardActiveStart", policyData.getYamlparams().getGuardActiveStart()); + attributeMap.put("guardActiveEnd", policyData.getYamlparams().getGuardActiveEnd()); + if(policyData.getYamlparams().getBlackList()!=null){ + String blackList = StringUtils.join(policyData.getYamlparams().getBlackList(), ","); + attributeMap.put("blackList", blackList); + } + if(policyData.getYamlparams().getTargets()!=null){ + String targets = StringUtils.join(policyData.getYamlparams().getTargets(),","); + attributeMap.put("targets", targets); + } + } + if(policyData.getRuleProvider()!=null && policyData.getRuleProvider().equals(DecisionPolicy.RAINY_DAY)){ + attributeMap.put("ServiceType", policyData.getRainyday().getServiceType()); + attributeMap.put("VNFType", policyData.getRainyday().getVnfType()); + attributeMap.put("BB_ID", policyData.getRainyday().getBbid()); + attributeMap.put("WorkStep", policyData.getRainyday().getWorkstep()); + + if(policyData.getRainyday().getTreatmentTableChoices()!=null && policyData.getRainyday().getTreatmentTableChoices().size() > 0){ + for (Object table : policyData.getRainyday().getTreatmentTableChoices()){ + if(table instanceof LinkedHashMap<?,?>){ + String errorcode = ((LinkedHashMap<?,?>) table).get("errorcode").toString(); + String treatment = ((LinkedHashMap<?,?>) table).get("treatment").toString(); + treatmentMap.put(errorcode, treatment); + } + } + } + } + + policyData.setDynamicRuleAlgorithmLabels(dynamicRuleAlgorithmLabels); + policyData.setDynamicRuleAlgorithmCombo(dynamicRuleAlgorithmCombo); + policyData.setDynamicRuleAlgorithmField1(dynamicRuleAlgorithmField1); + policyData.setDynamicRuleAlgorithmField2(dynamicRuleAlgorithmField2); + policyData.setDynamicVariableList(dynamicVariableList); + policyData.setDynamicSettingsMap(settingsMap); + policyData.setDynamicFieldConfigAttributes(attributeMap); + policyData.setDataTypeList(dataTypeList); + policyData.setRainydayMap(treatmentMap); + policyData.setErrorCodeList(errorCodeList); + policyData.setTreatmentList(treatmentList); + } + newPolicy = new DecisionPolicy(policyData); + } + + if(newPolicy != null){ + newPolicy.prepareToSave(); + }else{ + body = "error"; + status = HttpStatus.INTERNAL_SERVER_ERROR; + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "error"); + return new ResponseEntity<String>(body, status); + } + + PolicyDBDaoTransaction policyDBDaoTransaction = null; + try{ + policyDBDao = PolicyDBDao.getPolicyDBDaoInstance(XACMLPapServlet.getEmf()); + policyDBDaoTransaction = policyDBDao.getNewTransaction(); + policyDBDaoTransaction.createPolicy(newPolicy, policyData.getUserId()); + successMap = newPolicy.savePolicies(); + if(successMap.containsKey("success")){ + policyDBDaoTransaction.commitTransaction(); + if(policyData.isEditPolicy()){ + commonClassDao.update(policyVersionDao); + }else{ + commonClassDao.save(policyVersionDao); + } + try{ + PolicyElasticSearchController search= new PolicyElasticSearchController(); + search.updateElk(policyData); + }catch(Exception e){ + LOGGER.error("Error Occured while saving policy to Elastic Database"+e); + } + body = "success"; + status = HttpStatus.OK; + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + response.addHeader("policyName", policyData.getNewFileName()); + + //get message from the SafetyCheckerResults if present + String safetyCheckerResponse = policyData.getClWarning(); + String existingCLName = policyData.getExistingCLName(); + + //if safetyCheckerResponse is not null add a header to send back with response + if(safetyCheckerResponse!=null) { + PolicyLogger.info("SafetyCheckerResponse message: " + safetyCheckerResponse); + response.addHeader("safetyChecker", safetyCheckerResponse); + response.addHeader("newCLName", CLName); + response.addHeader("conflictCLName", existingCLName); + } else { + PolicyLogger.info("SafetyCheckerResponse was empty or null."); + } + + }else if (successMap.containsKey("invalidAttribute")) { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + "Invalid Action Attribute"; + LOGGER.error(XACMLErrorConstants.ERROR_DATA_ISSUE + "Could not fine " + policyData.getActionAttribute() + " in the ActionPolicyDict table."); + body = "invalidAttribute"; + status = HttpStatus.BAD_REQUEST; + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("invalidAttribute", policyData.getActionAttribute()); + response.addHeader("error", message); + response.addHeader("policyName", policyData.getPolicyName()); + }else if (successMap.containsKey("fwdberror")) { + policyDBDaoTransaction.rollbackTransaction(); + body = "fwdberror"; + status = HttpStatus.BAD_REQUEST; + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + + "Error when inserting Firewall ConfigBody data into the database."; + PolicyLogger.error(message); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + response.addHeader("policyName", policyData.getPolicyName()); + } else if (successMap.get("error").equals("Validation Failed")) { + policyDBDaoTransaction.rollbackTransaction(); + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + + "Error Validating the Policy on the PAP."; + PolicyLogger.error(message); + body = "Validation"; + status = HttpStatus.BAD_REQUEST; + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + response.addHeader("policyName", policyData.getPolicyName()); + }else { + policyDBDaoTransaction.rollbackTransaction(); + body = "error"; + status = HttpStatus.INTERNAL_SERVER_ERROR; + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "error"); + } + }catch(Exception e){ + if(policyDBDaoTransaction != null){ + policyDBDaoTransaction.rollbackTransaction(); + } + } + } + catch (Exception e){ + LOGGER.error("Exception Occured : "+e); + body = "error"; + response.addHeader("error", e.getMessage()); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + } + return new ResponseEntity<>(body, status); + } + + @ExceptionHandler({ HttpMessageNotReadableException.class }) + public ResponseEntity<String> messageNotReadableExceptionHandler(HttpServletRequest req, HttpMessageNotReadableException exception) { + LOGGER.error("Request not readable: {}", exception); + StringBuilder message = new StringBuilder(); + message.append(exception.getMessage()); + if (exception.getCause() != null) { + message.append(" Reason Caused: " + + exception.getCause().getMessage()); + } + return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST); + } + + public PolicyVersion getPolicyVersionData(String dbCheckPolicyName){ + PolicyVersion entityItem = (PolicyVersion) commonClassDao.getEntityItem(PolicyVersion.class, "policyName", dbCheckPolicyName); + if (entityItem != null) { + if(entityItem.getPolicyName().equals(dbCheckPolicyName)){ + return entityItem; + } + } + return entityItem; + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/package-info.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/package-info.java new file mode 100644 index 000000000..bb5307573 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/policycontroller/package-info.java @@ -0,0 +1,20 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.policycontroller;
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/DictionaryService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/DictionaryService.java new file mode 100644 index 000000000..df1916be9 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/DictionaryService.java @@ -0,0 +1,995 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.service; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.controller.ActionPolicyDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.BRMSDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.ClosedLoopDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.DecisionPolicyDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.DescriptiveDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.DictionaryController; +import org.onap.policy.pap.xacml.rest.controller.EnforcerDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.FirewallDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.MicroServiceDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.PolicyScopeDictionaryController; +import org.onap.policy.pap.xacml.rest.controller.SafePolicyController; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.springframework.stereotype.Service; +import org.springframework.web.servlet.ModelAndView; + + +@Service("DictionaryService") +public class DictionaryService { + + private static final Logger LOGGER = FlexLogger.getLogger(DictionaryService.class); + + /* + * Methods that call the controller method directly to Save and Update dictionary data + */ + public String saveOnapDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DictionaryController dictionary = new DictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveOnapDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + + } + + public String saveAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DictionaryController dictionary = new DictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveAttributeDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveActionPolicyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ActionPolicyDictionaryController action = new ActionPolicyDictionaryController(); + String responseString = null; + try { + ModelAndView result = action.saveActionPolicyDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + BRMSDictionaryController dictionary = new BRMSDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveBRMSParamDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveVSCLAction(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveVSCLAction(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveVnfType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveVnfType(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String savePEPOptions(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePEPOptions(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveVarbind(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveVarbind(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveServiceType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveServiceType(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveSiteType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveSiteType(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + } + + return responseString; + } + + public String saveSettingsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DecisionPolicyDictionaryController dictionary = new DecisionPolicyDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveSettingsDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveDescriptiveDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DescriptiveDictionaryController dictionary = new DescriptiveDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveDescriptiveDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveEnforcerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + EnforcerDictionaryController dictionary = new EnforcerDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveEnforcerDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveActionListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveActionListDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveProtocolListDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveZoneDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveSecurityZoneDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePrefixListDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveAddressGroupDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveServiceGroupDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveServiceListDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveTermListDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + + + + public String saveMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveMicroServiceLocationDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveMicroServiceConfigNameDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveDCAEUUIDDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveMicroServiceModelsDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveMicroServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveMicroServiceAttributeDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePSServiceDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePSResourceDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePSTypeDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePSClosedLoopDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String savePSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + String responseString = null; + try { + ModelAndView result = dictionary.savePSGroupScopeDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveRiskTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + SafePolicyController dictionary = new SafePolicyController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveRiskTypeDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + public String saveSafePolicyWarningDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + SafePolicyController dictionary = new SafePolicyController(); + String responseString = null; + try { + ModelAndView result = dictionary.saveSafePolicyWarningDictionary(request, response); + responseString = result.getViewName(); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + return responseString; + } + + + /* + * Methods that call the controller get methods directly to get dictionary data + */ + public void getOnapDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DictionaryController dictionary = new DictionaryController(); + try { + dictionary.getOnapNameDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getAttributeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DictionaryController dictionary = new DictionaryController(); + try { + dictionary.getAttributeDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getActionPolicyDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ActionPolicyDictionaryController action = new ActionPolicyDictionaryController(); + try { + action.getActionPolicyDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getBRMSParamDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + BRMSDictionaryController dictionary = new BRMSDictionaryController(); + try { + dictionary.getBRMSParamDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + } + + public void getVSCLAction(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getVSCLActionDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getVnfType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getVNFTypeDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + } + + public void getPEPOptions(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getPEPOptionsDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getVarbind(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getVarbindDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + + } + + public void getServiceType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getClosedLoopServiceDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getSiteType(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + ClosedLoopDictionaryController dictionary = new ClosedLoopDictionaryController(); + try { + dictionary.getClosedLoopSiteDictionaryEntityData(request, response); + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getSettingsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DecisionPolicyDictionaryController dictionary = new DecisionPolicyDictionaryController(); + try { + dictionary.getSettingsDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getDescriptiveDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + DescriptiveDictionaryController dictionary = new DescriptiveDictionaryController(); + try { + dictionary.getDescriptiveDictionaryEntityData(request, response); + + } catch (Exception e) { + + } + } + + public void getEnforcerDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + EnforcerDictionaryController dictionary = new EnforcerDictionaryController(); + try { + dictionary.getEnforcerDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getActionListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getActionListDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getProtocolListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getProtocolListDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getZoneDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getSecurityZoneDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getSecurityZoneDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPrefixListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getPrefixListDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getAddressGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getAddressGroupDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getServiceGroupDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getServiceGroupDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getServiceListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getServiceListDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getTermListDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + FirewallDictionaryController dictionary = new FirewallDictionaryController(); + try { + dictionary.getTermListDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + + public void getMicroServiceLocationDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + try { + dictionary.getMicroServiceLocationDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getMicroServiceConfigNameDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + try { + dictionary.getMicroServiceConfigNameDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getDCAEUUIDDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + try { + dictionary.getDCAEUUIDDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getMicroServiceModelsDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + try { + dictionary.getMicroServiceModelsDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getMicroServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + MicroServiceDictionaryController dictionary = new MicroServiceDictionaryController(); + try { + dictionary.getMicroServiceModelsDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPSServiceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + try { + dictionary.getPSServiceEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPSResourceDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + try { + dictionary.getPSResourceEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPSTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + try { + dictionary.getPSTypeEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPSClosedLoopDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + try { + dictionary.getPSClosedLoopEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getPSGroupScopeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + PolicyScopeDictionaryController dictionary = new PolicyScopeDictionaryController(); + try { + dictionary.getGroupPolicyScopeEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getRiskTypeDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + SafePolicyController dictionary = new SafePolicyController(); + try { + dictionary.getOnapNameDictionaryEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } + + public void getSafePolicyWarningDictionary(HttpServletRequest request, HttpServletResponse response) throws Exception{ + + SafePolicyController dictionary = new SafePolicyController(); + try { + dictionary.getSafePolicyWarningeEntityData(request, response); + + } catch (Exception e) { + LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + e); + + } + } +}
\ No newline at end of file diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/ImportService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/ImportService.java new file mode 100644 index 000000000..0a5da0ec3 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/ImportService.java @@ -0,0 +1,157 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.service; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStreamWriter; +import java.io.Writer; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.components.CreateBRMSRuleTemplate; +import org.onap.policy.pap.xacml.rest.components.CreateNewMicroServiceModel; + +public class ImportService { + + public void doImportMicroServicePut(HttpServletRequest request, HttpServletResponse response) { + String importServiceCreation = request.getParameter("importService");; + String fileName = request.getParameter("fileName"); + String version = request.getParameter("version"); + String serviceName = request.getParameter("serviceName"); + String description = request.getParameter("description"); + Map<String, String> successMap = new HashMap<>(); + switch(importServiceCreation){ + case "BRMSPARAM": + StringBuilder builder = new StringBuilder(); + int ch; + try { + while((ch = request.getInputStream().read()) != -1){ + builder.append((char)ch); + } + } catch (IOException e) { + PolicyLogger.error("Error in reading in file from API call"); + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "missing"); + response.addHeader("operation", "import"); + response.addHeader("service", serviceName); + } + CreateBRMSRuleTemplate brmsRuleTemplate = new CreateBRMSRuleTemplate(); + successMap = brmsRuleTemplate.addRule(builder.toString(), serviceName, description, "API"); + break; + case "MICROSERVICE": + CreateNewMicroServiceModel newMS = null; + String randomID = UUID.randomUUID().toString(); + if ( fileName != null) { + File extracDir = new File("ExtractDir"); + if (!extracDir.exists()){ + extracDir.mkdirs(); + } + if (fileName.contains(".xmi")){ + // get the request content into a String + String xmi = null; + java.util.Scanner scanner; + try { + scanner = new java.util.Scanner(request.getInputStream()); + scanner.useDelimiter("\\A"); + xmi = scanner.hasNext() ? scanner.next() : ""; + scanner.close(); + } catch (IOException e1) { + PolicyLogger.error("Error in reading in file from API call"); + return; + } + PolicyLogger.info("XML request from API for import new Service"); + try (Writer writer = new BufferedWriter(new OutputStreamWriter( + new FileOutputStream("ExtractDir" + File.separator + randomID+".xmi"), "utf-8"))) { + writer.write(xmi); + } catch (IOException e) { + PolicyLogger.error("Error in reading in file from API call"); + return; + } + }else{ + InputStream inputStream = null; + try(FileOutputStream outputStream = new FileOutputStream("ExtractDir" + File.separator + randomID+".zip")) { + inputStream = request.getInputStream(); + byte[] buffer = new byte[4096]; + int bytesRead = -1 ; + while ((bytesRead = inputStream.read(buffer)) != -1) { + outputStream.write(buffer, 0, bytesRead) ; + } + } catch (IOException e) { + PolicyLogger.error("Error in reading in Zip File from API call"+e); + return; + }finally{ + try { + if(inputStream != null){ + inputStream.close(); + } + } catch (IOException e) { + PolicyLogger.error("Exception Occured while closing the input/output stream"+e); + } + } + } + newMS = new CreateNewMicroServiceModel(fileName, serviceName, "API", version, randomID); + successMap = newMS.addValuesToNewModel(); + if (successMap.containsKey("success")) { + successMap.clear(); + successMap = newMS.saveImportService(); + } + } + break; + } + // return a response to the PAP + if (successMap.containsKey("success")) { + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "import"); + response.addHeader("service", serviceName); + } else if (successMap.containsKey("DBError")) { + if (successMap.get("DBError").contains("EXISTS")){ + response.setStatus(HttpServletResponse.SC_CONFLICT); + response.addHeader("service", serviceName); + response.addHeader("error", "modelExistsDB"); + }else{ + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "importDB"); + } + response.addHeader("operation", "import"); + response.addHeader("service", serviceName); + }else if (successMap.get("error").contains("MISSING")){ + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "missing"); + response.addHeader("operation", "import"); + response.addHeader("service", serviceName); + }else if (successMap.get("error").contains("VALIDATION")){ + response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + response.addHeader("error", "validation"); + response.addHeader("operation", "import"); + response.addHeader("service", serviceName); + } + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java new file mode 100644 index 000000000..416af4413 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/MetricService.java @@ -0,0 +1,93 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.service; + +import java.util.HashSet; +import java.util.Set; + +import javax.persistence.EntityManager; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.json.JSONObject; +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.xacml.api.XACMLErrorConstants; +import org.onap.policy.xacml.api.pap.OnapPDPGroup; + +import com.att.research.xacml.api.pap.PDPPolicy; + +public class MetricService { + + public static void doGetPolicyMetrics(HttpServletRequest request, HttpServletResponse response) { + Set<OnapPDPGroup> groups = new HashSet<>(); + try { + //get the count of policies on the PDP + if(XACMLPapServlet.getPAPEngine()!=null){ + groups = XACMLPapServlet.getPAPEngine().getOnapPDPGroups(); + } + int pdpCount = 0; + for (OnapPDPGroup group : groups) { + Set<PDPPolicy> policies = group.getPolicies(); + pdpCount += policies.size(); + } + //get the count of policies on the PAP + EntityManager em = null; + if(XACMLPapServlet.getEmf()!=null){ + em = (EntityManager) XACMLPapServlet.getEmf().createEntityManager(); + } + if (em==null){ + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + " Error creating entity manager with persistence unit: " + XACMLPapServlet.getPersistenceUnit()); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", "Error creating entity manager with persistence unit"); + return; + } + int papCount = ((Number) em.createNamedQuery("PolicyVersion.findAllCount").getSingleResult()).intValue(); + em.close(); + int totalCount = pdpCount + papCount; + //create json string for API response + JSONObject json = new JSONObject(); + json.put("papCount", papCount); + json.put("pdpCount", pdpCount); + json.put("totalCount", totalCount); + if (pdpCount>0 && papCount>0 && totalCount>0) { + PolicyLogger.info("Metrics have been found on the Policy Engine for the number of policies on the PAP and PDP."); + response.setStatus(HttpServletResponse.SC_OK); + response.addHeader("successMapKey", "success"); + response.addHeader("operation", "getMetrics"); + response.addHeader("metrics", json.toString() ); + return; + }else{ + String message = "The policy count on the PAP and PDP is 0. Please check the database and file system to correct this error."; + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + return; + } + } catch (Exception e) { + String message = XACMLErrorConstants.ERROR_DATA_ISSUE + " Error Querying the Database: " + e.getMessage(); + PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, "XACMLPapServlet", " Error Querying the Database."); + response.setStatus(HttpServletResponse.SC_BAD_REQUEST); + response.addHeader("error", message); + return; + } + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/AbstractPolicyCreation.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/AbstractPolicyCreation.java new file mode 100644 index 000000000..71de2b297 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/AbstractPolicyCreation.java @@ -0,0 +1,104 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ +package org.onap.policy.pap.xacml.rest.util; + + +import java.util.UUID; + +import org.onap.policy.rest.XACMLRestProperties; +import org.springframework.stereotype.Component; + +import com.att.research.xacml.util.XACMLProperties; +import com.google.common.base.Joiner; + +@Component +public abstract class AbstractPolicyCreation { + + public static String getDomain() { + return XACMLProperties.getProperty(XACMLRestProperties.PROP_ADMIN_DOMAIN, "urn"); + } + + public String newPolicyID() { + return Joiner.on(':').skipNulls().join((getDomain().startsWith("urn") ? null: "urn"), + getDomain().replaceAll("[/\\\\.]", ":"), "xacml", "policy", "id", UUID.randomUUID()); + } + + public String convertDate(String dateTTL, boolean portalType) { + String formateDate = null; + String[] date; + String[] parts; + + if (portalType){ + parts = dateTTL.split("-"); + formateDate = parts[2] + "-" + parts[1] + "-" + parts[0]; + } else { + date = dateTTL.split("T"); + parts = date[0].split("-"); + formateDate = parts[2] + "-" + parts[1] + "-" + parts[0]; + } + return formateDate; + } + + + + public void updatePolicyCreationToDatabase(){ + // Add it into our tree +/* Path finalPolicyPath = null; + finalPolicyPath = Paths.get(successMap.get("success")); + PolicyElasticSearchController controller = new PolicyElasticSearchController(); + controller.updateElk(finalPolicyPath.toString()); + File file = finalPolicyPath.toFile(); + if(file != null){ + String policyName = file.toString(); + String removePath = policyName.substring(policyName.indexOf("repository")+11); + String removeXml = removePath.replace(".xml", ""); + String removeExtension = removeXml.substring(0, removeXml.indexOf(".")); + List<Object> policyVersionList = commonClassDao.getDataById(PolicyVersion.class, "policyName", removeExtension); + if (policyVersionList.size() > 0) { + for(int i = 0; i < policyVersionList.size(); i++) { + PolicyVersion entityItem = (PolicyVersion) policyVersionList.get(i); + if(entityItem.getPolicyName().equals(removeExtension)){ + version = entityItem.getHigherVersion() +1; + entityItem.setActiveVersion(version); + entityItem.setHigherVersion(version); + entityItem.setModifiedBy(userId); + commonClassDao.update(entityItem); + if(policyData.isEditPolicy){ + PolicyNotificationMail email = new PolicyNotificationMail(); + String mode = "EditPolicy"; + String policyNameForEmail = policyData.getDomainDir() + File.separator + policyData.getOldPolicyFileName() + ".xml"; + email.sendMail(entityItem, policyNameForEmail, mode, commonClassDao); + } + } + } + }else{ + PolicyVersion entityItem = new PolicyVersion(); + entityItem.setActiveVersion(version); + entityItem.setHigherVersion(version); + entityItem.setPolicyName(removeExtension); + entityItem.setCreatedBy(userId); + entityItem.setModifiedBy(userId); + commonClassDao.save(entityItem); + } + }*/ + } + + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java new file mode 100644 index 000000000..732ed2f44 --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JPAUtils.java @@ -0,0 +1,239 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.util; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.Query; +import javax.servlet.ServletException; + +import org.onap.policy.rest.XacmlAdminAuthorization; +import org.onap.policy.rest.jpa.Attribute; +import org.onap.policy.rest.jpa.Datatype; +import org.onap.policy.rest.jpa.FunctionDefinition; +import org.onap.policy.rest.jpa.GlobalRoleSettings; + +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeDesignatorType; +import oasis.names.tc.xacml._3_0.core.schema.wd_17.AttributeSelectorType; + +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; + +public class JPAUtils { + private static Logger LOGGER = FlexLogger.getLogger(JPAUtils.class); + + private EntityManagerFactory emf; + private static final Object mapAccess = new Object(); + private static Map<Datatype, List<FunctionDefinition>> mapDatatype2Function = null; + private static Map<String, FunctionDefinition> mapID2Function = null; + private static JPAUtils currentInstance = null; + + + /** + * Get an instance of a JPAUtils. It creates one if it does not exist. + * Only one instance is allowed to be created per server. + * @param emf The EntityFactoryManager to be used for database connections + * @return The new instance of JPAUtils or throw exception if the given emf is null. + * @throws IllegalStateException if a JPAUtils has already been constructed. Call getJPAUtilsInstance() to get this. + */ + public static JPAUtils getJPAUtilsInstance(EntityManagerFactory emf) throws Exception{ + LOGGER.debug("getJPAUtilsInstance(EntityManagerFactory emf) as getJPAUtilsInstance("+emf+") called"); + if(currentInstance == null){ + if(emf != null){ + currentInstance = new JPAUtils(emf); + return currentInstance; + } + throw new IllegalStateException("The EntityManagerFactory is Null"); + } + return currentInstance; + } + + private JPAUtils(EntityManagerFactory emf){ + LOGGER.debug("JPAUtils(EntityManagerFactory emf) as JPAUtils("+emf+") called"); + this.emf = emf; + } + + /** + * Gets the current instance of JPAUtils. + * @return The instance of JPAUtils or throws exception if the given instance is null. + * @throws IllegalStateException if a JPAUtils instance is null. Call getJPAUtilsInstance(EntityManagerFactory emf) to get this. + */ + public static JPAUtils getJPAUtilsInstance() throws Exception{ + LOGGER.debug("getJPAUtilsInstance() as getJPAUtilsInstance() called"); + if(currentInstance != null){ + return currentInstance; + } + throw new IllegalStateException("The JPAUtils.currentInstance is Null. Use getJPAUtilsInstance(EntityManagerFactory emf)"); + } + + public static AttributeDesignatorType createDesignator(Attribute attribute) { + AttributeDesignatorType designator = new AttributeDesignatorType(); + designator.setAttributeId(attribute.getXacmlId()); + if (attribute.getCategoryBean() != null) { + designator.setCategory(attribute.getCategoryBean().getXacmlId()); + } else { + LOGGER.warn("No category bean"); + } + if (attribute.getDatatypeBean() != null) { + designator.setDataType(attribute.getDatatypeBean().getXacmlId()); + } else { + LOGGER.warn("No datatype bean"); + } + designator.setIssuer(attribute.getIssuer()); + designator.setMustBePresent(attribute.isMustBePresent()); + return designator; + } + + public static AttributeSelectorType createSelector(Attribute attribute) { + AttributeSelectorType selector = new AttributeSelectorType(); + selector.setContextSelectorId(attribute.getXacmlId()); + selector.setPath(attribute.getSelectorPath()); + if (attribute.getCategoryBean() != null) { + selector.setCategory(attribute.getCategoryBean().getXacmlId()); + } else { + LOGGER.warn("No category bean"); + } + if (attribute.getDatatypeBean() != null) { + selector.setDataType(attribute.getDatatypeBean().getXacmlId()); + } else { + LOGGER.warn("No datatype bean"); + } + selector.setMustBePresent(attribute.isMustBePresent()); + return selector; + } + + /** + * Builds a map in memory of a functions return datatype to function definition. Useful in limiting the number + * of SQL calls to DB especially when we don't expect these to change much. + * + * @return - A HashMap of Datatype JPA Container ID's to FunctionDefinition objects + */ + public Map<Datatype, List<FunctionDefinition>> getFunctionDatatypeMap() { + + synchronized(mapAccess) { + if (mapDatatype2Function == null||mapDatatype2Function.isEmpty()) { + try { + buildFunctionMaps(); + } catch (ServletException e) { + LOGGER.error("Exception Occured"+e); + } + } + } + return mapDatatype2Function; + } + + public Map<String, FunctionDefinition> getFunctionIDMap() { + synchronized(mapAccess) { + if (mapID2Function == null||mapID2Function.equals("{}")) { + try { + buildFunctionMaps(); + } catch (ServletException e) { + LOGGER.error("Exception Occured"+e); + } + } + } + return mapID2Function; + } + + private void buildFunctionMaps() throws ServletException { + mapDatatype2Function = new HashMap<>(); + mapID2Function = new HashMap<>(); + + EntityManager em = emf.createEntityManager(); + Query getFunctionDefinitions = em.createNamedQuery("FunctionDefinition.findAll"); + List<?> functionList = getFunctionDefinitions.getResultList(); + + for (Object id : functionList) { + FunctionDefinition value = (FunctionDefinition)id; + mapID2Function.put(value.getXacmlid(), value); + if (mapDatatype2Function.containsKey(value.getDatatypeBean()) == false) { + mapDatatype2Function.put(value.getDatatypeBean(), new ArrayList<FunctionDefinition>()); + } + mapDatatype2Function.get(value.getDatatypeBean()).add(value); + } + + em.close(); + + } + + /** + * Returns the lockdown value, in case of exception it is assumed that lockdown functionality + * is not supported and returns false. + * + * + * @throws ReadOnlyException + * @throws ConversionException + */ + public boolean dbLockdownIgnoreErrors() { + if (LOGGER.isTraceEnabled()) + LOGGER.trace("ENTER"); + + boolean lockdown = false; + try { + lockdown = dbLockdown(); + } catch (Exception e) { + LOGGER.warn("Cannot access DB lockdown value", e); + } + return lockdown; + } + + /** + * Returns the lockdown value from the database. + * + * @throws ReadOnlyException + * @throws ConversionException + */ + public boolean dbLockdown() + throws IllegalAccessException { + if (LOGGER.isTraceEnabled()) + LOGGER.trace("ENTER"); + + EntityManager em = emf.createEntityManager(); + Query globalRoleSettingsJPA = em.createNamedQuery("GlobalRoleSettings.findAll"); + + GlobalRoleSettings globalRoleSettings = (GlobalRoleSettings) globalRoleSettingsJPA.getSingleResult(); + + if (globalRoleSettings == null) { + // this should not happen + String msg = "NO GlobalSetttings for " + XacmlAdminAuthorization.Role.ROLE_SUPERADMIN.toString(); + if (LOGGER.isErrorEnabled()) + LOGGER.error(msg); + throw new IllegalAccessException(msg); + } + + if (!globalRoleSettings.getRole().equals(XacmlAdminAuthorization.Role.ROLE_SUPERADMIN.toString())) { + String msg = "NOT FOUND db data for " + XacmlAdminAuthorization.Role.ROLE_SUPERADMIN.toString(); + if (LOGGER.isErrorEnabled()) + LOGGER.error(msg); + throw new IllegalAccessException(msg); + } + + return globalRoleSettings.isLockdown(); + } + + + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JsonMessage.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JsonMessage.java new file mode 100644 index 000000000..ab3b126ea --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/JsonMessage.java @@ -0,0 +1,67 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.util; + +public class JsonMessage { + + private String data; + private String data2; + private String data3; + public JsonMessage(String data) { + super(); + this.data = data; + } + public JsonMessage(String data,String data2) { + super(); + this.data = data; + this.data2 = data2; + } + + public JsonMessage(String data,String data2,String data3) { + super(); + this.data = data; + this.data2 = data2; + this.data3 = data3; + } + + public String getData() { + return data; + } + + public void setData(String data) { + this.data = data; + } + public String getData2() { + return data2; + } + public void setData2(String data2) { + this.data2 = data2; + } + public String getData3() { + return data3; + } + public void setData3(String data3) { + this.data3 = data3; + } + + +} + diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyContainer.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyContainer.java new file mode 100644 index 000000000..5d2453b5c --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyContainer.java @@ -0,0 +1,121 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Policy Engine + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.util; + +import java.io.Serializable; +import java.util.Collection; +import java.util.List; + + +public interface PolicyContainer extends Serializable{ + + public Collection<?> getContainerPropertyIds(); + + public Collection<?> getItemIds(); + + public Class<?> getType(Object propertyId); + + public int size(); + + public boolean containsId(Object itemId); + + public Object addItem() throws UnsupportedOperationException; + + public boolean removeItem(Object itemId) + throws UnsupportedOperationException; + + public boolean addContainerProperty(Object propertyId, Class<?> type, + Object defaultValue) throws UnsupportedOperationException; + + public boolean removeContainerProperty(Object propertyId) + throws UnsupportedOperationException; + + public boolean removeAllItems() throws UnsupportedOperationException; + + public interface Ordered extends PolicyContainer { + + public Object nextItemId(Object itemId); + + public Object prevItemId(Object itemId); + + public Object firstItemId(); + + public Object lastItemId(); + + public boolean isFirstId(Object itemId); + + public boolean isLastId(Object itemId); + + public Object addItemAfter(Object previousItemId) + throws UnsupportedOperationException; + + } + + + public interface Indexed extends Ordered { + + public int indexOfId(Object itemId); + + public Object getIdByIndex(int index); + + public List<?> getItemIds(int startIndex, int numberOfItems); + + public Object addItemAt(int index) throws UnsupportedOperationException; + + public interface ItemAddEvent extends ItemSetChangeEvent { + + public Object getFirstItemId(); + + public int getFirstIndex(); + + public int getAddedItemsCount(); + } + + + public interface ItemRemoveEvent extends ItemSetChangeEvent { + + public Object getFirstItemId(); + + public int getFirstIndex(); + + public int getRemovedItemsCount(); + } + } + + public interface ItemSetChangeEvent extends Serializable { + + public PolicyContainer getContainer(); + } + + public interface ItemSetChangeListener extends Serializable { + + public void containerItemSetChange(PolicyContainer.ItemSetChangeEvent event); + } + + public interface ItemSetChangeNotifier extends Serializable { + + public void addItemSetChangeListener( + PolicyContainer.ItemSetChangeListener listener); + + public void removeItemSetChangeListener( + PolicyContainer.ItemSetChangeListener listener); + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyItemSetChangeNotifier.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyItemSetChangeNotifier.java new file mode 100644 index 000000000..5d7f7853c --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/util/PolicyItemSetChangeNotifier.java @@ -0,0 +1,96 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP Policy Engine + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.rest.util; + + +import java.io.Serializable; +import java.util.Collection; +import java.util.EventObject; +import java.util.LinkedList; + +import org.onap.policy.pap.xacml.rest.util.PolicyContainer.ItemSetChangeEvent; +import org.onap.policy.pap.xacml.rest.util.PolicyContainer.ItemSetChangeListener; + + + + +public class PolicyItemSetChangeNotifier implements PolicyContainer.ItemSetChangeNotifier { + private static final long serialVersionUID = 1L; + private Collection<PolicyContainer.ItemSetChangeListener> itemSetChangeListeners = null; + private PolicyContainer container = null; + + public PolicyItemSetChangeNotifier() { + } + + protected void setContainer(PolicyContainer c) { + this.container = c; + } + + @Override + public void addItemSetChangeListener(ItemSetChangeListener listener) { + if (getItemSetChangeListeners() == null) { + setItemSetChangeListeners(new LinkedList<PolicyContainer.ItemSetChangeListener>()); + } + getItemSetChangeListeners().add(listener); } + + @Override + public void removeItemSetChangeListener(ItemSetChangeListener listener) { + if (getItemSetChangeListeners() != null) { + getItemSetChangeListeners().remove(listener); + } + } + + protected static class BaseItemSetChangeEvent extends EventObject implements + PolicyContainer.ItemSetChangeEvent, Serializable { + private static final long serialVersionUID = 1L; + + protected BaseItemSetChangeEvent(PolicyContainer source) { + super(source); + } + + @Override + public PolicyContainer getContainer() { + return (PolicyContainer) getSource(); + } + } + + protected void setItemSetChangeListeners( + Collection<PolicyContainer.ItemSetChangeListener> itemSetChangeListeners) { + this.itemSetChangeListeners = itemSetChangeListeners; + } + protected Collection<PolicyContainer.ItemSetChangeListener> getItemSetChangeListeners() { + return itemSetChangeListeners; + } + + protected void fireItemSetChange() { + fireItemSetChange(new BaseItemSetChangeEvent(this.container)); + } + + protected void fireItemSetChange(ItemSetChangeEvent event) { + if (getItemSetChangeListeners() != null) { + final Object[] l = getItemSetChangeListeners().toArray(); + for (int i = 0; i < l.length; i++) { + ((PolicyContainer.ItemSetChangeListener) l[i]) + .containerItemSetChange(event); + } + } + } +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/AuthenticationService.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/AuthenticationService.java new file mode 100644 index 000000000..d0bfa2f8d --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/AuthenticationService.java @@ -0,0 +1,63 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.restAuth; + +import java.util.Base64; +import java.util.StringTokenizer; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.rest.XACMLRestProperties; + +import com.att.research.xacml.util.XACMLProperties; + +public class AuthenticationService { + private String papID = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_USERID); + private String papPass = XACMLProperties.getProperty(XACMLRestProperties.PROP_PAP_PASS); + + public boolean authenticate(String authCredentials) { + + if (null == authCredentials) + return false; + // header value format will be "Basic encodedstring" for Basic authentication. + final String encodedUserPassword = authCredentials.replaceFirst("Basic" + " ", ""); + String usernameAndPassword = null; + try { + byte[] decodedBytes = Base64.getDecoder().decode(encodedUserPassword); + usernameAndPassword = new String(decodedBytes, "UTF-8"); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "AuthenticationService", "Exception decoding username and password"); + return false; + } + try { + final StringTokenizer tokenizer = new StringTokenizer(usernameAndPassword, ":"); + final String username = tokenizer.nextToken(); + final String password = tokenizer.nextToken(); + + boolean authenticationStatus = papID.equals(username) && papPass.equals(password); + return authenticationStatus; + } catch (Exception e){ + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "AuthenticationService", "Exception authenticating user"); + return false; + } + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/CheckPDP.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/CheckPDP.java new file mode 100644 index 000000000..02ec467ed --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/CheckPDP.java @@ -0,0 +1,181 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.restAuth; + +import java.io.FileInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Properties; + +import org.onap.policy.common.logging.eelf.MessageCodes; +import org.onap.policy.common.logging.eelf.PolicyLogger; +import org.onap.policy.common.logging.flexlogger.FlexLogger; +import org.onap.policy.common.logging.flexlogger.Logger; +import org.onap.policy.pap.xacml.rest.XACMLPapServlet; +import org.onap.policy.xacml.api.XACMLErrorConstants; + +public class CheckPDP { + + private static Path pdpPath = null; + private static Properties pdpProp = null; + private static Long oldModified = null; + private static Long newModified = null; + private static HashMap<String, String> pdpMap = null; + private static final Logger logger = FlexLogger.getLogger(CheckPDP.class); + + public static boolean validateID(String id) { + // ReadFile + try { + readFile(); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CheckPDP", "Exception reading file"); + return false; + } + // Check ID + if (pdpMap.containsKey(id)) { + return true; + } + return false; + } + + private static void readFile() throws Exception { + String pdpFile = XACMLPapServlet.getPDPFile(); + if (pdpFile == null) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "PDP File name is undefined"); + throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"PDP File name not Valid : " + pdpFile); + } + if (pdpPath == null) { + pdpPath = Paths.get(pdpFile); + if (Files.notExists(pdpPath)) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "File doesn't exist in the specified Path"); + throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"File doesn't exist in the specified Path : "+ pdpPath.toString()); + } + if (pdpPath.toString().endsWith(".properties")) { + readProps(); + } else { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR + "Not a .properties file"); + throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Not a .properties file"); + } + } + // Check if File is updated recently + else { + newModified = pdpPath.toFile().lastModified(); + if (newModified != oldModified) { + // File has been updated. + readProps(); + } + } + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private static void readProps() throws Exception { + InputStream in; + pdpProp = new Properties(); + try { + in = new FileInputStream(pdpPath.toFile()); + oldModified = pdpPath.toFile().lastModified(); + pdpProp.load(in); + } catch (IOException e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CheckPDP", "Cannot load the Properties file"); + throw new Exception("Cannot Load the Properties file", e); + } + // Read the Properties and Load the PDPs and encoding. + pdpMap = new HashMap<>(); + // Check the Keys for PDP_URLs + Collection<Object> unsorted = pdpProp.keySet(); + List<String> sorted = new ArrayList(unsorted); + Collections.sort(sorted); + for (String propKey : sorted) { + if (propKey.startsWith("PDP_URL")) { + String check_val = pdpProp.getProperty(propKey); + if (check_val == null) { + throw new Exception("Properties file doesn't have the PDP_URL parameter"); + } + if (check_val.contains(";")) { + List<String> pdp_default = new ArrayList<>(Arrays.asList(check_val.split("\\s*;\\s*"))); + int pdpCount = 0; + while (pdpCount < pdp_default.size()) { + String pdpVal = pdp_default.get(pdpCount); + readPDPParam(pdpVal); + pdpCount++; + } + } else { + readPDPParam(check_val); + } + } + } + if (pdpMap == null || pdpMap.isEmpty()) { + logger.debug(XACMLErrorConstants.ERROR_SYSTEM_ERROR + "Cannot Proceed without PDP_URLs"); + throw new Exception(XACMLErrorConstants.ERROR_SYSTEM_ERROR +"Cannot Proceed without PDP_URLs"); + } + } + + private static void readPDPParam(String pdpVal) throws Exception{ + if(pdpVal.contains(",")){ + List<String> pdpValues = new ArrayList<>(Arrays.asList(pdpVal.split("\\s*,\\s*"))); + if(pdpValues.size()==3){ + // 1:2 will be UserID:Password + String userID = pdpValues.get(1); + String pass = pdpValues.get(2); + Base64.Encoder encoder = Base64.getEncoder(); + // 0 - PDPURL + pdpMap.put(pdpValues.get(0), encoder.encodeToString((userID+":"+pass).getBytes(StandardCharsets.UTF_8))); + }else{ + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + "No Credentials to send Request"); + throw new Exception(XACMLErrorConstants.ERROR_PERMISSIONS + "No enough Credentials to send Request. " + pdpValues); + } + }else{ + PolicyLogger.error(MessageCodes.ERROR_PERMISSIONS + "No Credentials to send Request: " + pdpVal); + throw new Exception(XACMLErrorConstants.ERROR_PERMISSIONS +"No enough Credentials to send Request."); + } + } + + public static String getEncoding(String pdpID){ + try { + readFile(); + } catch (Exception e) { + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CheckPDP", "Exeption reading Properties file"); + } + String encoding = null; + if(pdpMap!=null && (!pdpMap.isEmpty())){ + try{ + encoding = pdpMap.get(pdpID); + } catch(Exception e){ + PolicyLogger.error(MessageCodes.ERROR_SYSTEM_ERROR, e, "CheckPDP", "Exception encoding"); + } + return encoding; + }else{ + return null; + } + } + +} diff --git a/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/PAPAuthenticationFilter.java b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/PAPAuthenticationFilter.java new file mode 100644 index 000000000..44cb7d14a --- /dev/null +++ b/ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/restAuth/PAPAuthenticationFilter.java @@ -0,0 +1,130 @@ +/*- + * ============LICENSE_START======================================================= + * ONAP-PAP-REST + * ================================================================================ + * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * 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. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.policy.pap.xacml.restAuth; + +import java.io.IOException; + +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.annotation.WebFilter; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; + +/** + * Servlet Filter implementation class PAPAuthenticationFilter + */ +@WebFilter("/*") +public class PAPAuthenticationFilter implements Filter { + + private static final Log logger = LogFactory.getLog(PAPAuthenticationFilter.class); + public static final String AUTHENTICATION_HEADER = "Authorization"; + + @Override + public void doFilter(ServletRequest request, ServletResponse response, + FilterChain filter) throws IOException, ServletException { + + + if (request instanceof HttpServletRequest) { + HttpServletRequest httpServletRequest = (HttpServletRequest) request; + + String authCredentials = null; + String url = httpServletRequest.getRequestURI(); + + logger.info("Request URI: " + url); + System.out.println("Request URI: " + url); + + //getting authentication credentials + if(url.contains("@Auth@")){ + int authIndex = url.lastIndexOf("@"); + int endAuthIndex = url.indexOf("/onap"); + authCredentials = "Basic " + url.substring(authIndex+1, endAuthIndex); + + //parse the url for /pap/onap/ + String url1 = url.substring(0, 4); + String url2 = url.substring(endAuthIndex, url.length()); + url = url1 + url2; + + } else { + authCredentials = httpServletRequest.getHeader(AUTHENTICATION_HEADER); + } + + // Check Authentication credentials + AuthenticationService authenticationService = new AuthenticationService(); + boolean authenticationStatus = authenticationService.authenticate(authCredentials); + + if (authenticationStatus) { + //indicates the request comes from Traditional Admin Console or PolicyEngineAPI + if (url.equals("/pap/")){ + logger.info("Request comes from Traditional Admin Console or PolicyEngineAPI"); + + //forward request to the XACMLPAPServlet if authenticated + request.getRequestDispatcher("/pap/pap/").forward(request, response); + + }else if (url.startsWith("/pap/onap/")){ + + //indicates the request comes from the ONAP Portal onap-sdk-app + if(response instanceof HttpServletResponse) { + HttpServletResponse alteredResponse = ((HttpServletResponse)response); + addCorsHeader(alteredResponse); + logger.info("Request comes from Onap Portal"); + //Spring dispatcher servlet is at the end of the filter chain at /pap/onap/ path + System.out.println("New Request URI: " + url); + filter.doFilter(request, response); + /*url = url.substring(url.indexOf("/pap/")+4); + request.getRequestDispatcher(url).forward(request, response);*/ + } + + } + + } else { + if (response instanceof HttpServletResponse) { + HttpServletResponse httpServletResponse = (HttpServletResponse) response; + httpServletResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED); + } + } + + } + } + + //method to add CorsHeaders for onap portal rest call + private void addCorsHeader(HttpServletResponse response) { + logger.info("Adding Cors Response Headers!!!"); + response.addHeader("Access-Control-Allow-Origin", "*"); + response.addHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE, HEAD"); + response.addHeader("Access-Control-Allow-Headers", "X-PINGOTHER, Origin, X-Requested-With, Content-Type, Accept"); + response.addHeader("Access-Control-Max-Age", "1728000"); + } + + @Override + public void destroy() { + } + + @Override + public void init(FilterConfig arg0) throws ServletException { + } +} |