ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/daoimpl/CommonClassDaoImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017,2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.policy.pap.xacml.rest.daoimpl;
  22
  23 import java.util.List;
  24 import java.util.Map;
  25
  26 import javax.script.SimpleBindings;
  27
  28 import org.apache.commons.logging.Log;
  29 import org.apache.commons.logging.LogFactory;
  30 import org.hibernate.Criteria;
  31 import org.hibernate.HibernateException;
  32 import org.hibernate.Query;
  33 import org.hibernate.Session;
  34 import org.hibernate.SessionFactory;
  35 import org.hibernate.Transaction;
  36 import org.hibernate.criterion.Conjunction;
  37 import org.hibernate.criterion.Criterion;
  38 import org.hibernate.criterion.Disjunction;
  39 import org.hibernate.criterion.Projections;
  40 import org.hibernate.criterion.Restrictions;
  41 import org.onap.policy.rest.dao.CommonClassDao;
  42 import org.onap.policy.rest.jpa.ClosedLoops;
  43 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  44 import org.onap.policy.rest.jpa.PolicyRoles;
  45 import org.onap.policy.xacml.api.XACMLErrorConstants;
  46 import org.springframework.beans.factory.annotation.Autowired;
  47 import org.springframework.context.annotation.Primary;
  48 import org.springframework.stereotype.Service;
  49
  50 @Service("CommonClassDao")
  51 @Primary
  52 public class CommonClassDaoImpl implements CommonClassDao {
  53
  54     private static final Log LOGGER = LogFactory.getLog(CommonClassDaoImpl.class);
  55
  56     private static SessionFactory sessionFactory;
  57
  58     @Autowired
  59     private CommonClassDaoImpl(SessionFactory sessionFactory) {
  60         CommonClassDaoImpl.sessionFactory = sessionFactory;
  61     }
  62
  63     public CommonClassDaoImpl() {
  64         // Default Constructor
  65     }
  66
  67     @SuppressWarnings({"unchecked", "rawtypes"})
  68     @Override
  69     public List<Object> getData(Class className) {
  70         Session session = sessionFactory.openSession();
  71         List<Object> data = null;
  72         try {
  73             Criteria cr = session.createCriteria(className);
  74             data = cr.list();
  75         } catch (Exception e) {
  76             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
  77         } finally {
  78             try {
  79                 session.close();
  80             } catch (Exception e) {
  81                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e);
  82             }
  83         }
  84         return data;
  85     }
  86
  87     @SuppressWarnings({"rawtypes", "unchecked"})
  88     @Override
  89     public List<Object> getDataById(Class className, String columnName, String key) {
  90         Session session = sessionFactory.openSession();
  91         List<Object> data = null;
  92         try {
  93             Criteria cr = session.createCriteria(className);
  94             if (columnName.contains(":") && key.contains(":")) {
  95                 String[] columns = columnName.split(":");
  96                 String[] keys = key.split(":");
  97                 for (int i = 0; i < columns.length; i++) {
  98                     cr.add(Restrictions.eq(columns[i], keys[i]));
  99                 }
 100             } else {
 101                 cr.add(Restrictions.eq(columnName, key));
 102             }
 103             data = cr.list();
 104         } catch (Exception e) {
 105             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
 106         } finally {
 107             try {
 108                 session.close();
 109             } catch (Exception e1) {
 110                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 111             }
 112         }
 113         return data;
 114     }
 115
 116     @SuppressWarnings({"unchecked", "rawtypes"})
 117     @Override
 118     public List<String> getDataByColumn(Class className, String columnName) {
 119         Session session = sessionFactory.openSession();
 120         List<String> data = null;
 121         try {
 122             Criteria cr = session.createCriteria(className);
 123             cr.setProjection(Projections.property(columnName));
 124             data = cr.list();
 125         } catch (Exception e) {
 126             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
 127         } finally {
 128             try {
 129                 session.close();
 130             } catch (Exception e) {
 131                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e);
 132             }
 133         }
 134         return data;
 135     }
 136
 137     @Override
 138     public void save(Object entity) {
 139         Session session = sessionFactory.openSession();
 140         Transaction tx = session.beginTransaction();
 141         try {
 142             session.persist(entity);
 143             tx.commit();
 144         } catch (Exception e) {
 145             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table" + e);
 146         } finally {
 147             try {
 148                 session.close();
 149             } catch (Exception e1) {
 150                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 151             }
 152         }
 153
 154     }
 155
 156     @Override
 157     public void delete(Object entity) {
 158         Session session = sessionFactory.openSession();
 159         Transaction tx = session.beginTransaction();
 160         try {
 161             session.delete(entity);
 162             tx.commit();
 163         } catch (Exception e) {
 164             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table" + e);
 165         } finally {
 166             try {
 167                 session.close();
 168             } catch (Exception e1) {
 169                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 170             }
 171         }
 172
 173     }
 174
 175     @Override
 176     public void update(Object entity) {
 177         Session session = sessionFactory.openSession();
 178         Transaction tx = session.beginTransaction();
 179         try {
 180             session.update(entity);
 181             tx.commit();
 182         } catch (Exception e) {
 183             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table" + e);
 184         } finally {
 185             try {
 186                 session.close();
 187             } catch (Exception e1) {
 188                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 189             }
 190         }
 191
 192     }
 193
 194     @SuppressWarnings({"unchecked", "rawtypes"})
 195     @Override
 196     public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 197         Session session = sessionFactory.openSession();
 198         Transaction tx = session.beginTransaction();
 199         List<Object> data = null;
 200
 201         String[] columnNames = null;
 202         if (columnName != null && columnName.contains(":")) {
 203             columnNames = columnName.split(":");
 204         }
 205         String[] values = null;
 206         if (value != null && value.contains(":")) {
 207             values = value.split(":");
 208         }
 209         try {
 210             Criteria cr = session.createCriteria(className);
 211             if (columnNames != null && values != null && columnNames.length == values.length) {
 212                 for (int i = 0; i < columnNames.length; i++) {
 213                     cr.add(Restrictions.eq(columnNames[i], values[i]));
 214                 }
 215             } else {
 216                 cr.add(Restrictions.eq(columnName, value));
 217             }
 218
 219             data = cr.list();
 220             tx.commit();
 221         } catch (Exception e) {
 222             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"
 223                     + e + className);
 224         } finally {
 225             try {
 226                 session.close();
 227             } catch (Exception e1) {
 228                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 229             }
 230         }
 231         return data;
 232     }
 233
 234     @SuppressWarnings("unchecked")
 235     @Override
 236     public List<Object> getDataByQuery(String query, SimpleBindings params) {
 237         Session session = sessionFactory.openSession();
 238         Transaction tx = session.beginTransaction();
 239         List<Object> data = null;
 240         try {
 241             Query hbquery = session.createQuery(query);
 242             for (Map.Entry<String, Object> paramPair : params.entrySet()) {
 243                 if (paramPair.getValue() instanceof java.lang.Long) {
 244                     hbquery.setLong(paramPair.getKey(), (long) paramPair.getValue());
 245                 } else {
 246                     hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 247                 }
 248             }
 249             data = hbquery.list();
 250             tx.commit();
 251         } catch (Exception e) {
 252             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table" + e);
 253             throw e;
 254         } finally {
 255             try {
 256                 session.close();
 257             } catch (HibernateException e1) {
 258                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement", e1);
 259             }
 260         }
 261         return data;
 262     }
 263
 264     @Override
 265     public void updateQuery(String query) {
 266         Session session = sessionFactory.openSession();
 267         Transaction tx = session.beginTransaction();
 268         try {
 269             Query hbquery = session.createQuery(query);
 270             hbquery.executeUpdate();
 271             tx.commit();
 272         } catch (Exception e) {
 273             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table" + e);
 274         } finally {
 275             try {
 276                 session.close();
 277             } catch (Exception e1) {
 278                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 279             }
 280         }
 281     }
 282
 283     @SuppressWarnings("rawtypes")
 284     @Override
 285     public Object getEntityItem(Class className, String columnName, String key) {
 286         Session session = sessionFactory.openSession();
 287         Transaction tx = session.beginTransaction();
 288         Object data = null;
 289         try {
 290             Criteria cr = session.createCriteria(className);
 291             if (columnName.contains(":") && key.contains(":")) {
 292                 String[] columns = columnName.split(":");
 293                 String[] keys = key.split(":");
 294                 for (int i = 0; i < columns.length; i++) {
 295                     cr.add(Restrictions.eq(columns[i], keys[i]));
 296                 }
 297             } else {
 298                 cr.add(Restrictions.eq(columnName, key));
 299             }
 300             data = cr.list().get(0);
 301             tx.commit();
 302         } catch (Exception e) {
 303             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table" + e);
 304         } finally {
 305             try {
 306                 session.close();
 307             } catch (Exception e1) {
 308                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 309             }
 310         }
 311         return data;
 312     }
 313
 314     @SuppressWarnings("unchecked")
 315     @Override
 316     public List<PolicyRoles> getUserRoles() {
 317         Session session = sessionFactory.openSession();
 318         Transaction tx = session.beginTransaction();
 319         List<PolicyRoles> rolesData = null;
 320         try {
 321             Criteria cr = session.createCriteria(PolicyRoles.class);
 322             Disjunction disjunction = Restrictions.disjunction();
 323             Conjunction conjunction1 = Restrictions.conjunction();
 324             conjunction1.add(Restrictions.eq("role", "admin"));
 325             Conjunction conjunction2 = Restrictions.conjunction();
 326             conjunction2.add(Restrictions.eq("role", "editor"));
 327             Conjunction conjunction3 = Restrictions.conjunction();
 328             conjunction3.add(Restrictions.eq("role", "guest"));
 329             disjunction.add(conjunction1);
 330             disjunction.add(conjunction2);
 331             disjunction.add(conjunction3);
 332             rolesData = cr.add(disjunction).list();
 333             tx.commit();
 334         } catch (Exception e) {
 335             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table" + e);
 336         } finally {
 337             try {
 338                 session.close();
 339             } catch (Exception e1) {
 340                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 341             }
 342         }
 343         return rolesData;
 344     }
 345
 346     @SuppressWarnings("unchecked")
 347     @Override
 348     public void updateClAlarms(String clName, String alarms) {
 349         Session session = sessionFactory.openSession();
 350         List<ClosedLoops> closedloopsdata = null;
 351         Transaction tx = session.beginTransaction();
 352         try {
 353             Criteria cr = session.createCriteria(ClosedLoops.class);
 354             cr.add(Restrictions.eq("closedLoopControlName", clName));
 355             closedloopsdata = cr.list();
 356             ClosedLoops closedloop = closedloopsdata.get(0);
 357             closedloop.setAlarmConditions(alarms);
 358             session.update(closedloop);
 359             tx.commit();
 360         } catch (Exception e) {
 361             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table" + e);
 362         } finally {
 363             session.close();
 364         }
 365     }
 366
 367     @SuppressWarnings("unchecked")
 368     @Override
 369     public void updateClYaml(String clName, String yaml) {
 370         Session session = sessionFactory.openSession();
 371         List<ClosedLoops> closedloopsdata = null;
 372         Transaction tx = session.beginTransaction();
 373         try {
 374             Criteria cr = session.createCriteria(ClosedLoops.class);
 375             cr.add(Restrictions.eq("closedLoopControlName", clName));
 376             closedloopsdata = cr.list();
 377             ClosedLoops closedloop = closedloopsdata.get(0);
 378             closedloop.setYaml(yaml);
 379             session.update(closedloop);
 380             tx.commit();
 381         } catch (Exception e) {
 382             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table" + e);
 383         } finally {
 384             session.close();
 385         }
 386     }
 387
 388     @SuppressWarnings("unchecked")
 389     @Override
 390     public void deleteAll() {
 391         Session session = sessionFactory.openSession();
 392         Transaction tx = session.beginTransaction();
 393         List<ClosedLoops> closedloopsdata = null;
 394         try {
 395             Criteria cr = session.createCriteria(ClosedLoops.class);
 396             closedloopsdata = cr.list();
 397
 398             if (closedloopsdata != null && !closedloopsdata.isEmpty()) {
 399                 LOGGER.info(
 400                         "ClosedLoops exist in the database, we need to delete them in our first step to buildCache().");
 401                 for (int i = 0; i < closedloopsdata.size(); i++) {
 402                     ClosedLoops cl = closedloopsdata.get(i);
 403                     session.delete(cl);
 404                 }
 405             } else {
 406                 LOGGER.info("No ClosedLoops exist in the database, no need to delete.");
 407             }
 408
 409             tx.commit();
 410         } catch (Exception e) {
 411             LOGGER.error(
 412                     XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while deleting ClosedLoops from the table" + e);
 413         } finally {
 414             session.close();
 415         }
 416     }
 417
 418     @SuppressWarnings({"unchecked"})
 419     @Override
 420     public List<Object> checkExistingGroupListforUpdate(String groupListValue, String groupNameValue) {
 421         Session session = sessionFactory.openSession();
 422         Transaction tx = session.beginTransaction();
 423         List<Object> data = null;
 424         try {
 425             Criteria cr = session.createCriteria(GroupPolicyScopeList.class);
 426             cr.add(Restrictions.eq("groupList", groupListValue));
 427             Criterion expression = Restrictions.eq("name", groupNameValue);
 428             cr.add(Restrictions.not(expression));
 429             data = cr.list();
 430             tx.commit();
 431         } catch (Exception e) {
 432             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW
 433                     + "Error While Querying for Duplicate Entries for GroupPolicyScopeList Table" + e);
 434         } finally {
 435             try {
 436                 session.close();
 437             } catch (Exception e1) {
 438                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 439             }
 440         }
 441         return data;
 442     }
 443
 444     @Override
 445     public List<Object> getMultipleDataOnAddingConjunction(@SuppressWarnings("rawtypes") Class className,
 446             String columnName, List<String> data) {
 447         return null;
 448     }
 449
 450     public static void setSessionfactory(SessionFactory sessionfactory) {
 451         sessionFactory = sessionfactory;
 452     }
 453
 454 }