POLICY-SDK-APP/src/main/java/org/onap/policy/daoImp/CommonClassDaoImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP Policy Engine
   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.daoImp;
  22
  23 import java.util.ArrayList;
  24 import java.util.Collections;
  25 import java.util.List;
  26 import java.util.Map;
  27
  28 import javax.script.SimpleBindings;
  29
  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.Disjunction;
  38 import org.hibernate.criterion.Projections;
  39 import org.hibernate.criterion.Restrictions;
  40 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  41 import org.onap.policy.common.logging.flexlogger.Logger;
  42 import org.onap.policy.rest.dao.CommonClassDao;
  43 import org.onap.policy.rest.jpa.PolicyRoles;
  44 import org.onap.policy.xacml.api.XACMLErrorConstants;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.context.annotation.Primary;
  47 import org.springframework.stereotype.Service;
  48
  49 @Service("CommonClassDao")
  50 @Primary
  51 public class CommonClassDaoImpl implements CommonClassDao {
  52
  53     private static final Logger LOGGER = FlexLogger.getLogger(CommonClassDaoImpl.class);
  54     private static SessionFactory sessionfactory;
  55
  56     public static SessionFactory getSessionfactory() {
  57         return sessionfactory;
  58     }
  59
  60     public static void setSessionfactory(SessionFactory sessionfactory) {
  61         CommonClassDaoImpl.sessionfactory = sessionfactory;
  62     }
  63
  64     @Autowired
  65     private CommonClassDaoImpl(SessionFactory sessionfactory) {
  66         CommonClassDaoImpl.sessionfactory = sessionfactory;
  67     }
  68
  69     public CommonClassDaoImpl() {
  70         // Default Constructor
  71     }
  72
  73     @SuppressWarnings({"unchecked", "rawtypes"})
  74     @Override
  75     public List<Object> getData(Class className) {
  76         Session session = sessionfactory.openSession();
  77         List<Object> data = null;
  78         try {
  79             Criteria cr = session.createCriteria(className);
  80             data = cr.list();
  81         } catch (Exception e) {
  82             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
  83         } finally {
  84             try {
  85                 session.close();
  86             } catch (Exception e) {
  87                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e);
  88             }
  89         }
  90         return data;
  91     }
  92
  93     @SuppressWarnings({"rawtypes", "unchecked"})
  94     @Override
  95     public List<Object> getDataById(Class className, String columnName, String key) {
  96         Session session = sessionfactory.openSession();
  97         List<Object> data = null;
  98         try {
  99             Criteria cr = session.createCriteria(className);
 100             if (columnName.contains(":") && key.contains(":")) {
 101                 String[] columns = columnName.split(":");
 102                 String[] keys = key.split(":");
 103                 for (int i = 0; i < columns.length; i++) {
 104                     cr.add(Restrictions.eq(columns[i], keys[i]));
 105                 }
 106             } else {
 107                 cr.add(Restrictions.eq(columnName, key));
 108             }
 109             data = cr.list();
 110         } catch (Exception e) {
 111             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
 112         } finally {
 113             try {
 114                 session.close();
 115             } catch (Exception e1) {
 116                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 117             }
 118         }
 119         return data;
 120     }
 121
 122     @Override
 123     public void save(Object entity) {
 124         Session session = sessionfactory.openSession();
 125         Transaction tx = session.beginTransaction();
 126         try {
 127             session.persist(entity);
 128             tx.commit();
 129         } catch (Exception e) {
 130             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table" + e);
 131         } finally {
 132             try {
 133                 session.close();
 134             } catch (Exception e1) {
 135                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 136             }
 137         }
 138
 139     }
 140
 141     @Override
 142     public void delete(Object entity) {
 143         Session session = sessionfactory.openSession();
 144         Transaction tx = session.beginTransaction();
 145         try {
 146             session.delete(entity);
 147             tx.commit();
 148         } catch (Exception e) {
 149             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table" + e);
 150         } finally {
 151             try {
 152                 session.close();
 153             } catch (Exception e1) {
 154                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 155             }
 156         }
 157
 158     }
 159
 160     @Override
 161     public void update(Object entity) {
 162         Session session = sessionfactory.openSession();
 163         Transaction tx = session.beginTransaction();
 164         try {
 165             session.update(entity);
 166             tx.commit();
 167         } catch (Exception e) {
 168             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table" + e);
 169         } finally {
 170             try {
 171                 session.close();
 172             } catch (Exception e1) {
 173                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 174             }
 175         }
 176
 177     }
 178
 179     @SuppressWarnings({"unchecked", "rawtypes"})
 180     @Override
 181     public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 182         Session session = sessionfactory.openSession();
 183         Transaction tx = session.beginTransaction();
 184         List<Object> data = null;
 185         String[] columnNames = null;
 186         if (columnName != null && columnName.contains(":")) {
 187             columnNames = columnName.split(":");
 188         }
 189         String[] values = null;
 190         if (value != null && value.contains(":")) {
 191             values = value.split(":");
 192         }
 193         try {
 194             Criteria cr = session.createCriteria(className);
 195             if (columnNames != null && values != null && columnNames.length == values.length) {
 196                 for (int i = 0; i < columnNames.length; i++) {
 197                     cr.add(Restrictions.eq(columnNames[i], values[i]));
 198                 }
 199             } else {
 200                 cr.add(Restrictions.eq(columnName, value));
 201             }
 202             data = cr.list();
 203             tx.commit();
 204         } catch (Exception e) {
 205             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"
 206                     + e + className);
 207         } finally {
 208             try {
 209                 session.close();
 210             } catch (Exception e1) {
 211                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 212             }
 213         }
 214         return data;
 215     }
 216
 217     @SuppressWarnings("unchecked")
 218     @Override
 219     public List<PolicyRoles> getUserRoles() {
 220         Session session = sessionfactory.openSession();
 221         Transaction tx = session.beginTransaction();
 222         List<PolicyRoles> rolesData = null;
 223         try {
 224             Criteria cr = session.createCriteria(PolicyRoles.class);
 225             Disjunction disjunction = Restrictions.disjunction();
 226             Conjunction conjunction1 = Restrictions.conjunction();
 227             conjunction1.add(Restrictions.eq("role", "admin"));
 228             Conjunction conjunction2 = Restrictions.conjunction();
 229             conjunction2.add(Restrictions.eq("role", "editor"));
 230             Conjunction conjunction3 = Restrictions.conjunction();
 231             conjunction3.add(Restrictions.eq("role", "guest"));
 232             disjunction.add(conjunction1);
 233             disjunction.add(conjunction2);
 234             disjunction.add(conjunction3);
 235             rolesData = cr.add(disjunction).list();
 236             tx.commit();
 237         } catch (Exception e) {
 238             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table" + e);
 239         } finally {
 240             try {
 241                 session.close();
 242             } catch (Exception e1) {
 243                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 244             }
 245         }
 246         return rolesData;
 247     }
 248
 249     @Override
 250     public List<Object> checkExistingGroupListforUpdate(String arg0, String arg1) {
 251         return Collections.emptyList();
 252     }
 253
 254     @Override
 255     public void deleteAll() {
 256     }
 257
 258     @SuppressWarnings("unchecked")
 259     @Override
 260     public List<Object> getDataByQuery(String query, SimpleBindings params) {
 261         Session session = sessionfactory.openSession();
 262         Transaction tx = session.beginTransaction();
 263         List<Object> data = null;
 264         try {
 265             Query hbquery = session.createQuery(query);
 266             for (Map.Entry<String, Object> paramPair : params.entrySet()) {
 267                 if (paramPair.getValue() instanceof java.lang.Long) {
 268                     hbquery.setLong(paramPair.getKey(), (long) paramPair.getValue());
 269                 } else {
 270                     hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 271                 }
 272             }
 273             data = hbquery.list();
 274             tx.commit();
 275         } catch (Exception e) {
 276             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table" + e);
 277             throw e;
 278         } finally {
 279             try {
 280                 session.close();
 281             } catch (HibernateException e1) {
 282                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 283             }
 284         }
 285         return data;
 286     }
 287
 288     @SuppressWarnings("rawtypes")
 289     @Override
 290     public Object getEntityItem(Class className, String columnName, String key) {
 291         Session session = sessionfactory.openSession();
 292         Transaction tx = session.beginTransaction();
 293         Object data = null;
 294         try {
 295             Criteria cr = session.createCriteria(className);
 296             if (columnName.contains(":") && key.contains(":")) {
 297                 String[] columns = columnName.split(":");
 298                 String[] keys = key.split(":");
 299                 for (int i = 0; i < columns.length; i++) {
 300                     cr.add(Restrictions.eq(columns[i], keys[i]));
 301                 }
 302             } else {
 303                 cr.add(Restrictions.eq(columnName, key));
 304             }
 305             data = cr.list().get(0);
 306             tx.commit();
 307         } catch (Exception e) {
 308             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table" + e);
 309         } finally {
 310             try {
 311                 session.close();
 312             } catch (Exception e1) {
 313                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 314             }
 315         }
 316         return data;
 317     }
 318
 319     @Override
 320     public void updateClAlarms(String arg0, String arg1) {
 321     }
 322
 323     @Override
 324     public void updateClYaml(String arg0, String arg1) {
 325     }
 326
 327     @Override
 328     public void updateQuery(String query) {
 329         Session session = sessionfactory.openSession();
 330         Transaction tx = session.beginTransaction();
 331         try {
 332             Query hbquery = session.createQuery(query);
 333             hbquery.executeUpdate();
 334             tx.commit();
 335         } catch (Exception e) {
 336             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table" + e);
 337         } finally {
 338             try {
 339                 session.close();
 340             } catch (Exception e1) {
 341                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 342             }
 343         }
 344
 345     }
 346
 347     @SuppressWarnings({"rawtypes", "unchecked"})
 348     @Override
 349     public List<String> getDataByColumn(Class className, String columnName) {
 350         Session session = sessionfactory.openSession();
 351         List<String> data = null;
 352         try {
 353             Criteria cr = session.createCriteria(className);
 354             cr.setProjection(Projections.property(columnName));
 355             data = cr.list();
 356         } catch (Exception e) {
 357             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + e);
 358         } finally {
 359             try {
 360                 session.close();
 361             } catch (Exception e) {
 362                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e);
 363             }
 364         }
 365         return data;
 366     }
 367
 368     @SuppressWarnings({"rawtypes", "unchecked"})
 369     @Override
 370     public List<Object> getMultipleDataOnAddingConjunction(Class className, String columnName, List<String> data) {
 371         Session session = sessionfactory.openSession();
 372         Transaction tx = session.beginTransaction();
 373         List<Object> entityData = null;
 374         try {
 375             Criteria cr = session.createCriteria(className);
 376             Disjunction disjunction = Restrictions.disjunction();
 377             List<Conjunction> conjunctionList = new ArrayList<>();
 378             String[] columNames = columnName.split(":");
 379             for (int i = 0; i < data.size(); i++) {
 380                 String[] entiySplit = data.get(i).split(":");
 381                 Conjunction conjunction = Restrictions.conjunction();
 382                 conjunction.add(Restrictions.eq(columNames[0], entiySplit[0]));
 383                 conjunction.add(Restrictions.eq(columNames[1], entiySplit[1]));
 384                 conjunctionList.add(conjunction);
 385             }
 386             for (int j = 0; j < conjunctionList.size(); j++) {
 387                 disjunction.add(conjunctionList.get(j));
 388             }
 389             entityData = cr.add(disjunction).list();
 390             tx.commit();
 391         } catch (Exception e) {
 392             LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" + className + e);
 393         } finally {
 394             try {
 395                 session.close();
 396             } catch (Exception e1) {
 397                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement" + e1);
 398             }
 399         }
 400         return entityData;
 401     }
 402
 403 }