ONAP-REST/src/main/java/org/onap/policy/rest/daoimpl/PolicyValidationDaoImpl.java

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