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 }