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