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.Service;
  47
  48 @Service("CommonClassDao")
  49 @Primary
  50 public class CommonClassDaoImpl implements CommonClassDao{
  51
  52         private static final Logger LOGGER = FlexLogger.getLogger(CommonClassDaoImpl.class);
  53         private static SessionFactory sessionfactory;
  54
  55     public static SessionFactory getSessionfactory() {
  56           return sessionfactory;
  57     }
  58
  59     public static void setSessionfactory(SessionFactory sessionfactory) {
  60           CommonClassDaoImpl.sessionfactory = sessionfactory;
  61     }
  62
  63     @Autowired
  64     private CommonClassDaoImpl(SessionFactory sessionfactory){
  65           CommonClassDaoImpl.sessionfactory = sessionfactory;
  66     }
  67
  68     public CommonClassDaoImpl(){
  69           //Default Constructor
  70     }
  71
  72
  73
  74         @SuppressWarnings({ "unchecked", "rawtypes" })
  75         @Override
  76         public List<Object> getData(Class className) {
  77                 Session session = sessionfactory.openSession();
  78                 List<Object> data = null;
  79                 try{
  80                         Criteria cr = session.createCriteria(className);
  81                         data = cr.list();
  82                 }catch(Exception e){
  83                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
  84                 }finally{
  85                         try{
  86                                 session.close();
  87                         }catch(Exception e){
  88                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
  89                         }
  90                 }
  91                 return data;
  92         }
  93
  94
  95         @SuppressWarnings({ "rawtypes", "unchecked" })
  96         @Override
  97         public List<Object> getDataById(Class className, String columnName, String key) {
  98                 Session session = sessionfactory.openSession();
  99                 List<Object> data = null;
 100                 try {
 101                         Criteria cr = session.createCriteria(className);
 102                         if(columnName.contains(":") && key.contains(":")){
 103                                 String[] columns = columnName.split(":");
 104                                 String[] keys = key.split(":");
 105                                 for(int i=0; i < columns.length; i++){
 106                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 107                                 }
 108                         }else{
 109                                 cr.add(Restrictions.eq(columnName, key));
 110                         }
 111                         data = cr.list();
 112                 } catch (Exception e) {
 113                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 114                 }finally{
 115                         try{
 116                                 session.close();
 117                         }catch(Exception e1){
 118                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 119                         }
 120                 }
 121                 return data;
 122         }
 123
 124         @Override
 125         public void save(Object entity) {
 126                 Session session = sessionfactory.openSession();
 127                 Transaction tx = session.beginTransaction();
 128                 try {
 129                         session.persist(entity);
 130                         tx.commit();
 131                 }catch(Exception e){
 132                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table"+e);
 133                 }finally{
 134                         try{
 135                                 session.close();
 136                         }catch(Exception e1){
 137                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 138                         }
 139                 }
 140
 141         }
 142
 143         @Override
 144         public void delete(Object entity) {
 145                 Session session = sessionfactory.openSession();
 146                 Transaction tx = session.beginTransaction();
 147                 try {
 148                         session.delete(entity);
 149                         tx.commit();
 150                 }catch(Exception e){
 151                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table"+e);
 152                 }finally{
 153                         try{
 154                                 session.close();
 155                         }catch(Exception e1){
 156                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 157                         }
 158                 }
 159
 160         }
 161
 162
 163         @Override
 164         public void update(Object entity) {
 165                 Session session = sessionfactory.openSession();
 166                 Transaction tx = session.beginTransaction();
 167                 try {
 168                         session.update(entity);
 169                         tx.commit();
 170                 }catch(Exception e){
 171                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table"+e);
 172                 }finally{
 173                         try{
 174                                 session.close();
 175                         }catch(Exception e1){
 176                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 177                         }
 178                 }
 179
 180         }
 181
 182
 183         @SuppressWarnings({ "unchecked", "rawtypes" })
 184         @Override
 185         public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 186                 Session session = sessionfactory.openSession();
 187                 Transaction tx = session.beginTransaction();
 188                 List<Object> data = null;
 189                 String[] columnNames = null;
 190                 if(columnName != null && columnName.contains(":")){
 191                         columnNames = columnName.split(":");
 192                 }
 193                 String[] values = null;
 194                 if(value != null && value.contains(":")){
 195                         values = value.split(":");
 196                 }
 197                 try {
 198                         Criteria cr = session.createCriteria(className);
 199                         if(columnNames != null && values != null && columnNames.length == values.length){
 200                                 for (int i = 0; i < columnNames.length; i++){
 201                                         cr.add(Restrictions.eq(columnNames[i],values[i]));
 202                                 }
 203                         }else{
 204                                 cr.add(Restrictions.eq(columnName,value));
 205                         }
 206                         data = cr.list();
 207                         tx.commit();
 208                 } catch (Exception e) {
 209                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"+e + className);
 210                 }finally{
 211                         try{
 212                                 session.close();
 213                         }catch(Exception e1){
 214                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 215                         }
 216                 }
 217                 return data;
 218         }
 219
 220
 221         @SuppressWarnings("unchecked")
 222         @Override
 223         public List<PolicyRoles> getUserRoles() {
 224                 Session session = sessionfactory.openSession();
 225                 Transaction tx = session.beginTransaction();
 226                 List<PolicyRoles> rolesData = null;
 227                 try {
 228                         Criteria cr = session.createCriteria(PolicyRoles.class);
 229                         Disjunction disjunction = Restrictions.disjunction();
 230                         Conjunction conjunction1  = Restrictions.conjunction();
 231                         conjunction1.add(Restrictions.eq("role", "admin"));
 232                         Conjunction conjunction2  = Restrictions.conjunction();
 233                         conjunction2.add(Restrictions.eq("role", "editor"));
 234                         Conjunction conjunction3  = Restrictions.conjunction();
 235                         conjunction3.add(Restrictions.eq("role", "guest"));
 236                         disjunction.add(conjunction1);
 237                         disjunction.add(conjunction2);
 238                         disjunction.add(conjunction3);
 239                         rolesData = cr.add(disjunction).list();
 240                         tx.commit();
 241                 } catch (Exception e) {
 242                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table"+e);
 243                 }finally{
 244                         try{
 245                                 session.close();
 246                         }catch(Exception e1){
 247                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 248                         }
 249                 }
 250                 return rolesData;
 251         }
 252
 253
 254         @Override
 255         public List<Object> checkExistingGroupListforUpdate(String arg0, String arg1) {
 256                 return null;
 257         }
 258
 259
 260         @Override
 261         public void deleteAll() {}
 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 + "Error While Querying Database Table"+e);
 284                         throw e;
 285                 }finally{
 286                         try{
 287                                 session.close();
 288                         }catch(HibernateException e1){
 289                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+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 + "Error While Querying Database Table"+e);
 317                 }finally{
 318                         try{
 319                                 session.close();
 320                         }catch(Exception e1){
 321                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 322                         }
 323                 }
 324                 return data;
 325         }
 326
 327
 328         @Override
 329         public void updateClAlarms(String arg0, String arg1) {}
 330
 331
 332         @Override
 333         public void updateClYaml(String arg0, String arg1) {}
 334
 335
 336         @Override
 337         public void updateQuery(String query) {
 338                 Session session = sessionfactory.openSession();
 339                 Transaction tx = session.beginTransaction();
 340                 try {
 341                         Query hbquery = session.createQuery(query);
 342                         hbquery.executeUpdate();
 343                         tx.commit();
 344                 } catch (Exception e) {
 345                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e);
 346                 }finally{
 347                         try{
 348                                 session.close();
 349                         }catch(Exception e1){
 350                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 351                         }
 352                 }
 353
 354         }
 355
 356
 357         @SuppressWarnings({ "rawtypes", "unchecked" })
 358         @Override
 359         public List<String> getDataByColumn(Class className, String columnName) {
 360                 Session session = sessionfactory.openSession();
 361                 List<String> data = null;
 362                 try{
 363                         Criteria cr = session.createCriteria(className);
 364                         cr.setProjection(Projections.property(columnName));
 365                         data = cr.list();
 366                 }catch(Exception e){
 367                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 368                 }finally{
 369                         try{
 370                                 session.close();
 371                         }catch(Exception e){
 372                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
 373                         }
 374                 }
 375                 return data;
 376         }
 377
 378
 379         @SuppressWarnings({ "rawtypes", "unchecked" })
 380         @Override
 381         public List<Object> getMultipleDataOnAddingConjunction(Class className, String columnName, List<String> data) {
 382                 Session session = sessionfactory.openSession();
 383                 Transaction tx = session.beginTransaction();
 384                 List<Object> entityData = null;
 385                 try {
 386                         Criteria cr = session.createCriteria(className);
 387                         Disjunction disjunction = Restrictions.disjunction();
 388                         List<Conjunction> conjunctionList = new ArrayList<>();
 389                         String[] columNames = columnName.split(":");
 390                         for(int i =0; i < data.size(); i++){
 391                                 String[] entiySplit = data.get(i).split(":");
 392                                 Conjunction conjunction = Restrictions.conjunction();
 393                                 conjunction.add(Restrictions.eq(columNames[0], entiySplit[0]));
 394                                 conjunction.add(Restrictions.eq(columNames[1], entiySplit[1]));
 395                                 conjunctionList.add(conjunction);
 396                         }
 397                         for(int j =0 ; j < conjunctionList.size(); j++){
 398                                 disjunction.add(conjunctionList.get(j));
 399                         }
 400                         entityData = cr.add(disjunction).list();
 401                         tx.commit();
 402                 } catch (Exception e) {
 403                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" +className +e);
 404                 }finally{
 405                         try{
 406                                 session.close();
 407                         }catch(Exception e1){
 408                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 409                         }
 410                 }
 411                 return entityData;
 412         }
 413
 414 }