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.stereotype.Service;
  46
  47 @Service("CommonClassDao")
  48 public class CommonClassDaoImpl implements CommonClassDao{
  49
  50         private static final Logger LOGGER = FlexLogger.getLogger(CommonClassDaoImpl.class);
  51         private static SessionFactory sessionfactory;
  52
  53     public static SessionFactory getSessionfactory() {
  54           return sessionfactory;
  55     }
  56
  57     public static void setSessionfactory(SessionFactory sessionfactory) {
  58           CommonClassDaoImpl.sessionfactory = sessionfactory;
  59     }
  60
  61     @Autowired
  62     private CommonClassDaoImpl(SessionFactory sessionfactory){
  63           CommonClassDaoImpl.sessionfactory = sessionfactory;
  64     }
  65
  66     public CommonClassDaoImpl(){
  67           //Default Constructor
  68     }
  69
  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 + "Error While Querying Table"+e);
  82                 }finally{
  83                         try{
  84                                 session.close();
  85                         }catch(Exception e){
  86                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+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 + "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
 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 + "Error While Closing Connection/Statement"+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 + "Error While Closing Connection/Statement"+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 + "Error While Closing Connection/Statement"+e1);
 246                         }
 247                 }
 248                 return rolesData;
 249         }
 250
 251
 252         @Override
 253         public List<Object> checkExistingGroupListforUpdate(String arg0, String arg1) {
 254                 return null;
 255         }
 256
 257
 258         @Override
 259         public void deleteAll() {}
 260
 261
 262         @SuppressWarnings("unchecked")
 263         @Override
 264         public List<Object> getDataByQuery(String query, SimpleBindings params) {
 265                 Session session = sessionfactory.openSession();
 266                 Transaction tx = session.beginTransaction();
 267                 List<Object> data = null;
 268                 try {
 269                         Query hbquery = session.createQuery(query);
 270                         for (Map.Entry<String, Object> paramPair : params.entrySet()) {
 271                                 hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 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
 289         @SuppressWarnings("rawtypes")
 290         @Override
 291         public Object getEntityItem(Class className, String columnName, String key) {
 292                 Session session = sessionfactory.openSession();
 293                 Transaction tx = session.beginTransaction();
 294                 Object data = null;
 295                 try {
 296                         Criteria cr = session.createCriteria(className);
 297                         if(columnName.contains(":") && key.contains(":")){
 298                                 String[] columns = columnName.split(":");
 299                                 String[] keys = key.split(":");
 300                                 for(int i=0; i < columns.length; i++){
 301                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 302                                 }
 303                         }else{
 304                                 cr.add(Restrictions.eq(columnName, key));
 305                         }
 306                         data = cr.list().get(0);
 307                         tx.commit();
 308                 } catch (Exception e) {
 309                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 310                 }finally{
 311                         try{
 312                                 session.close();
 313                         }catch(Exception e1){
 314                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 315                         }
 316                 }
 317                 return data;
 318         }
 319
 320
 321         @Override
 322         public void updateClAlarms(String arg0, String arg1) {}
 323
 324
 325         @Override
 326         public void updateClYaml(String arg0, String arg1) {}
 327
 328
 329         @Override
 330         public void updateQuery(String query) {
 331                 Session session = sessionfactory.openSession();
 332                 Transaction tx = session.beginTransaction();
 333                 try {
 334                         Query hbquery = session.createQuery(query);
 335                         hbquery.executeUpdate();
 336                         tx.commit();
 337                 } catch (Exception e) {
 338                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e);
 339                 }finally{
 340                         try{
 341                                 session.close();
 342                         }catch(Exception e1){
 343                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 344                         }
 345                 }
 346
 347         }
 348
 349
 350         @SuppressWarnings({ "rawtypes", "unchecked" })
 351         @Override
 352         public List<String> getDataByColumn(Class className, String columnName) {
 353                 Session session = sessionfactory.openSession();
 354                 List<String> data = null;
 355                 try{
 356                         Criteria cr = session.createCriteria(className);
 357                         cr.setProjection(Projections.property(columnName));
 358                         data = cr.list();
 359                 }catch(Exception e){
 360                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 361                 }finally{
 362                         try{
 363                                 session.close();
 364                         }catch(Exception e){
 365                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
 366                         }
 367                 }
 368                 return data;
 369         }
 370
 371
 372         @SuppressWarnings({ "rawtypes", "unchecked" })
 373         @Override
 374         public List<Object> getMultipleDataOnAddingConjunction(Class className, String columnName, List<String> data) {
 375                 Session session = sessionfactory.openSession();
 376                 Transaction tx = session.beginTransaction();
 377                 List<Object> entityData = null;
 378                 try {
 379                         Criteria cr = session.createCriteria(className);
 380                         Disjunction disjunction = Restrictions.disjunction();
 381                         List<Conjunction> conjunctionList = new ArrayList<>();
 382                         String[] columNames = columnName.split(":");
 383                         for(int i =0; i < data.size(); i++){
 384                                 String[] entiySplit = data.get(i).split(":");
 385                                 Conjunction conjunction = Restrictions.conjunction();
 386                                 conjunction.add(Restrictions.eq(columNames[0], entiySplit[0]));
 387                                 conjunction.add(Restrictions.eq(columNames[1], entiySplit[1]));
 388                                 conjunctionList.add(conjunction);
 389                         }
 390                         for(int j =0 ; j < conjunctionList.size(); j++){
 391                                 disjunction.add(conjunctionList.get(j));
 392                         }
 393                         entityData = cr.add(disjunction).list();
 394                         tx.commit();
 395                 } catch (Exception e) {
 396                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" +className +e);
 397                 }finally{
 398                         try{
 399                                 session.close();
 400                         }catch(Exception e1){
 401                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 402                         }
 403                 }
 404                 return entityData;
 405         }
 406
 407 }